{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.Soup.Enums
    ( 
    catchXMLRPCError                        ,
    handleXMLRPCError                       ,
    catchTLDError                           ,
    handleTLDError                          ,
    catchRequesterError                     ,
    handleRequesterError                    ,
    catchRequestError                       ,
    handleRequestError                      ,

-- * Exported types
    XMLRPCFault(..)                         ,
    XMLRPCError(..)                         ,
    WebsocketState(..)                      ,
    WebsocketError(..)                      ,
    WebsocketDataType(..)                   ,
    WebsocketConnectionType(..)             ,
    WebsocketCloseCode(..)                  ,
    TLDError(..)                            ,
    Status(..)                              ,
    SocketIOStatus(..)                      ,
    RequesterError(..)                      ,
    RequestError(..)                        ,
    MessagePriority(..)                     ,
    MessageHeadersType(..)                  ,
    MemoryUse(..)                           ,
    LoggerLogLevel(..)                      ,
    KnownStatusCode(..)                     ,
    HTTPVersion(..)                         ,
    Encoding(..)                            ,
    DateFormat(..)                          ,
    CookieJarAcceptPolicy(..)               ,
    ConnectionState(..)                     ,
    CacheType(..)                           ,
    CacheResponse(..)                       ,
    AddressFamily(..)                       ,


    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP


-- Enum XMLRPCFault
{- |
Pre-defined XML-RPC fault codes from \<ulink
url=\"http:\/\/xmlrpc-epi.sourceforge.net\/specs\/rfc.fault_codes.php\">http:\/\/xmlrpc-epi.sourceforge.net\/specs\/rfc.fault_codes.php\<\/ulink>.
These are an extension, not part of the XML-RPC spec; you can\'t
assume servers will use them.
-}
data XMLRPCFault = 
      XMLRPCFaultParseErrorNotWellFormed
    {- ^
    request was not
      well-formed
    -}
    | XMLRPCFaultParseErrorUnsupportedEncoding
    {- ^
    request was in
      an unsupported encoding
    -}
    | XMLRPCFaultParseErrorInvalidCharacterForEncoding
    {- ^
    request contained an invalid character
    -}
    | XMLRPCFaultServerErrorInvalidXmlRpc
    {- ^
    request was not
      valid XML-RPC
    -}
    | XMLRPCFaultServerErrorRequestedMethodNotFound
    {- ^
    method
      not found
    -}
    | XMLRPCFaultServerErrorInvalidMethodParameters
    {- ^
    invalid
      parameters
    -}
    | XMLRPCFaultServerErrorInternalXmlRpcError
    {- ^
    internal
      error
    -}
    | XMLRPCFaultApplicationError
    {- ^
    start of reserved range for
      application error codes
    -}
    | XMLRPCFaultSystemError
    {- ^
    start of reserved range for
      system error codes
    -}
    | XMLRPCFaultTransportError
    {- ^
    start of reserved range for
      transport error codes
    -}
    | AnotherXMLRPCFault Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum XMLRPCFault where
    fromEnum XMLRPCFaultParseErrorNotWellFormed = -32700
    fromEnum XMLRPCFaultParseErrorUnsupportedEncoding = -32701
    fromEnum XMLRPCFaultParseErrorInvalidCharacterForEncoding = -32702
    fromEnum XMLRPCFaultServerErrorInvalidXmlRpc = -32600
    fromEnum XMLRPCFaultServerErrorRequestedMethodNotFound = -32601
    fromEnum XMLRPCFaultServerErrorInvalidMethodParameters = -32602
    fromEnum XMLRPCFaultServerErrorInternalXmlRpcError = -32603
    fromEnum XMLRPCFaultApplicationError = -32500
    fromEnum XMLRPCFaultSystemError = -32400
    fromEnum XMLRPCFaultTransportError = -32300
    fromEnum (AnotherXMLRPCFault k) = k

    toEnum -32700 = XMLRPCFaultParseErrorNotWellFormed
    toEnum -32701 = XMLRPCFaultParseErrorUnsupportedEncoding
    toEnum -32702 = XMLRPCFaultParseErrorInvalidCharacterForEncoding
    toEnum -32600 = XMLRPCFaultServerErrorInvalidXmlRpc
    toEnum -32601 = XMLRPCFaultServerErrorRequestedMethodNotFound
    toEnum -32602 = XMLRPCFaultServerErrorInvalidMethodParameters
    toEnum -32603 = XMLRPCFaultServerErrorInternalXmlRpcError
    toEnum -32500 = XMLRPCFaultApplicationError
    toEnum -32400 = XMLRPCFaultSystemError
    toEnum -32300 = XMLRPCFaultTransportError
    toEnum k = AnotherXMLRPCFault k

instance P.Ord XMLRPCFault where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_xmlrpc_fault_get_type" c_soup_xmlrpc_fault_get_type :: 
    IO GType

instance BoxedEnum XMLRPCFault where
    boxedEnumType _ = c_soup_xmlrpc_fault_get_type

-- Enum XMLRPCError
{- |
/No description available in the introspection data./
-}
data XMLRPCError = 
      XMLRPCErrorArguments
    {- ^
    /No description available in the introspection data./
    -}
    | XMLRPCErrorRetval
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherXMLRPCError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum XMLRPCError where
    fromEnum XMLRPCErrorArguments = 0
    fromEnum XMLRPCErrorRetval = 1
    fromEnum (AnotherXMLRPCError k) = k

    toEnum 0 = XMLRPCErrorArguments
    toEnum 1 = XMLRPCErrorRetval
    toEnum k = AnotherXMLRPCError k

instance P.Ord XMLRPCError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass XMLRPCError where
    gerrorClassDomain _ = "soup_xmlrpc_error_quark"

catchXMLRPCError ::
    IO a ->
    (XMLRPCError -> GErrorMessage -> IO a) ->
    IO a
catchXMLRPCError = catchGErrorJustDomain

handleXMLRPCError ::
    (XMLRPCError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleXMLRPCError = handleGErrorJustDomain

foreign import ccall "soup_xmlrpc_error_get_type" c_soup_xmlrpc_error_get_type :: 
    IO GType

instance BoxedEnum XMLRPCError where
    boxedEnumType _ = c_soup_xmlrpc_error_get_type

-- Enum WebsocketState
{- |
The state of the WebSocket connection.

@since 2.50
-}
data WebsocketState = 
      WebsocketStateOpen
    {- ^
    the connection is ready to send messages
    -}
    | WebsocketStateClosing
    {- ^
    the connection is in the process of
      closing down; messages may be received, but not sent
    -}
    | WebsocketStateClosed
    {- ^
    the connection is completely closed down
    -}
    | AnotherWebsocketState Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum WebsocketState where
    fromEnum WebsocketStateOpen = 1
    fromEnum WebsocketStateClosing = 2
    fromEnum WebsocketStateClosed = 3
    fromEnum (AnotherWebsocketState k) = k

    toEnum 1 = WebsocketStateOpen
    toEnum 2 = WebsocketStateClosing
    toEnum 3 = WebsocketStateClosed
    toEnum k = AnotherWebsocketState k

instance P.Ord WebsocketState where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_websocket_state_get_type" c_soup_websocket_state_get_type :: 
    IO GType

instance BoxedEnum WebsocketState where
    boxedEnumType _ = c_soup_websocket_state_get_type

-- Enum WebsocketError
{- |
WebSocket-related errors.

@since 2.50
-}
data WebsocketError = 
      WebsocketErrorFailed
    {- ^
    a generic error
    -}
    | WebsocketErrorNotWebsocket
    {- ^
    attempted to handshake with a
      server that does not appear to understand WebSockets.
    -}
    | WebsocketErrorBadHandshake
    {- ^
    the WebSocket handshake failed
      because some detail was invalid (eg, incorrect accept key).
    -}
    | WebsocketErrorBadOrigin
    {- ^
    the WebSocket handshake failed
      because the \"Origin\" header was not an allowed value.
    -}
    | AnotherWebsocketError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum WebsocketError where
    fromEnum WebsocketErrorFailed = 0
    fromEnum WebsocketErrorNotWebsocket = 1
    fromEnum WebsocketErrorBadHandshake = 2
    fromEnum WebsocketErrorBadOrigin = 3
    fromEnum (AnotherWebsocketError k) = k

    toEnum 0 = WebsocketErrorFailed
    toEnum 1 = WebsocketErrorNotWebsocket
    toEnum 2 = WebsocketErrorBadHandshake
    toEnum 3 = WebsocketErrorBadOrigin
    toEnum k = AnotherWebsocketError k

instance P.Ord WebsocketError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_websocket_error_get_type" c_soup_websocket_error_get_type :: 
    IO GType

instance BoxedEnum WebsocketError where
    boxedEnumType _ = c_soup_websocket_error_get_type

-- Enum WebsocketDataType
{- |
The type of data contained in a 'GI.Soup.Objects.WebsocketConnection.WebsocketConnection'::@/message/@
signal.

@since 2.50
-}
data WebsocketDataType = 
      WebsocketDataTypeText
    {- ^
    UTF-8 text
    -}
    | WebsocketDataTypeBinary
    {- ^
    binary data
    -}
    | AnotherWebsocketDataType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum WebsocketDataType where
    fromEnum WebsocketDataTypeText = 1
    fromEnum WebsocketDataTypeBinary = 2
    fromEnum (AnotherWebsocketDataType k) = k

    toEnum 1 = WebsocketDataTypeText
    toEnum 2 = WebsocketDataTypeBinary
    toEnum k = AnotherWebsocketDataType k

instance P.Ord WebsocketDataType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_websocket_data_type_get_type" c_soup_websocket_data_type_get_type :: 
    IO GType

instance BoxedEnum WebsocketDataType where
    boxedEnumType _ = c_soup_websocket_data_type_get_type

-- Enum WebsocketConnectionType
{- |
The type of a 'GI.Soup.Objects.WebsocketConnection.WebsocketConnection'.

@since 2.50
-}
data WebsocketConnectionType = 
      WebsocketConnectionTypeUnknown
    {- ^
    unknown\/invalid connection
    -}
    | WebsocketConnectionTypeClient
    {- ^
    a client-side connection
    -}
    | WebsocketConnectionTypeServer
    {- ^
    a server-side connection
    -}
    | AnotherWebsocketConnectionType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum WebsocketConnectionType where
    fromEnum WebsocketConnectionTypeUnknown = 0
    fromEnum WebsocketConnectionTypeClient = 1
    fromEnum WebsocketConnectionTypeServer = 2
    fromEnum (AnotherWebsocketConnectionType k) = k

    toEnum 0 = WebsocketConnectionTypeUnknown
    toEnum 1 = WebsocketConnectionTypeClient
    toEnum 2 = WebsocketConnectionTypeServer
    toEnum k = AnotherWebsocketConnectionType k

instance P.Ord WebsocketConnectionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_websocket_connection_type_get_type" c_soup_websocket_connection_type_get_type :: 
    IO GType

instance BoxedEnum WebsocketConnectionType where
    boxedEnumType _ = c_soup_websocket_connection_type_get_type

-- Enum WebsocketCloseCode
{- |
Pre-defined close codes that can be passed to
'GI.Soup.Objects.WebsocketConnection.websocketConnectionClose' or received from
'GI.Soup.Objects.WebsocketConnection.websocketConnectionGetCloseCode'. (However, other codes
are also allowed.)

@since 2.50
-}
data WebsocketCloseCode = 
      WebsocketCloseCodeNormal
    {- ^
    a normal, non-error close
    -}
    | WebsocketCloseCodeGoingAway
    {- ^
    the client\/server is going away
    -}
    | WebsocketCloseCodeProtocolError
    {- ^
    a protocol error occurred
    -}
    | WebsocketCloseCodeUnsupportedData
    {- ^
    the endpoint received data
      of a type that it does not support.
    -}
    | WebsocketCloseCodeNoStatus
    {- ^
    reserved value indicating that
      no close code was present; must not be sent.
    -}
    | WebsocketCloseCodeAbnormal
    {- ^
    reserved value indicating that
      the connection was closed abnormally; must not be sent.
    -}
    | WebsocketCloseCodeBadData
    {- ^
    the endpoint received data that
      was invalid (eg, non-UTF-8 data in a text message).
    -}
    | WebsocketCloseCodePolicyViolation
    {- ^
    generic error code
      indicating some sort of policy violation.
    -}
    | WebsocketCloseCodeTooBig
    {- ^
    the endpoint received a message
      that is too big to process.
    -}
    | WebsocketCloseCodeNoExtension
    {- ^
    the client is closing the
      connection because the server failed to negotiate a required
      extension.
    -}
    | WebsocketCloseCodeServerError
    {- ^
    the server is closing the
      connection because it was unable to fulfill the request.
    -}
    | WebsocketCloseCodeTlsHandshake
    {- ^
    reserved value indicating that
      the TLS handshake failed; must not be sent.
    -}
    | AnotherWebsocketCloseCode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum WebsocketCloseCode where
    fromEnum WebsocketCloseCodeNormal = 1000
    fromEnum WebsocketCloseCodeGoingAway = 1001
    fromEnum WebsocketCloseCodeProtocolError = 1002
    fromEnum WebsocketCloseCodeUnsupportedData = 1003
    fromEnum WebsocketCloseCodeNoStatus = 1005
    fromEnum WebsocketCloseCodeAbnormal = 1006
    fromEnum WebsocketCloseCodeBadData = 1007
    fromEnum WebsocketCloseCodePolicyViolation = 1008
    fromEnum WebsocketCloseCodeTooBig = 1009
    fromEnum WebsocketCloseCodeNoExtension = 1010
    fromEnum WebsocketCloseCodeServerError = 1011
    fromEnum WebsocketCloseCodeTlsHandshake = 1015
    fromEnum (AnotherWebsocketCloseCode k) = k

    toEnum 1000 = WebsocketCloseCodeNormal
    toEnum 1001 = WebsocketCloseCodeGoingAway
    toEnum 1002 = WebsocketCloseCodeProtocolError
    toEnum 1003 = WebsocketCloseCodeUnsupportedData
    toEnum 1005 = WebsocketCloseCodeNoStatus
    toEnum 1006 = WebsocketCloseCodeAbnormal
    toEnum 1007 = WebsocketCloseCodeBadData
    toEnum 1008 = WebsocketCloseCodePolicyViolation
    toEnum 1009 = WebsocketCloseCodeTooBig
    toEnum 1010 = WebsocketCloseCodeNoExtension
    toEnum 1011 = WebsocketCloseCodeServerError
    toEnum 1015 = WebsocketCloseCodeTlsHandshake
    toEnum k = AnotherWebsocketCloseCode k

instance P.Ord WebsocketCloseCode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_websocket_close_code_get_type" c_soup_websocket_close_code_get_type :: 
    IO GType

instance BoxedEnum WebsocketCloseCode where
    boxedEnumType _ = c_soup_websocket_close_code_get_type

-- Enum TLDError
{- |
Error codes for @/SOUP_TLD_ERROR/@.

@since 2.40
-}
data TLDError = 
      TLDErrorInvalidHostname
    {- ^
    A hostname was syntactically
      invalid.
    -}
    | TLDErrorIsIpAddress
    {- ^
    The passed-in \"hostname\" was
      actually an IP address (and thus has no base domain or
      public suffix).
    -}
    | TLDErrorNotEnoughDomains
    {- ^
    The passed-in hostname
      did not have enough components. Eg, calling
      'GI.Soup.Functions.tldGetBaseDomain' on \<literal>\"co.uk\"\<\/literal>.
    -}
    | TLDErrorNoBaseDomain
    {- ^
    The passed-in hostname has
      no recognized public suffix.
    -}
    | AnotherTLDError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TLDError where
    fromEnum TLDErrorInvalidHostname = 0
    fromEnum TLDErrorIsIpAddress = 1
    fromEnum TLDErrorNotEnoughDomains = 2
    fromEnum TLDErrorNoBaseDomain = 3
    fromEnum (AnotherTLDError k) = k

    toEnum 0 = TLDErrorInvalidHostname
    toEnum 1 = TLDErrorIsIpAddress
    toEnum 2 = TLDErrorNotEnoughDomains
    toEnum 3 = TLDErrorNoBaseDomain
    toEnum k = AnotherTLDError k

instance P.Ord TLDError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass TLDError where
    gerrorClassDomain _ = "soup_tld_error_quark"

catchTLDError ::
    IO a ->
    (TLDError -> GErrorMessage -> IO a) ->
    IO a
catchTLDError = catchGErrorJustDomain

handleTLDError ::
    (TLDError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleTLDError = handleGErrorJustDomain

foreign import ccall "soup_tld_error_get_type" c_soup_tld_error_get_type :: 
    IO GType

instance BoxedEnum TLDError where
    boxedEnumType _ = c_soup_tld_error_get_type

-- Enum Status
{- |
These represent the known HTTP status code values, plus various
network and internal errors.

Note that no libsoup functions take or return this type directly;
any function that works with status codes will accept unrecognized
status codes as well.

Prior to 2.44 this type was called
\<literal>SoupKnownStatusCode\<\/literal>, but the individual values
have always had the names they have now.
-}
data Status = 
      StatusNone
    {- ^
    No status available. (Eg, the message has not
    been sent yet)
    -}
    | StatusCancelled
    {- ^
    Message was cancelled locally
    -}
    | StatusCantResolve
    {- ^
    Unable to resolve destination host name
    -}
    | StatusCantResolveProxy
    {- ^
    Unable to resolve proxy host name
    -}
    | StatusCantConnect
    {- ^
    Unable to connect to remote host
    -}
    | StatusCantConnectProxy
    {- ^
    Unable to connect to proxy
    -}
    | StatusSslFailed
    {- ^
    SSL\/TLS negotiation failed
    -}
    | StatusIoError
    {- ^
    A network error occurred, or the other end
    closed the connection unexpectedly
    -}
    | StatusMalformed
    {- ^
    Malformed data (usually a programmer error)
    -}
    | StatusTryAgain
    {- ^
    Used internally
    -}
    | StatusTooManyRedirects
    {- ^
    There were too many redirections
    -}
    | StatusTlsFailed
    {- ^
    Used internally
    -}
    | StatusContinue
    {- ^
    100 Continue (HTTP)
    -}
    | StatusSwitchingProtocols
    {- ^
    101 Switching Protocols (HTTP)
    -}
    | StatusProcessing
    {- ^
    102 Processing (WebDAV)
    -}
    | StatusOk
    {- ^
    200 Success (HTTP). Also used by many lower-level
    soup routines to indicate success.
    -}
    | StatusCreated
    {- ^
    201 Created (HTTP)
    -}
    | StatusAccepted
    {- ^
    202 Accepted (HTTP)
    -}
    | StatusNonAuthoritative
    {- ^
    203 Non-Authoritative Information
    (HTTP)
    -}
    | StatusNoContent
    {- ^
    204 No Content (HTTP)
    -}
    | StatusResetContent
    {- ^
    205 Reset Content (HTTP)
    -}
    | StatusPartialContent
    {- ^
    206 Partial Content (HTTP)
    -}
    | StatusMultiStatus
    {- ^
    207 Multi-Status (WebDAV)
    -}
    | StatusMultipleChoices
    {- ^
    300 Multiple Choices (HTTP)
    -}
    | StatusMovedPermanently
    {- ^
    301 Moved Permanently (HTTP)
    -}
    | StatusFound
    {- ^
    302 Found (HTTP)
    -}
    | StatusMovedTemporarily
    {- ^
    302 Moved Temporarily (old name,
    RFC 2068)
    -}
    | StatusSeeOther
    {- ^
    303 See Other (HTTP)
    -}
    | StatusNotModified
    {- ^
    304 Not Modified (HTTP)
    -}
    | StatusUseProxy
    {- ^
    305 Use Proxy (HTTP)
    -}
    | StatusNotAppearingInThisProtocol
    {- ^
    306 [Unused] (HTTP)
    -}
    | StatusTemporaryRedirect
    {- ^
    307 Temporary Redirect (HTTP)
    -}
    | StatusBadRequest
    {- ^
    400 Bad Request (HTTP)
    -}
    | StatusUnauthorized
    {- ^
    401 Unauthorized (HTTP)
    -}
    | StatusPaymentRequired
    {- ^
    402 Payment Required (HTTP)
    -}
    | StatusForbidden
    {- ^
    403 Forbidden (HTTP)
    -}
    | StatusNotFound
    {- ^
    404 Not Found (HTTP)
    -}
    | StatusMethodNotAllowed
    {- ^
    405 Method Not Allowed (HTTP)
    -}
    | StatusNotAcceptable
    {- ^
    406 Not Acceptable (HTTP)
    -}
    | StatusProxyAuthenticationRequired
    {- ^
    407 Proxy Authentication
    Required (HTTP)
    -}
    | StatusProxyUnauthorized
    {- ^
    shorter alias for
    'GI.Soup.Enums.StatusProxyAuthenticationRequired'
    -}
    | StatusRequestTimeout
    {- ^
    408 Request Timeout (HTTP)
    -}
    | StatusConflict
    {- ^
    409 Conflict (HTTP)
    -}
    | StatusGone
    {- ^
    410 Gone (HTTP)
    -}
    | StatusLengthRequired
    {- ^
    411 Length Required (HTTP)
    -}
    | StatusPreconditionFailed
    {- ^
    412 Precondition Failed (HTTP)
    -}
    | StatusRequestEntityTooLarge
    {- ^
    413 Request Entity Too Large
    (HTTP)
    -}
    | StatusRequestUriTooLong
    {- ^
    414 Request-URI Too Long (HTTP)
    -}
    | StatusUnsupportedMediaType
    {- ^
    415 Unsupported Media Type
    (HTTP)
    -}
    | StatusRequestedRangeNotSatisfiable
    {- ^
    416 Requested Range
    Not Satisfiable (HTTP)
    -}
    | StatusInvalidRange
    {- ^
    shorter alias for
    'GI.Soup.Enums.StatusRequestedRangeNotSatisfiable'
    -}
    | StatusExpectationFailed
    {- ^
    417 Expectation Failed (HTTP)
    -}
    | StatusUnprocessableEntity
    {- ^
    422 Unprocessable Entity
    (WebDAV)
    -}
    | StatusLocked
    {- ^
    423 Locked (WebDAV)
    -}
    | StatusFailedDependency
    {- ^
    424 Failed Dependency (WebDAV)
    -}
    | StatusInternalServerError
    {- ^
    500 Internal Server Error
    (HTTP)
    -}
    | StatusNotImplemented
    {- ^
    501 Not Implemented (HTTP)
    -}
    | StatusBadGateway
    {- ^
    502 Bad Gateway (HTTP)
    -}
    | StatusServiceUnavailable
    {- ^
    503 Service Unavailable (HTTP)
    -}
    | StatusGatewayTimeout
    {- ^
    504 Gateway Timeout (HTTP)
    -}
    | StatusHttpVersionNotSupported
    {- ^
    505 HTTP Version Not
    Supported (HTTP)
    -}
    | StatusInsufficientStorage
    {- ^
    507 Insufficient Storage
    (WebDAV)
    -}
    | StatusNotExtended
    {- ^
    510 Not Extended (RFC 2774)
    -}
    | AnotherStatus Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum Status where
    fromEnum StatusNone = 0
    fromEnum StatusCancelled = 1
    fromEnum StatusCantResolve = 2
    fromEnum StatusCantResolveProxy = 3
    fromEnum StatusCantConnect = 4
    fromEnum StatusCantConnectProxy = 5
    fromEnum StatusSslFailed = 6
    fromEnum StatusIoError = 7
    fromEnum StatusMalformed = 8
    fromEnum StatusTryAgain = 9
    fromEnum StatusTooManyRedirects = 10
    fromEnum StatusTlsFailed = 11
    fromEnum StatusContinue = 100
    fromEnum StatusSwitchingProtocols = 101
    fromEnum StatusProcessing = 102
    fromEnum StatusOk = 200
    fromEnum StatusCreated = 201
    fromEnum StatusAccepted = 202
    fromEnum StatusNonAuthoritative = 203
    fromEnum StatusNoContent = 204
    fromEnum StatusResetContent = 205
    fromEnum StatusPartialContent = 206
    fromEnum StatusMultiStatus = 207
    fromEnum StatusMultipleChoices = 300
    fromEnum StatusMovedPermanently = 301
    fromEnum StatusFound = 302
    fromEnum StatusMovedTemporarily = 302
    fromEnum StatusSeeOther = 303
    fromEnum StatusNotModified = 304
    fromEnum StatusUseProxy = 305
    fromEnum StatusNotAppearingInThisProtocol = 306
    fromEnum StatusTemporaryRedirect = 307
    fromEnum StatusBadRequest = 400
    fromEnum StatusUnauthorized = 401
    fromEnum StatusPaymentRequired = 402
    fromEnum StatusForbidden = 403
    fromEnum StatusNotFound = 404
    fromEnum StatusMethodNotAllowed = 405
    fromEnum StatusNotAcceptable = 406
    fromEnum StatusProxyAuthenticationRequired = 407
    fromEnum StatusProxyUnauthorized = 407
    fromEnum StatusRequestTimeout = 408
    fromEnum StatusConflict = 409
    fromEnum StatusGone = 410
    fromEnum StatusLengthRequired = 411
    fromEnum StatusPreconditionFailed = 412
    fromEnum StatusRequestEntityTooLarge = 413
    fromEnum StatusRequestUriTooLong = 414
    fromEnum StatusUnsupportedMediaType = 415
    fromEnum StatusRequestedRangeNotSatisfiable = 416
    fromEnum StatusInvalidRange = 416
    fromEnum StatusExpectationFailed = 417
    fromEnum StatusUnprocessableEntity = 422
    fromEnum StatusLocked = 423
    fromEnum StatusFailedDependency = 424
    fromEnum StatusInternalServerError = 500
    fromEnum StatusNotImplemented = 501
    fromEnum StatusBadGateway = 502
    fromEnum StatusServiceUnavailable = 503
    fromEnum StatusGatewayTimeout = 504
    fromEnum StatusHttpVersionNotSupported = 505
    fromEnum StatusInsufficientStorage = 507
    fromEnum StatusNotExtended = 510
    fromEnum (AnotherStatus k) = k

    toEnum 0 = StatusNone
    toEnum 1 = StatusCancelled
    toEnum 2 = StatusCantResolve
    toEnum 3 = StatusCantResolveProxy
    toEnum 4 = StatusCantConnect
    toEnum 5 = StatusCantConnectProxy
    toEnum 6 = StatusSslFailed
    toEnum 7 = StatusIoError
    toEnum 8 = StatusMalformed
    toEnum 9 = StatusTryAgain
    toEnum 10 = StatusTooManyRedirects
    toEnum 11 = StatusTlsFailed
    toEnum 100 = StatusContinue
    toEnum 101 = StatusSwitchingProtocols
    toEnum 102 = StatusProcessing
    toEnum 200 = StatusOk
    toEnum 201 = StatusCreated
    toEnum 202 = StatusAccepted
    toEnum 203 = StatusNonAuthoritative
    toEnum 204 = StatusNoContent
    toEnum 205 = StatusResetContent
    toEnum 206 = StatusPartialContent
    toEnum 207 = StatusMultiStatus
    toEnum 300 = StatusMultipleChoices
    toEnum 301 = StatusMovedPermanently
    toEnum 302 = StatusFound
    toEnum 302 = StatusMovedTemporarily
    toEnum 303 = StatusSeeOther
    toEnum 304 = StatusNotModified
    toEnum 305 = StatusUseProxy
    toEnum 306 = StatusNotAppearingInThisProtocol
    toEnum 307 = StatusTemporaryRedirect
    toEnum 400 = StatusBadRequest
    toEnum 401 = StatusUnauthorized
    toEnum 402 = StatusPaymentRequired
    toEnum 403 = StatusForbidden
    toEnum 404 = StatusNotFound
    toEnum 405 = StatusMethodNotAllowed
    toEnum 406 = StatusNotAcceptable
    toEnum 407 = StatusProxyAuthenticationRequired
    toEnum 407 = StatusProxyUnauthorized
    toEnum 408 = StatusRequestTimeout
    toEnum 409 = StatusConflict
    toEnum 410 = StatusGone
    toEnum 411 = StatusLengthRequired
    toEnum 412 = StatusPreconditionFailed
    toEnum 413 = StatusRequestEntityTooLarge
    toEnum 414 = StatusRequestUriTooLong
    toEnum 415 = StatusUnsupportedMediaType
    toEnum 416 = StatusRequestedRangeNotSatisfiable
    toEnum 416 = StatusInvalidRange
    toEnum 417 = StatusExpectationFailed
    toEnum 422 = StatusUnprocessableEntity
    toEnum 423 = StatusLocked
    toEnum 424 = StatusFailedDependency
    toEnum 500 = StatusInternalServerError
    toEnum 501 = StatusNotImplemented
    toEnum 502 = StatusBadGateway
    toEnum 503 = StatusServiceUnavailable
    toEnum 504 = StatusGatewayTimeout
    toEnum 505 = StatusHttpVersionNotSupported
    toEnum 507 = StatusInsufficientStorage
    toEnum 510 = StatusNotExtended
    toEnum k = AnotherStatus k

instance P.Ord Status where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_status_get_type" c_soup_status_get_type :: 
    IO GType

instance BoxedEnum Status where
    boxedEnumType _ = c_soup_status_get_type

-- Enum SocketIOStatus
{- |
Return value from the 'GI.Soup.Objects.Socket.Socket' IO methods.
-}
data SocketIOStatus = 
      SocketIOStatusOk
    {- ^
    Success
    -}
    | SocketIOStatusWouldBlock
    {- ^
    Cannot read\/write any more at this time
    -}
    | SocketIOStatusEof
    {- ^
    End of file
    -}
    | SocketIOStatusError
    {- ^
    Other error
    -}
    | AnotherSocketIOStatus Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SocketIOStatus where
    fromEnum SocketIOStatusOk = 0
    fromEnum SocketIOStatusWouldBlock = 1
    fromEnum SocketIOStatusEof = 2
    fromEnum SocketIOStatusError = 3
    fromEnum (AnotherSocketIOStatus k) = k

    toEnum 0 = SocketIOStatusOk
    toEnum 1 = SocketIOStatusWouldBlock
    toEnum 2 = SocketIOStatusEof
    toEnum 3 = SocketIOStatusError
    toEnum k = AnotherSocketIOStatus k

instance P.Ord SocketIOStatus where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_socket_io_status_get_type" c_soup_socket_io_status_get_type :: 
    IO GType

instance BoxedEnum SocketIOStatus where
    boxedEnumType _ = c_soup_socket_io_status_get_type

-- Enum RequesterError
{- |
/No description available in the introspection data./
-}
data RequesterError = 
      RequesterErrorBadUri
    {- ^
    /No description available in the introspection data./
    -}
    | RequesterErrorUnsupportedUriScheme
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherRequesterError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RequesterError where
    fromEnum RequesterErrorBadUri = 0
    fromEnum RequesterErrorUnsupportedUriScheme = 1
    fromEnum (AnotherRequesterError k) = k

    toEnum 0 = RequesterErrorBadUri
    toEnum 1 = RequesterErrorUnsupportedUriScheme
    toEnum k = AnotherRequesterError k

instance P.Ord RequesterError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass RequesterError where
    gerrorClassDomain _ = "soup_requester_error_quark"

catchRequesterError ::
    IO a ->
    (RequesterError -> GErrorMessage -> IO a) ->
    IO a
catchRequesterError = catchGErrorJustDomain

handleRequesterError ::
    (RequesterError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleRequesterError = handleGErrorJustDomain

foreign import ccall "soup_requester_error_get_type" c_soup_requester_error_get_type :: 
    IO GType

instance BoxedEnum RequesterError where
    boxedEnumType _ = c_soup_requester_error_get_type

-- Enum RequestError
{- |
A 'GI.Soup.Objects.Request.Request' error.

@since 2.42
-}
data RequestError = 
      RequestErrorBadUri
    {- ^
    the URI could not be parsed
    -}
    | RequestErrorUnsupportedUriScheme
    {- ^
    the URI scheme is not
      supported by this 'GI.Soup.Objects.Session.Session'
    -}
    | RequestErrorParsing
    {- ^
    the server\'s response could not
      be parsed
    -}
    | RequestErrorEncoding
    {- ^
    the server\'s response was in an
      unsupported format
    -}
    | AnotherRequestError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RequestError where
    fromEnum RequestErrorBadUri = 0
    fromEnum RequestErrorUnsupportedUriScheme = 1
    fromEnum RequestErrorParsing = 2
    fromEnum RequestErrorEncoding = 3
    fromEnum (AnotherRequestError k) = k

    toEnum 0 = RequestErrorBadUri
    toEnum 1 = RequestErrorUnsupportedUriScheme
    toEnum 2 = RequestErrorParsing
    toEnum 3 = RequestErrorEncoding
    toEnum k = AnotherRequestError k

instance P.Ord RequestError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass RequestError where
    gerrorClassDomain _ = "soup_request_error_quark"

catchRequestError ::
    IO a ->
    (RequestError -> GErrorMessage -> IO a) ->
    IO a
catchRequestError = catchGErrorJustDomain

handleRequestError ::
    (RequestError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleRequestError = handleGErrorJustDomain

foreign import ccall "soup_request_error_get_type" c_soup_request_error_get_type :: 
    IO GType

instance BoxedEnum RequestError where
    boxedEnumType _ = c_soup_request_error_get_type

-- Enum MessagePriority
{- |
Priorities that can be set on a 'GI.Soup.Objects.Message.Message' to instruct the
message queue to process it before any other message with lower
priority.
-}
data MessagePriority = 
      MessagePriorityVeryLow
    {- ^
    The lowest priority, the messages
      with this priority will be the last ones to be attended.
    -}
    | MessagePriorityLow
    {- ^
    Use this for low priority messages, a
      'GI.Soup.Objects.Message.Message' with the default priority will be processed first.
    -}
    | MessagePriorityNormal
    {- ^
    The default priotity, this is the
      priority assigned to the 'GI.Soup.Objects.Message.Message' by default.
    -}
    | MessagePriorityHigh
    {- ^
    High priority, a 'GI.Soup.Objects.Message.Message' with
      this priority will be processed before the ones with the default
      priority.
    -}
    | MessagePriorityVeryHigh
    {- ^
    The highest priority, use this
      for very urgent 'GI.Soup.Objects.Message.Message' as they will be the first ones to be
      attended.
    -}
    | AnotherMessagePriority Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MessagePriority where
    fromEnum MessagePriorityVeryLow = 0
    fromEnum MessagePriorityLow = 1
    fromEnum MessagePriorityNormal = 2
    fromEnum MessagePriorityHigh = 3
    fromEnum MessagePriorityVeryHigh = 4
    fromEnum (AnotherMessagePriority k) = k

    toEnum 0 = MessagePriorityVeryLow
    toEnum 1 = MessagePriorityLow
    toEnum 2 = MessagePriorityNormal
    toEnum 3 = MessagePriorityHigh
    toEnum 4 = MessagePriorityVeryHigh
    toEnum k = AnotherMessagePriority k

instance P.Ord MessagePriority where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_message_priority_get_type" c_soup_message_priority_get_type :: 
    IO GType

instance BoxedEnum MessagePriority where
    boxedEnumType _ = c_soup_message_priority_get_type

-- Enum MessageHeadersType
{- |
Value passed to 'GI.Soup.Structs.MessageHeaders.messageHeadersNew' to set certain default
behaviors.
-}
data MessageHeadersType = 
      MessageHeadersTypeRequest
    {- ^
    request headers
    -}
    | MessageHeadersTypeResponse
    {- ^
    response headers
    -}
    | MessageHeadersTypeMultipart
    {- ^
    multipart body part headers
    -}
    | AnotherMessageHeadersType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MessageHeadersType where
    fromEnum MessageHeadersTypeRequest = 0
    fromEnum MessageHeadersTypeResponse = 1
    fromEnum MessageHeadersTypeMultipart = 2
    fromEnum (AnotherMessageHeadersType k) = k

    toEnum 0 = MessageHeadersTypeRequest
    toEnum 1 = MessageHeadersTypeResponse
    toEnum 2 = MessageHeadersTypeMultipart
    toEnum k = AnotherMessageHeadersType k

instance P.Ord MessageHeadersType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_message_headers_type_get_type" c_soup_message_headers_type_get_type :: 
    IO GType

instance BoxedEnum MessageHeadersType where
    boxedEnumType _ = c_soup_message_headers_type_get_type

-- Enum MemoryUse
{- |
Describes how 'GI.Soup.Structs.Buffer.Buffer' should use the data passed in by the
caller.

See also 'GI.Soup.Structs.Buffer.bufferNewWithOwner', which allows to you create a
buffer containing data which is owned by another object.
-}
data MemoryUse = 
      MemoryUseStatic
    {- ^
    The memory is statically allocated and
    constant; libsoup can use the passed-in buffer directly and not
    need to worry about it being modified or freed.
    -}
    | MemoryUseTake
    {- ^
    The caller has allocated the memory for the
    'GI.Soup.Structs.Buffer.Buffer'\'s use; libsoup will assume ownership of it and free it
    (with 'GI.GLib.Functions.free') when it is done with it.
    -}
    | MemoryUseCopy
    {- ^
    The passed-in data belongs to the caller; the
    'GI.Soup.Structs.Buffer.Buffer' will copy it into new memory, leaving the caller free
    to reuse the original memory.
    -}
    | MemoryUseTemporary
    {- ^
    The passed-in data belongs to the caller,
    but will remain valid for the lifetime of the 'GI.Soup.Structs.Buffer.Buffer'. The
    difference between this and /@sOUPMEMORYSTATIC@/ is that if you copy
    a /@sOUPMEMORYTEMPORARY@/ buffer, it will make a copy of the memory
    as well, rather than reusing the original memory.
    -}
    | AnotherMemoryUse Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MemoryUse where
    fromEnum MemoryUseStatic = 0
    fromEnum MemoryUseTake = 1
    fromEnum MemoryUseCopy = 2
    fromEnum MemoryUseTemporary = 3
    fromEnum (AnotherMemoryUse k) = k

    toEnum 0 = MemoryUseStatic
    toEnum 1 = MemoryUseTake
    toEnum 2 = MemoryUseCopy
    toEnum 3 = MemoryUseTemporary
    toEnum k = AnotherMemoryUse k

instance P.Ord MemoryUse where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_memory_use_get_type" c_soup_memory_use_get_type :: 
    IO GType

instance BoxedEnum MemoryUse where
    boxedEnumType _ = c_soup_memory_use_get_type

-- Enum LoggerLogLevel
{- |
Describes the level of logging output to provide.
-}
data LoggerLogLevel = 
      LoggerLogLevelNone
    {- ^
    No logging
    -}
    | LoggerLogLevelMinimal
    {- ^
    Log the Request-Line or Status-Line and
    the Soup-Debug pseudo-headers
    -}
    | LoggerLogLevelHeaders
    {- ^
    Log the full request\/response headers
    -}
    | LoggerLogLevelBody
    {- ^
    Log the full headers and request\/response
    bodies.
    -}
    | AnotherLoggerLogLevel Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum LoggerLogLevel where
    fromEnum LoggerLogLevelNone = 0
    fromEnum LoggerLogLevelMinimal = 1
    fromEnum LoggerLogLevelHeaders = 2
    fromEnum LoggerLogLevelBody = 3
    fromEnum (AnotherLoggerLogLevel k) = k

    toEnum 0 = LoggerLogLevelNone
    toEnum 1 = LoggerLogLevelMinimal
    toEnum 2 = LoggerLogLevelHeaders
    toEnum 3 = LoggerLogLevelBody
    toEnum k = AnotherLoggerLogLevel k

instance P.Ord LoggerLogLevel where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_logger_log_level_get_type" c_soup_logger_log_level_get_type :: 
    IO GType

instance BoxedEnum LoggerLogLevel where
    boxedEnumType _ = c_soup_logger_log_level_get_type

-- Enum KnownStatusCode
{- |
/No description available in the introspection data./
-}
data KnownStatusCode = 
      KnownStatusCodeNone
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeCancelled
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeCantResolve
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeCantResolveProxy
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeCantConnect
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeCantConnectProxy
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeSslFailed
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeIoError
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeMalformed
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeTryAgain
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeTooManyRedirects
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeTlsFailed
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeContinue
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeSwitchingProtocols
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeProcessing
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeOk
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeCreated
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeAccepted
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNonAuthoritative
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNoContent
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeResetContent
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodePartialContent
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeMultiStatus
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeMultipleChoices
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeMovedPermanently
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeFound
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeMovedTemporarily
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeSeeOther
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNotModified
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeUseProxy
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNotAppearingInThisProtocol
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeTemporaryRedirect
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeBadRequest
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeUnauthorized
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodePaymentRequired
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeForbidden
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNotFound
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeMethodNotAllowed
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNotAcceptable
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeProxyAuthenticationRequired
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeProxyUnauthorized
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeRequestTimeout
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeConflict
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeGone
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeLengthRequired
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodePreconditionFailed
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeRequestEntityTooLarge
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeRequestUriTooLong
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeUnsupportedMediaType
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeRequestedRangeNotSatisfiable
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeInvalidRange
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeExpectationFailed
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeUnprocessableEntity
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeLocked
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeFailedDependency
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeInternalServerError
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNotImplemented
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeBadGateway
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeServiceUnavailable
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeGatewayTimeout
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeHttpVersionNotSupported
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeInsufficientStorage
    {- ^
    /No description available in the introspection data./
    -}
    | KnownStatusCodeNotExtended
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherKnownStatusCode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum KnownStatusCode where
    fromEnum KnownStatusCodeNone = 0
    fromEnum KnownStatusCodeCancelled = 1
    fromEnum KnownStatusCodeCantResolve = 2
    fromEnum KnownStatusCodeCantResolveProxy = 3
    fromEnum KnownStatusCodeCantConnect = 4
    fromEnum KnownStatusCodeCantConnectProxy = 5
    fromEnum KnownStatusCodeSslFailed = 6
    fromEnum KnownStatusCodeIoError = 7
    fromEnum KnownStatusCodeMalformed = 8
    fromEnum KnownStatusCodeTryAgain = 9
    fromEnum KnownStatusCodeTooManyRedirects = 10
    fromEnum KnownStatusCodeTlsFailed = 11
    fromEnum KnownStatusCodeContinue = 100
    fromEnum KnownStatusCodeSwitchingProtocols = 101
    fromEnum KnownStatusCodeProcessing = 102
    fromEnum KnownStatusCodeOk = 200
    fromEnum KnownStatusCodeCreated = 201
    fromEnum KnownStatusCodeAccepted = 202
    fromEnum KnownStatusCodeNonAuthoritative = 203
    fromEnum KnownStatusCodeNoContent = 204
    fromEnum KnownStatusCodeResetContent = 205
    fromEnum KnownStatusCodePartialContent = 206
    fromEnum KnownStatusCodeMultiStatus = 207
    fromEnum KnownStatusCodeMultipleChoices = 300
    fromEnum KnownStatusCodeMovedPermanently = 301
    fromEnum KnownStatusCodeFound = 302
    fromEnum KnownStatusCodeMovedTemporarily = 302
    fromEnum KnownStatusCodeSeeOther = 303
    fromEnum KnownStatusCodeNotModified = 304
    fromEnum KnownStatusCodeUseProxy = 305
    fromEnum KnownStatusCodeNotAppearingInThisProtocol = 306
    fromEnum KnownStatusCodeTemporaryRedirect = 307
    fromEnum KnownStatusCodeBadRequest = 400
    fromEnum KnownStatusCodeUnauthorized = 401
    fromEnum KnownStatusCodePaymentRequired = 402
    fromEnum KnownStatusCodeForbidden = 403
    fromEnum KnownStatusCodeNotFound = 404
    fromEnum KnownStatusCodeMethodNotAllowed = 405
    fromEnum KnownStatusCodeNotAcceptable = 406
    fromEnum KnownStatusCodeProxyAuthenticationRequired = 407
    fromEnum KnownStatusCodeProxyUnauthorized = 407
    fromEnum KnownStatusCodeRequestTimeout = 408
    fromEnum KnownStatusCodeConflict = 409
    fromEnum KnownStatusCodeGone = 410
    fromEnum KnownStatusCodeLengthRequired = 411
    fromEnum KnownStatusCodePreconditionFailed = 412
    fromEnum KnownStatusCodeRequestEntityTooLarge = 413
    fromEnum KnownStatusCodeRequestUriTooLong = 414
    fromEnum KnownStatusCodeUnsupportedMediaType = 415
    fromEnum KnownStatusCodeRequestedRangeNotSatisfiable = 416
    fromEnum KnownStatusCodeInvalidRange = 416
    fromEnum KnownStatusCodeExpectationFailed = 417
    fromEnum KnownStatusCodeUnprocessableEntity = 422
    fromEnum KnownStatusCodeLocked = 423
    fromEnum KnownStatusCodeFailedDependency = 424
    fromEnum KnownStatusCodeInternalServerError = 500
    fromEnum KnownStatusCodeNotImplemented = 501
    fromEnum KnownStatusCodeBadGateway = 502
    fromEnum KnownStatusCodeServiceUnavailable = 503
    fromEnum KnownStatusCodeGatewayTimeout = 504
    fromEnum KnownStatusCodeHttpVersionNotSupported = 505
    fromEnum KnownStatusCodeInsufficientStorage = 507
    fromEnum KnownStatusCodeNotExtended = 510
    fromEnum (AnotherKnownStatusCode k) = k

    toEnum 0 = KnownStatusCodeNone
    toEnum 1 = KnownStatusCodeCancelled
    toEnum 2 = KnownStatusCodeCantResolve
    toEnum 3 = KnownStatusCodeCantResolveProxy
    toEnum 4 = KnownStatusCodeCantConnect
    toEnum 5 = KnownStatusCodeCantConnectProxy
    toEnum 6 = KnownStatusCodeSslFailed
    toEnum 7 = KnownStatusCodeIoError
    toEnum 8 = KnownStatusCodeMalformed
    toEnum 9 = KnownStatusCodeTryAgain
    toEnum 10 = KnownStatusCodeTooManyRedirects
    toEnum 11 = KnownStatusCodeTlsFailed
    toEnum 100 = KnownStatusCodeContinue
    toEnum 101 = KnownStatusCodeSwitchingProtocols
    toEnum 102 = KnownStatusCodeProcessing
    toEnum 200 = KnownStatusCodeOk
    toEnum 201 = KnownStatusCodeCreated
    toEnum 202 = KnownStatusCodeAccepted
    toEnum 203 = KnownStatusCodeNonAuthoritative
    toEnum 204 = KnownStatusCodeNoContent
    toEnum 205 = KnownStatusCodeResetContent
    toEnum 206 = KnownStatusCodePartialContent
    toEnum 207 = KnownStatusCodeMultiStatus
    toEnum 300 = KnownStatusCodeMultipleChoices
    toEnum 301 = KnownStatusCodeMovedPermanently
    toEnum 302 = KnownStatusCodeFound
    toEnum 302 = KnownStatusCodeMovedTemporarily
    toEnum 303 = KnownStatusCodeSeeOther
    toEnum 304 = KnownStatusCodeNotModified
    toEnum 305 = KnownStatusCodeUseProxy
    toEnum 306 = KnownStatusCodeNotAppearingInThisProtocol
    toEnum 307 = KnownStatusCodeTemporaryRedirect
    toEnum 400 = KnownStatusCodeBadRequest
    toEnum 401 = KnownStatusCodeUnauthorized
    toEnum 402 = KnownStatusCodePaymentRequired
    toEnum 403 = KnownStatusCodeForbidden
    toEnum 404 = KnownStatusCodeNotFound
    toEnum 405 = KnownStatusCodeMethodNotAllowed
    toEnum 406 = KnownStatusCodeNotAcceptable
    toEnum 407 = KnownStatusCodeProxyAuthenticationRequired
    toEnum 407 = KnownStatusCodeProxyUnauthorized
    toEnum 408 = KnownStatusCodeRequestTimeout
    toEnum 409 = KnownStatusCodeConflict
    toEnum 410 = KnownStatusCodeGone
    toEnum 411 = KnownStatusCodeLengthRequired
    toEnum 412 = KnownStatusCodePreconditionFailed
    toEnum 413 = KnownStatusCodeRequestEntityTooLarge
    toEnum 414 = KnownStatusCodeRequestUriTooLong
    toEnum 415 = KnownStatusCodeUnsupportedMediaType
    toEnum 416 = KnownStatusCodeRequestedRangeNotSatisfiable
    toEnum 416 = KnownStatusCodeInvalidRange
    toEnum 417 = KnownStatusCodeExpectationFailed
    toEnum 422 = KnownStatusCodeUnprocessableEntity
    toEnum 423 = KnownStatusCodeLocked
    toEnum 424 = KnownStatusCodeFailedDependency
    toEnum 500 = KnownStatusCodeInternalServerError
    toEnum 501 = KnownStatusCodeNotImplemented
    toEnum 502 = KnownStatusCodeBadGateway
    toEnum 503 = KnownStatusCodeServiceUnavailable
    toEnum 504 = KnownStatusCodeGatewayTimeout
    toEnum 505 = KnownStatusCodeHttpVersionNotSupported
    toEnum 507 = KnownStatusCodeInsufficientStorage
    toEnum 510 = KnownStatusCodeNotExtended
    toEnum k = AnotherKnownStatusCode k

instance P.Ord KnownStatusCode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_known_status_code_get_type" c_soup_known_status_code_get_type :: 
    IO GType

instance BoxedEnum KnownStatusCode where
    boxedEnumType _ = c_soup_known_status_code_get_type

-- Enum HTTPVersion
{- |
Indicates the HTTP protocol version being used.
-}
data HTTPVersion = 
      HTTPVersionHttp10
    {- ^
    HTTP 1.0 (RFC 1945)
    -}
    | HTTPVersionHttp11
    {- ^
    HTTP 1.1 (RFC 2616)
    -}
    | AnotherHTTPVersion Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum HTTPVersion where
    fromEnum HTTPVersionHttp10 = 0
    fromEnum HTTPVersionHttp11 = 1
    fromEnum (AnotherHTTPVersion k) = k

    toEnum 0 = HTTPVersionHttp10
    toEnum 1 = HTTPVersionHttp11
    toEnum k = AnotherHTTPVersion k

instance P.Ord HTTPVersion where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_http_version_get_type" c_soup_http_version_get_type :: 
    IO GType

instance BoxedEnum HTTPVersion where
    boxedEnumType _ = c_soup_http_version_get_type

-- Enum Encoding
{- |
How a message body is encoded for transport
-}
data Encoding = 
      EncodingUnrecognized
    {- ^
    unknown \/ error
    -}
    | EncodingNone
    {- ^
    no body is present (which is not the same as a
    0-length body, and only occurs in certain places)
    -}
    | EncodingContentLength
    {- ^
    Content-Length encoding
    -}
    | EncodingEof
    {- ^
    Response body ends when the connection is closed
    -}
    | EncodingChunked
    {- ^
    chunked encoding (currently only supported
    for response)
    -}
    | EncodingByteranges
    {- ^
    multipart\/byteranges (Reserved for future
    use: NOT CURRENTLY IMPLEMENTED)
    -}
    | AnotherEncoding Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum Encoding where
    fromEnum EncodingUnrecognized = 0
    fromEnum EncodingNone = 1
    fromEnum EncodingContentLength = 2
    fromEnum EncodingEof = 3
    fromEnum EncodingChunked = 4
    fromEnum EncodingByteranges = 5
    fromEnum (AnotherEncoding k) = k

    toEnum 0 = EncodingUnrecognized
    toEnum 1 = EncodingNone
    toEnum 2 = EncodingContentLength
    toEnum 3 = EncodingEof
    toEnum 4 = EncodingChunked
    toEnum 5 = EncodingByteranges
    toEnum k = AnotherEncoding k

instance P.Ord Encoding where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_encoding_get_type" c_soup_encoding_get_type :: 
    IO GType

instance BoxedEnum Encoding where
    boxedEnumType _ = c_soup_encoding_get_type

-- Enum DateFormat
{- |
Date formats that 'GI.Soup.Structs.Date.dateToString' can use.

/@sOUPDATEHTTP@/ and /@sOUPDATECOOKIE@/ always coerce the time to
UTC. /@sOUPDATEISO8601XMLRPC@/ uses the time as given, ignoring the
offset completely. /@sOUPDATERFC2822@/ and the other ISO 8601
variants use the local time, appending the offset information if
available.

This enum may be extended with more values in future releases.
-}
data DateFormat = 
      DateFormatHttp
    {- ^
    RFC 1123 format, used by the HTTP \"Date\" header. Eg
    \"Sun, 06 Nov 1994 08:49:37 GMT\"
    -}
    | DateFormatCookie
    {- ^
    The format for the \"Expires\" timestamp in the
    Netscape cookie specification. Eg, \"Sun, 06-Nov-1994 08:49:37 GMT\".
    -}
    | DateFormatRfc2822
    {- ^
    RFC 2822 format, eg \"Sun, 6 Nov 1994 09:49:37 -0100\"
    -}
    | DateFormatIso8601Compact
    {- ^
    ISO 8601 date\/time with no optional
    punctuation. Eg, \"19941106T094937-0100\".
    -}
    | DateFormatIso8601Full
    {- ^
    ISO 8601 date\/time with all optional
    punctuation. Eg, \"1994-11-06T09:49:37-01:00\".
    -}
    | DateFormatIso8601
    {- ^
    An alias for /@sOUPDATEISO8601FULL@/.
    -}
    | DateFormatIso8601Xmlrpc
    {- ^
    ISO 8601 date\/time as used by XML-RPC.
    Eg, \"19941106T09:49:37\".
    -}
    | AnotherDateFormat Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DateFormat where
    fromEnum DateFormatHttp = 1
    fromEnum DateFormatCookie = 2
    fromEnum DateFormatRfc2822 = 3
    fromEnum DateFormatIso8601Compact = 4
    fromEnum DateFormatIso8601Full = 5
    fromEnum DateFormatIso8601 = 5
    fromEnum DateFormatIso8601Xmlrpc = 6
    fromEnum (AnotherDateFormat k) = k

    toEnum 1 = DateFormatHttp
    toEnum 2 = DateFormatCookie
    toEnum 3 = DateFormatRfc2822
    toEnum 4 = DateFormatIso8601Compact
    toEnum 5 = DateFormatIso8601Full
    toEnum 5 = DateFormatIso8601
    toEnum 6 = DateFormatIso8601Xmlrpc
    toEnum k = AnotherDateFormat k

instance P.Ord DateFormat where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_date_format_get_type" c_soup_date_format_get_type :: 
    IO GType

instance BoxedEnum DateFormat where
    boxedEnumType _ = c_soup_date_format_get_type

-- Enum CookieJarAcceptPolicy
{- |
The policy for accepting or rejecting cookies returned in
responses.

@since 2.30
-}
data CookieJarAcceptPolicy = 
      CookieJarAcceptPolicyAlways
    {- ^
    accept all cookies unconditionally.
    -}
    | CookieJarAcceptPolicyNever
    {- ^
    reject all cookies unconditionally.
    -}
    | CookieJarAcceptPolicyNoThirdParty
    {- ^
    accept all cookies set by
    the main document loaded in the application using libsoup. An
    example of the most common case, web browsers, would be: If
    http:\/\/www.example.com is the page loaded, accept all cookies set
    by example.com, but if a resource from http:\/\/www.third-party.com
    is loaded from that page reject any cookie that it could try to
    set. For libsoup to be able to tell apart first party cookies from
    the rest, the application must call 'GI.Soup.Objects.Message.messageSetFirstParty'
    on each outgoing 'GI.Soup.Objects.Message.Message', setting the 'GI.Soup.Structs.URI.URI' of the main
    document. If no first party is set in a message when this policy is
    in effect, cookies will be assumed to be third party by default.
    -}
    | AnotherCookieJarAcceptPolicy Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum CookieJarAcceptPolicy where
    fromEnum CookieJarAcceptPolicyAlways = 0
    fromEnum CookieJarAcceptPolicyNever = 1
    fromEnum CookieJarAcceptPolicyNoThirdParty = 2
    fromEnum (AnotherCookieJarAcceptPolicy k) = k

    toEnum 0 = CookieJarAcceptPolicyAlways
    toEnum 1 = CookieJarAcceptPolicyNever
    toEnum 2 = CookieJarAcceptPolicyNoThirdParty
    toEnum k = AnotherCookieJarAcceptPolicy k

instance P.Ord CookieJarAcceptPolicy where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_cookie_jar_accept_policy_get_type" c_soup_cookie_jar_accept_policy_get_type :: 
    IO GType

instance BoxedEnum CookieJarAcceptPolicy where
    boxedEnumType _ = c_soup_cookie_jar_accept_policy_get_type

-- Enum ConnectionState
{- |
/No description available in the introspection data./
-}
data ConnectionState = 
      ConnectionStateNew
    {- ^
    /No description available in the introspection data./
    -}
    | ConnectionStateConnecting
    {- ^
    /No description available in the introspection data./
    -}
    | ConnectionStateIdle
    {- ^
    /No description available in the introspection data./
    -}
    | ConnectionStateInUse
    {- ^
    /No description available in the introspection data./
    -}
    | ConnectionStateRemoteDisconnected
    {- ^
    /No description available in the introspection data./
    -}
    | ConnectionStateDisconnected
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherConnectionState Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ConnectionState where
    fromEnum ConnectionStateNew = 0
    fromEnum ConnectionStateConnecting = 1
    fromEnum ConnectionStateIdle = 2
    fromEnum ConnectionStateInUse = 3
    fromEnum ConnectionStateRemoteDisconnected = 4
    fromEnum ConnectionStateDisconnected = 5
    fromEnum (AnotherConnectionState k) = k

    toEnum 0 = ConnectionStateNew
    toEnum 1 = ConnectionStateConnecting
    toEnum 2 = ConnectionStateIdle
    toEnum 3 = ConnectionStateInUse
    toEnum 4 = ConnectionStateRemoteDisconnected
    toEnum 5 = ConnectionStateDisconnected
    toEnum k = AnotherConnectionState k

instance P.Ord ConnectionState where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_connection_state_get_type" c_soup_connection_state_get_type :: 
    IO GType

instance BoxedEnum ConnectionState where
    boxedEnumType _ = c_soup_connection_state_get_type

-- Enum CacheType
{- |
The type of cache; this affects what kinds of responses will be
saved.

@since 2.34
-}
data CacheType = 
      CacheTypeSingleUser
    {- ^
    a single-user cache
    -}
    | CacheTypeShared
    {- ^
    a shared cache
    -}
    | AnotherCacheType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum CacheType where
    fromEnum CacheTypeSingleUser = 0
    fromEnum CacheTypeShared = 1
    fromEnum (AnotherCacheType k) = k

    toEnum 0 = CacheTypeSingleUser
    toEnum 1 = CacheTypeShared
    toEnum k = AnotherCacheType k

instance P.Ord CacheType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_cache_type_get_type" c_soup_cache_type_get_type :: 
    IO GType

instance BoxedEnum CacheType where
    boxedEnumType _ = c_soup_cache_type_get_type

-- Enum CacheResponse
{- |
/No description available in the introspection data./
-}
data CacheResponse = 
      CacheResponseFresh
    {- ^
    /No description available in the introspection data./
    -}
    | CacheResponseNeedsValidation
    {- ^
    /No description available in the introspection data./
    -}
    | CacheResponseStale
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherCacheResponse Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum CacheResponse where
    fromEnum CacheResponseFresh = 0
    fromEnum CacheResponseNeedsValidation = 1
    fromEnum CacheResponseStale = 2
    fromEnum (AnotherCacheResponse k) = k

    toEnum 0 = CacheResponseFresh
    toEnum 1 = CacheResponseNeedsValidation
    toEnum 2 = CacheResponseStale
    toEnum k = AnotherCacheResponse k

instance P.Ord CacheResponse where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_cache_response_get_type" c_soup_cache_response_get_type :: 
    IO GType

instance BoxedEnum CacheResponse where
    boxedEnumType _ = c_soup_cache_response_get_type

-- Enum AddressFamily
{- |
The supported address families.
-}
data AddressFamily = 
      AddressFamilyInvalid
    {- ^
    an invalid @/SoupAddress/@
    -}
    | AddressFamilyIpv4
    {- ^
    an IPv4 address
    -}
    | AddressFamilyIpv6
    {- ^
    an IPv6 address
    -}
    | AnotherAddressFamily Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AddressFamily where
    fromEnum AddressFamilyInvalid = -1
    fromEnum AddressFamilyIpv4 = 2
    fromEnum AddressFamilyIpv6 = 10
    fromEnum (AnotherAddressFamily k) = k

    toEnum -1 = AddressFamilyInvalid
    toEnum 2 = AddressFamilyIpv4
    toEnum 10 = AddressFamilyIpv6
    toEnum k = AnotherAddressFamily k

instance P.Ord AddressFamily where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "soup_address_family_get_type" c_soup_address_family_get_type :: 
    IO GType

instance BoxedEnum AddressFamily where
    boxedEnumType _ = c_soup_address_family_get_type