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

The HTTP message headers associated with a request or response.
-}

module GI.Soup.Structs.MessageHeaders
    ( 

-- * Exported types
    MessageHeaders(..)                      ,
    noMessageHeaders                        ,


 -- * Methods
-- ** append #method:append#
    MessageHeadersAppendMethodInfo          ,
    messageHeadersAppend                    ,


-- ** cleanConnectionHeaders #method:cleanConnectionHeaders#
    MessageHeadersCleanConnectionHeadersMethodInfo,
    messageHeadersCleanConnectionHeaders    ,


-- ** clear #method:clear#
    MessageHeadersClearMethodInfo           ,
    messageHeadersClear                     ,


-- ** foreach #method:foreach#
    MessageHeadersForeachMethodInfo         ,
    messageHeadersForeach                   ,


-- ** free #method:free#
    MessageHeadersFreeMethodInfo            ,
    messageHeadersFree                      ,


-- ** freeRanges #method:freeRanges#
    MessageHeadersFreeRangesMethodInfo      ,
    messageHeadersFreeRanges                ,


-- ** get #method:get#
    MessageHeadersGetMethodInfo             ,
    messageHeadersGet                       ,


-- ** getContentDisposition #method:getContentDisposition#
    MessageHeadersGetContentDispositionMethodInfo,
    messageHeadersGetContentDisposition     ,


-- ** getContentLength #method:getContentLength#
    MessageHeadersGetContentLengthMethodInfo,
    messageHeadersGetContentLength          ,


-- ** getContentRange #method:getContentRange#
    MessageHeadersGetContentRangeMethodInfo ,
    messageHeadersGetContentRange           ,


-- ** getContentType #method:getContentType#
    MessageHeadersGetContentTypeMethodInfo  ,
    messageHeadersGetContentType            ,


-- ** getEncoding #method:getEncoding#
    MessageHeadersGetEncodingMethodInfo     ,
    messageHeadersGetEncoding               ,


-- ** getExpectations #method:getExpectations#
    MessageHeadersGetExpectationsMethodInfo ,
    messageHeadersGetExpectations           ,


-- ** getHeadersType #method:getHeadersType#
    MessageHeadersGetHeadersTypeMethodInfo  ,
    messageHeadersGetHeadersType            ,


-- ** getList #method:getList#
    MessageHeadersGetListMethodInfo         ,
    messageHeadersGetList                   ,


-- ** getOne #method:getOne#
    MessageHeadersGetOneMethodInfo          ,
    messageHeadersGetOne                    ,


-- ** getRanges #method:getRanges#
    MessageHeadersGetRangesMethodInfo       ,
    messageHeadersGetRanges                 ,


-- ** headerContains #method:headerContains#
    MessageHeadersHeaderContainsMethodInfo  ,
    messageHeadersHeaderContains            ,


-- ** headerEquals #method:headerEquals#
    MessageHeadersHeaderEqualsMethodInfo    ,
    messageHeadersHeaderEquals              ,


-- ** new #method:new#
    messageHeadersNew                       ,


-- ** remove #method:remove#
    MessageHeadersRemoveMethodInfo          ,
    messageHeadersRemove                    ,


-- ** replace #method:replace#
    MessageHeadersReplaceMethodInfo         ,
    messageHeadersReplace                   ,


-- ** setContentDisposition #method:setContentDisposition#
    MessageHeadersSetContentDispositionMethodInfo,
    messageHeadersSetContentDisposition     ,


-- ** setContentLength #method:setContentLength#
    MessageHeadersSetContentLengthMethodInfo,
    messageHeadersSetContentLength          ,


-- ** setContentRange #method:setContentRange#
    MessageHeadersSetContentRangeMethodInfo ,
    messageHeadersSetContentRange           ,


-- ** setContentType #method:setContentType#
    MessageHeadersSetContentTypeMethodInfo  ,
    messageHeadersSetContentType            ,


-- ** setEncoding #method:setEncoding#
    MessageHeadersSetEncodingMethodInfo     ,
    messageHeadersSetEncoding               ,


-- ** setExpectations #method:setExpectations#
    MessageHeadersSetExpectationsMethodInfo ,
    messageHeadersSetExpectations           ,


-- ** setRange #method:setRange#
    MessageHeadersSetRangeMethodInfo        ,
    messageHeadersSetRange                  ,


-- ** setRanges #method:setRanges#
    MessageHeadersSetRangesMethodInfo       ,
    messageHeadersSetRanges                 ,




    ) 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

import qualified GI.Soup.Callbacks as Soup.Callbacks
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Flags as Soup.Flags
import {-# SOURCE #-} qualified GI.Soup.Structs.Range as Soup.Range

newtype MessageHeaders = MessageHeaders (ManagedPtr MessageHeaders)
foreign import ccall "soup_message_headers_get_type" c_soup_message_headers_get_type :: 
    IO GType

instance BoxedObject MessageHeaders where
    boxedType _ = c_soup_message_headers_get_type

noMessageHeaders :: Maybe MessageHeaders
noMessageHeaders = Nothing


instance O.HasAttributeList MessageHeaders
type instance O.AttributeList MessageHeaders = MessageHeadersAttributeList
type MessageHeadersAttributeList = ('[ ] :: [(Symbol, *)])

-- method MessageHeaders::new
-- method type : Constructor
-- Args : [Arg {argCName = "type", argType = TInterface (Name {namespace = "Soup", name = "MessageHeadersType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of headers", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "MessageHeaders"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_new" soup_message_headers_new :: 
    CUInt ->                                -- type : TInterface (Name {namespace = "Soup", name = "MessageHeadersType"})
    IO (Ptr MessageHeaders)

{- |
Creates a 'GI.Soup.Structs.MessageHeaders.MessageHeaders'. ('GI.Soup.Objects.Message.Message' does this
automatically for its own headers. You would only need to use this
method if you are manually parsing or generating message headers.)
-}
messageHeadersNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Soup.Enums.MessageHeadersType
    {- ^ /@type@/: the type of headers -}
    -> m MessageHeaders
    {- ^ __Returns:__ a new 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
messageHeadersNew type_ = liftIO $ do
    let type_' = (fromIntegral . fromEnum) type_
    result <- soup_message_headers_new type_'
    checkUnexpectedReturnNULL "messageHeadersNew" result
    result' <- (wrapBoxed MessageHeaders) result
    return result'

-- method MessageHeaders::append
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the header name to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value of @name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_append" soup_message_headers_append :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Appends a new header with name /@name@/ and value /@value@/ to /@hdrs@/. (If
there is an existing header with name /@name@/, then this creates a
second one, which is only allowed for list-valued headers; see also
'GI.Soup.Structs.MessageHeaders.messageHeadersReplace'.)

The caller is expected to make sure that /@name@/ and /@value@/ are
syntactically correct.
-}
messageHeadersAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: the header name to add -}
    -> T.Text
    {- ^ /@value@/: the new value of /@name@/ -}
    -> m ()
messageHeadersAppend hdrs name value = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    value' <- textToCString value
    soup_message_headers_append hdrs' name' value'
    touchManagedPtr hdrs
    freeMem name'
    freeMem value'
    return ()

data MessageHeadersAppendMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.MethodInfo MessageHeadersAppendMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersAppend

-- method MessageHeaders::clean_connection_headers
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_clean_connection_headers" soup_message_headers_clean_connection_headers :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO ()

{- |
Removes all the headers listed in the Connection header.

@since 2.36
-}
messageHeadersCleanConnectionHeaders ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m ()
messageHeadersCleanConnectionHeaders hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    soup_message_headers_clean_connection_headers hdrs'
    touchManagedPtr hdrs
    return ()

data MessageHeadersCleanConnectionHeadersMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageHeadersCleanConnectionHeadersMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersCleanConnectionHeaders

-- method MessageHeaders::clear
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_clear" soup_message_headers_clear :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO ()

{- |
Clears /@hdrs@/.
-}
messageHeadersClear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m ()
messageHeadersClear hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    soup_message_headers_clear hdrs'
    touchManagedPtr hdrs
    return ()

data MessageHeadersClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageHeadersClearMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersClear

-- method MessageHeaders::foreach
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Soup", name = "MessageHeadersForeachFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "callback function to run for each header", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to @func", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_foreach" soup_message_headers_foreach :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    FunPtr Soup.Callbacks.C_MessageHeadersForeachFunc -> -- func : TInterface (Name {namespace = "Soup", name = "MessageHeadersForeachFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Calls /@func@/ once for each header value in /@hdrs@/.

Beware that unlike 'GI.Soup.Structs.MessageHeaders.messageHeadersGet', this processes the
headers in exactly the way they were added, rather than
concatenating multiple same-named headers into a single value.
(This is intentional; it ensures that if you call
'GI.Soup.Structs.MessageHeaders.messageHeadersAppend' multiple times with the same name,
then the I\/O code will output multiple copies of the header when
sending the message to the remote implementation, which may be
required for interoperability in some cases.)

You may not modify the headers from /@func@/.
-}
messageHeadersForeach ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Soup.Callbacks.MessageHeadersForeachFunc
    {- ^ /@func@/: callback function to run for each header -}
    -> m ()
messageHeadersForeach hdrs func = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    func' <- Soup.Callbacks.mk_MessageHeadersForeachFunc (Soup.Callbacks.wrap_MessageHeadersForeachFunc Nothing (Soup.Callbacks.drop_closures_MessageHeadersForeachFunc func))
    let userData = nullPtr
    soup_message_headers_foreach hdrs' func' userData
    safeFreeFunPtr $ castFunPtrToPtr func'
    touchManagedPtr hdrs
    return ()

data MessageHeadersForeachMethodInfo
instance (signature ~ (Soup.Callbacks.MessageHeadersForeachFunc -> m ()), MonadIO m) => O.MethodInfo MessageHeadersForeachMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersForeach

-- method MessageHeaders::free
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_free" soup_message_headers_free :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO ()

{- |
Frees /@hdrs@/.
-}
messageHeadersFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m ()
messageHeadersFree hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    soup_message_headers_free hdrs'
    touchManagedPtr hdrs
    return ()

data MessageHeadersFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageHeadersFreeMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersFree

-- method MessageHeaders::free_ranges
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ranges", argType = TInterface (Name {namespace = "Soup", name = "Range"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an array of #SoupRange", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_free_ranges" soup_message_headers_free_ranges :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr Soup.Range.Range ->                 -- ranges : TInterface (Name {namespace = "Soup", name = "Range"})
    IO ()

{- |
Frees the array of ranges returned from 'GI.Soup.Structs.MessageHeaders.messageHeadersGetRanges'.

@since 2.26
-}
messageHeadersFreeRanges ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Soup.Range.Range
    {- ^ /@ranges@/: an array of 'GI.Soup.Structs.Range.Range' -}
    -> m ()
messageHeadersFreeRanges hdrs ranges = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    ranges' <- unsafeManagedPtrGetPtr ranges
    soup_message_headers_free_ranges hdrs' ranges'
    touchManagedPtr hdrs
    touchManagedPtr ranges
    return ()

data MessageHeadersFreeRangesMethodInfo
instance (signature ~ (Soup.Range.Range -> m ()), MonadIO m) => O.MethodInfo MessageHeadersFreeRangesMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersFreeRanges

-- method MessageHeaders::get
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "header name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get" soup_message_headers_get :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO CString

{-# DEPRECATED messageHeadersGet ["Use 'GI.Soup.Structs.MessageHeaders.messageHeadersGetOne' or","'GI.Soup.Structs.MessageHeaders.messageHeadersGetList' instead."] #-}
{- |
Gets the value of header /@name@/ in /@hdrs@/.

This method was supposed to work correctly for both single-valued
and list-valued headers, but because some HTTP clients\/servers
mistakenly send multiple copies of headers that are supposed to be
single-valued, it sometimes returns incorrect results. To fix this,
the methods 'GI.Soup.Structs.MessageHeaders.messageHeadersGetOne' and
'GI.Soup.Structs.MessageHeaders.messageHeadersGetList' were introduced, so callers can
explicitly state which behavior they are expecting.
-}
messageHeadersGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: header name -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ as with 'GI.Soup.Structs.MessageHeaders.messageHeadersGetList'. -}
messageHeadersGet hdrs name = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    result <- soup_message_headers_get hdrs' name'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr hdrs
    freeMem name'
    return maybeResult

data MessageHeadersGetMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo MessageHeadersGetMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGet

-- method MessageHeaders::get_content_disposition
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disposition", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the\ndisposition-type, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return\nlocation for the Content-Disposition parameters, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_content_disposition" soup_message_headers_get_content_disposition :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr CString ->                          -- disposition : TBasicType TUTF8
    Ptr (Ptr (GHashTable CString CString)) -> -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO CInt

{- |
Looks up the \"Content-Disposition\" header in /@hdrs@/, parses it, and
returns its value in */@disposition@/ and */@params@/. /@params@/ can be
'Nothing' if you are only interested in the disposition-type.

In HTTP, the most common use of this header is to set a
disposition-type of \"attachment\", to suggest to the browser that a
response should be saved to disk rather than displayed in the
browser. If /@params@/ contains a \"filename\" parameter, this is a
suggestion of a filename to use. (If the parameter value in the
header contains an absolute or relative path, libsoup will truncate
it down to just the final path component, so you do not need to
test this yourself.)

Content-Disposition is also used in \"multipart\/form-data\", however
this is handled automatically by 'GI.Soup.Structs.Multipart.Multipart' and the associated
form methods.

@since 2.26
-}
messageHeadersGetContentDisposition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m (Bool,T.Text,(Map.Map T.Text T.Text))
    {- ^ __Returns:__ 'True' if /@hdrs@/ contains a \"Content-Disposition\"
header, 'False' if not (in which case */@disposition@/ and */@params@/
will be unchanged). -}
messageHeadersGetContentDisposition hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    disposition <- allocMem :: IO (Ptr CString)
    params <- allocMem :: IO (Ptr (Ptr (GHashTable CString CString)))
    result <- soup_message_headers_get_content_disposition hdrs' disposition params
    let result' = (/= 0) result
    disposition' <- peek disposition
    disposition'' <- cstringToText disposition'
    freeMem disposition'
    params' <- peek params
    params'' <- unpackGHashTable params'
    let params''' = mapFirst cstringUnpackPtr params''
    params'''' <- mapFirstA cstringToText params'''
    let params''''' = mapSecond cstringUnpackPtr params''''
    params'''''' <- mapSecondA cstringToText params'''''
    let params''''''' = Map.fromList params''''''
    unrefGHashTable params'
    touchManagedPtr hdrs
    freeMem disposition
    freeMem params
    return (result', disposition'', params''''''')

data MessageHeadersGetContentDispositionMethodInfo
instance (signature ~ (m (Bool,T.Text,(Map.Map T.Text T.Text))), MonadIO m) => O.MethodInfo MessageHeadersGetContentDispositionMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetContentDisposition

-- method MessageHeaders::get_content_length
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt64)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_content_length" soup_message_headers_get_content_length :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO Int64

{- |
Gets the message body length that /@hdrs@/ declare. This will only
be non-0 if 'GI.Soup.Structs.MessageHeaders.messageHeadersGetEncoding' returns
'GI.Soup.Enums.EncodingContentLength'.
-}
messageHeadersGetContentLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m Int64
    {- ^ __Returns:__ the message body length declared by /@hdrs@/. -}
messageHeadersGetContentLength hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    result <- soup_message_headers_get_content_length hdrs'
    touchManagedPtr hdrs
    return result

data MessageHeadersGetContentLengthMethodInfo
instance (signature ~ (m Int64), MonadIO m) => O.MethodInfo MessageHeadersGetContentLengthMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetContentLength

-- method MessageHeaders::get_content_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the start of the range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the end of the range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "total_length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the total length of the resource,\nor %NULL if you don't care.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_content_range" soup_message_headers_get_content_range :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- start : TBasicType TInt64
    Int64 ->                                -- end : TBasicType TInt64
    Int64 ->                                -- total_length : TBasicType TInt64
    IO CInt

{- |
Parses /@hdrs@/\'s Content-Range header and returns it in /@start@/,
/@end@/, and /@totalLength@/. If the total length field in the header
was specified as \"*\", then /@totalLength@/ will be set to -1.

@since 2.26
-}
messageHeadersGetContentRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Int64
    {- ^ /@start@/: return value for the start of the range -}
    -> Int64
    {- ^ /@end@/: return value for the end of the range -}
    -> Int64
    {- ^ /@totalLength@/: return value for the total length of the resource,
or 'Nothing' if you don\'t care. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@hdrs@/ contained a \"Content-Range\" header
containing a byte range which could be parsed, 'False' otherwise. -}
messageHeadersGetContentRange hdrs start end totalLength = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    result <- soup_message_headers_get_content_range hdrs' start end totalLength
    let result' = (/= 0) result
    touchManagedPtr hdrs
    return result'

data MessageHeadersGetContentRangeMethodInfo
instance (signature ~ (Int64 -> Int64 -> Int64 -> m Bool), MonadIO m) => O.MethodInfo MessageHeadersGetContentRangeMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetContentRange

-- method MessageHeaders::get_content_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n  return location for the Content-Type parameters (eg, \"charset\"), or\n  %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_content_type" soup_message_headers_get_content_type :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr (Ptr (GHashTable CString CString)) -> -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO CString

{- |
Looks up the \"Content-Type\" header in /@hdrs@/, parses it, and returns
its value in */@contentType@/ and */@params@/. /@params@/ can be 'Nothing' if you
are only interested in the content type itself.

@since 2.26
-}
messageHeadersGetContentType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m ((Maybe T.Text),(Map.Map T.Text T.Text))
    {- ^ __Returns:__ a string with the value of the
\"Content-Type\" header or 'Nothing' if /@hdrs@/ does not contain that
header or it cannot be parsed (in which case */@params@/ will be
unchanged). -}
messageHeadersGetContentType hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    params <- allocMem :: IO (Ptr (Ptr (GHashTable CString CString)))
    result <- soup_message_headers_get_content_type hdrs' params
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    params' <- peek params
    params'' <- unpackGHashTable params'
    let params''' = mapFirst cstringUnpackPtr params''
    params'''' <- mapFirstA cstringToText params'''
    let params''''' = mapSecond cstringUnpackPtr params''''
    params'''''' <- mapSecondA cstringToText params'''''
    let params''''''' = Map.fromList params''''''
    unrefGHashTable params'
    touchManagedPtr hdrs
    freeMem params
    return (maybeResult, params''''''')

data MessageHeadersGetContentTypeMethodInfo
instance (signature ~ (m ((Maybe T.Text),(Map.Map T.Text T.Text))), MonadIO m) => O.MethodInfo MessageHeadersGetContentTypeMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetContentType

-- method MessageHeaders::get_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Encoding"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_encoding" soup_message_headers_get_encoding :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO CUInt

{- |
Gets the message body encoding that /@hdrs@/ declare. This may not
always correspond to the encoding used on the wire; eg, a HEAD
response may declare a Content-Length or Transfer-Encoding, but
it will never actually include a body.
-}
messageHeadersGetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m Soup.Enums.Encoding
    {- ^ __Returns:__ the encoding declared by /@hdrs@/. -}
messageHeadersGetEncoding hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    result <- soup_message_headers_get_encoding hdrs'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr hdrs
    return result'

data MessageHeadersGetEncodingMethodInfo
instance (signature ~ (m Soup.Enums.Encoding), MonadIO m) => O.MethodInfo MessageHeadersGetEncodingMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetEncoding

-- method MessageHeaders::get_expectations
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Expectation"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_expectations" soup_message_headers_get_expectations :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO CUInt

{- |
Gets the expectations declared by /@hdrs@/\'s \"Expect\" header.
Currently this will either be 'GI.Soup.Flags.ExpectationContinue' or
'GI.Soup.Flags.ExpectationUnrecognized'.
-}
messageHeadersGetExpectations ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m [Soup.Flags.Expectation]
    {- ^ __Returns:__ the contents of /@hdrs@/\'s \"Expect\" header -}
messageHeadersGetExpectations hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    result <- soup_message_headers_get_expectations hdrs'
    let result' = wordToGFlags result
    touchManagedPtr hdrs
    return result'

data MessageHeadersGetExpectationsMethodInfo
instance (signature ~ (m [Soup.Flags.Expectation]), MonadIO m) => O.MethodInfo MessageHeadersGetExpectationsMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetExpectations

-- method MessageHeaders::get_headers_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "MessageHeadersType"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_headers_type" soup_message_headers_get_headers_type :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO CUInt

{- |
Gets the type of headers.

@since 2.50
-}
messageHeadersGetHeadersType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> m Soup.Enums.MessageHeadersType
    {- ^ __Returns:__ the header\'s type. -}
messageHeadersGetHeadersType hdrs = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    result <- soup_message_headers_get_headers_type hdrs'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr hdrs
    return result'

data MessageHeadersGetHeadersTypeMethodInfo
instance (signature ~ (m Soup.Enums.MessageHeadersType), MonadIO m) => O.MethodInfo MessageHeadersGetHeadersTypeMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetHeadersType

-- method MessageHeaders::get_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "header name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_list" soup_message_headers_get_list :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO CString

{- |
Gets the value of header /@name@/ in /@hdrs@/. Use this for headers whose
values are comma-delimited lists, and which are therefore allowed
to appear multiple times in the headers. For non-list-valued
headers, use 'GI.Soup.Structs.MessageHeaders.messageHeadersGetOne'.

If /@name@/ appears multiple times in /@hdrs@/,
'GI.Soup.Structs.MessageHeaders.messageHeadersGetList' will concatenate all of the values
together, separated by commas. This is sometimes awkward to parse
(eg, WWW-Authenticate, Set-Cookie), but you have to be able to deal
with it anyway, because the HTTP spec explicitly states that this
transformation is allowed, and so an upstream proxy could do the
same thing.

@since 2.28
-}
messageHeadersGetList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: header name -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the header\'s value or 'Nothing' if not found. -}
messageHeadersGetList hdrs name = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    result <- soup_message_headers_get_list hdrs' name'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr hdrs
    freeMem name'
    return maybeResult

data MessageHeadersGetListMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo MessageHeadersGetListMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetList

-- method MessageHeaders::get_one
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "header name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_one" soup_message_headers_get_one :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO CString

{- |
Gets the value of header /@name@/ in /@hdrs@/. Use this for headers whose
values are \<emphasis>not\<\/emphasis> comma-delimited lists, and
which therefore can only appear at most once in the headers. For
list-valued headers, use 'GI.Soup.Structs.MessageHeaders.messageHeadersGetList'.

If /@hdrs@/ does erroneously contain multiple copies of the header, it
is not defined which one will be returned. (Ideally, it will return
whichever one makes libsoup most compatible with other HTTP
implementations.)

@since 2.28
-}
messageHeadersGetOne ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: header name -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the header\'s value or 'Nothing' if not found. -}
messageHeadersGetOne hdrs name = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    result <- soup_message_headers_get_one hdrs' name'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr hdrs
    freeMem name'
    return maybeResult

data MessageHeadersGetOneMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo MessageHeadersGetOneMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetOne

-- method MessageHeaders::get_ranges
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "total_length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the total_length of the response body", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ranges", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "Soup", name = "Range"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for an array\nof #SoupRange", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the returned array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the returned array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_ranges" soup_message_headers_get_ranges :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- total_length : TBasicType TInt64
    Ptr (Ptr Soup.Range.Range) ->           -- ranges : TCArray False (-1) 3 (TInterface (Name {namespace = "Soup", name = "Range"}))
    Ptr Int32 ->                            -- length : TBasicType TInt
    IO CInt

{- |
Parses /@hdrs@/\'s Range header and returns an array of the requested
byte ranges. The returned array must be freed with
'GI.Soup.Structs.MessageHeaders.messageHeadersFreeRanges'.

If /@totalLength@/ is non-0, its value will be used to adjust the
returned ranges to have explicit start and end values, and the
returned ranges will be sorted and non-overlapping. If
/@totalLength@/ is 0, then some ranges may have an end value of -1,
as described under 'GI.Soup.Structs.Range.Range', and some of the ranges may be
redundant.

Beware that even if given a /@totalLength@/, this function does not
check that the ranges are satisfiable.

\<note>\<para>
'GI.Soup.Objects.Server.Server' has built-in handling for range requests. If your
server handler returns a 'GI.Soup.Enums.StatusOk' response containing the
complete response body (rather than pausing the message and
returning some of the response body later), and there is a Range
header in the request, then libsoup will automatically convert the
response to a 'GI.Soup.Enums.StatusPartialContent' response containing only
the range(s) requested by the client.

The only time you need to process the Range header yourself is if
either you need to stream the response body rather than returning
it all at once, or you do not already have the complete response
body available, and only want to generate the parts that were
actually requested by the client.
\<\/para>\<\/note>

@since 2.26
-}
messageHeadersGetRanges ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Int64
    {- ^ /@totalLength@/: the total_length of the response body -}
    -> m (Bool,[Soup.Range.Range])
    {- ^ __Returns:__ 'True' if /@hdrs@/ contained a syntactically-valid
\"Range\" header, 'False' otherwise (in which case /@range@/ and /@length@/
will not be set). -}
messageHeadersGetRanges hdrs totalLength = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    ranges <- allocMem :: IO (Ptr (Ptr Soup.Range.Range))
    length_ <- allocMem :: IO (Ptr Int32)
    result <- soup_message_headers_get_ranges hdrs' totalLength ranges length_
    length_' <- peek length_
    let result' = (/= 0) result
    ranges' <- peek ranges
    ranges'' <- (unpackBlockArrayWithLength 16 length_') ranges'
    ranges''' <- mapM (wrapPtr Soup.Range.Range) ranges''
    freeMem ranges'
    touchManagedPtr hdrs
    freeMem ranges
    freeMem length_
    return (result', ranges''')

data MessageHeadersGetRangesMethodInfo
instance (signature ~ (Int64 -> m (Bool,[Soup.Range.Range])), MonadIO m) => O.MethodInfo MessageHeadersGetRangesMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersGetRanges

-- method MessageHeaders::header_contains
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "header name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "token", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "token to look for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_header_contains" soup_message_headers_header_contains :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- token : TBasicType TUTF8
    IO CInt

{- |
Checks whether the list-valued header /@name@/ is present in /@hdrs@/,
and contains a case-insensitive match for /@token@/.

(If /@name@/ is present in /@hdrs@/, then this is equivalent to calling
'GI.Soup.Functions.headerContains' on its value.)

@since 2.50
-}
messageHeadersHeaderContains ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: header name -}
    -> T.Text
    {- ^ /@token@/: token to look for -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the header is present and contains /@token@/,
  'False' otherwise. -}
messageHeadersHeaderContains hdrs name token = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    token' <- textToCString token
    result <- soup_message_headers_header_contains hdrs' name' token'
    let result' = (/= 0) result
    touchManagedPtr hdrs
    freeMem name'
    freeMem token'
    return result'

data MessageHeadersHeaderContainsMethodInfo
instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.MethodInfo MessageHeadersHeaderContainsMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersHeaderContains

-- method MessageHeaders::header_equals
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "header name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "expected value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_header_equals" soup_message_headers_header_equals :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO CInt

{- |
Checks whether the header /@name@/ is present in /@hdrs@/ and is
(case-insensitively) equal to /@value@/.

@since 2.50
-}
messageHeadersHeaderEquals ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: header name -}
    -> T.Text
    {- ^ /@value@/: expected value -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the header is present and its value is
  /@value@/, 'False' otherwise. -}
messageHeadersHeaderEquals hdrs name value = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    value' <- textToCString value
    result <- soup_message_headers_header_equals hdrs' name' value'
    let result' = (/= 0) result
    touchManagedPtr hdrs
    freeMem name'
    freeMem value'
    return result'

data MessageHeadersHeaderEqualsMethodInfo
instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.MethodInfo MessageHeadersHeaderEqualsMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersHeaderEquals

-- method MessageHeaders::remove
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the header name to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_remove" soup_message_headers_remove :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Removes /@name@/ from /@hdrs@/. If there are multiple values for /@name@/,
they are all removed.
-}
messageHeadersRemove ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: the header name to remove -}
    -> m ()
messageHeadersRemove hdrs name = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    soup_message_headers_remove hdrs' name'
    touchManagedPtr hdrs
    freeMem name'
    return ()

data MessageHeadersRemoveMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo MessageHeadersRemoveMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersRemove

-- method MessageHeaders::replace
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the header name to replace", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value of @name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_replace" soup_message_headers_replace :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Replaces the value of the header /@name@/ in /@hdrs@/ with /@value@/. (See
also 'GI.Soup.Structs.MessageHeaders.messageHeadersAppend'.)

The caller is expected to make sure that /@name@/ and /@value@/ are
syntactically correct.
-}
messageHeadersReplace ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@name@/: the header name to replace -}
    -> T.Text
    {- ^ /@value@/: the new value of /@name@/ -}
    -> m ()
messageHeadersReplace hdrs name value = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    name' <- textToCString name
    value' <- textToCString value
    soup_message_headers_replace hdrs' name' value'
    touchManagedPtr hdrs
    freeMem name'
    freeMem value'
    return ()

data MessageHeadersReplaceMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.MethodInfo MessageHeadersReplaceMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersReplace

-- method MessageHeaders::set_content_disposition
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disposition", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the disposition-type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "additional\nparameters, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_disposition" soup_message_headers_set_content_disposition :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- disposition : TBasicType TUTF8
    Ptr (GHashTable CString CString) ->     -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO ()

{- |
Sets the \"Content-Disposition\" header in /@hdrs@/ to /@disposition@/,
optionally with additional parameters specified in /@params@/.

See 'GI.Soup.Structs.MessageHeaders.messageHeadersGetContentDisposition' for a discussion
of how Content-Disposition is used in HTTP.

@since 2.26
-}
messageHeadersSetContentDisposition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@disposition@/: the disposition-type -}
    -> Maybe (Map.Map T.Text T.Text)
    {- ^ /@params@/: additional
parameters, or 'Nothing' -}
    -> m ()
messageHeadersSetContentDisposition hdrs disposition params = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    disposition' <- textToCString disposition
    maybeParams <- case params of
        Nothing -> return nullPtr
        Just jParams -> do
            let jParams' = Map.toList jParams
            jParams'' <- mapFirstA textToCString jParams'
            jParams''' <- mapSecondA textToCString jParams''
            let jParams'''' = mapFirst cstringPackPtr jParams'''
            let jParams''''' = mapSecond cstringPackPtr jParams''''
            jParams'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) jParams'''''
            return jParams''''''
    soup_message_headers_set_content_disposition hdrs' disposition' maybeParams
    touchManagedPtr hdrs
    freeMem disposition'
    unrefGHashTable maybeParams
    return ()

data MessageHeadersSetContentDispositionMethodInfo
instance (signature ~ (T.Text -> Maybe (Map.Map T.Text T.Text) -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentDispositionMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetContentDisposition

-- method MessageHeaders::set_content_length
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message body length", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_length" soup_message_headers_set_content_length :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- content_length : TBasicType TInt64
    IO ()

{- |
Sets the message body length that /@hdrs@/ will declare, and sets
/@hdrs@/\'s encoding to 'GI.Soup.Enums.EncodingContentLength'.

You do not normally need to call this; if /@hdrs@/ is set to use
Content-Length encoding, libsoup will automatically set its
Content-Length header for you immediately before sending the
headers. One situation in which this method is useful is when
generating the response to a HEAD request; Calling
'GI.Soup.Structs.MessageHeaders.messageHeadersSetContentLength' allows you to put the
correct content length into the response without needing to waste
memory by filling in a response body which won\'t actually be sent.
-}
messageHeadersSetContentLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Int64
    {- ^ /@contentLength@/: the message body length -}
    -> m ()
messageHeadersSetContentLength hdrs contentLength = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    soup_message_headers_set_content_length hdrs' contentLength
    touchManagedPtr hdrs
    return ()

data MessageHeadersSetContentLengthMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentLengthMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetContentLength

-- method MessageHeaders::set_content_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start of the range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the end of the range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "total_length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the total length of the resource, or -1 if unknown", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_range" soup_message_headers_set_content_range :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- start : TBasicType TInt64
    Int64 ->                                -- end : TBasicType TInt64
    Int64 ->                                -- total_length : TBasicType TInt64
    IO ()

{- |
Sets /@hdrs@/\'s Content-Range header according to the given values.
(Note that /@totalLength@/ is the total length of the entire resource
that this is a range of, not simply /@end@/ - /@start@/ + 1.)

\<note>\<para>
'GI.Soup.Objects.Server.Server' has built-in handling for range requests, and you do
not normally need to call this function youself. See
'GI.Soup.Structs.MessageHeaders.messageHeadersGetRanges' for more details.
\<\/para>\<\/note>

@since 2.26
-}
messageHeadersSetContentRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Int64
    {- ^ /@start@/: the start of the range -}
    -> Int64
    {- ^ /@end@/: the end of the range -}
    -> Int64
    {- ^ /@totalLength@/: the total length of the resource, or -1 if unknown -}
    -> m ()
messageHeadersSetContentRange hdrs start end totalLength = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    soup_message_headers_set_content_range hdrs' start end totalLength
    touchManagedPtr hdrs
    return ()

data MessageHeadersSetContentRangeMethodInfo
instance (signature ~ (Int64 -> Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentRangeMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetContentRange

-- method MessageHeaders::set_content_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the MIME type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "additional\nparameters, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_type" soup_message_headers_set_content_type :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- content_type : TBasicType TUTF8
    Ptr (GHashTable CString CString) ->     -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO ()

{- |
Sets the \"Content-Type\" header in /@hdrs@/ to /@contentType@/,
optionally with additional parameters specified in /@params@/.

@since 2.26
-}
messageHeadersSetContentType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> T.Text
    {- ^ /@contentType@/: the MIME type -}
    -> Maybe (Map.Map T.Text T.Text)
    {- ^ /@params@/: additional
parameters, or 'Nothing' -}
    -> m ()
messageHeadersSetContentType hdrs contentType params = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    contentType' <- textToCString contentType
    maybeParams <- case params of
        Nothing -> return nullPtr
        Just jParams -> do
            let jParams' = Map.toList jParams
            jParams'' <- mapFirstA textToCString jParams'
            jParams''' <- mapSecondA textToCString jParams''
            let jParams'''' = mapFirst cstringPackPtr jParams'''
            let jParams''''' = mapSecond cstringPackPtr jParams''''
            jParams'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) jParams'''''
            return jParams''''''
    soup_message_headers_set_content_type hdrs' contentType' maybeParams
    touchManagedPtr hdrs
    freeMem contentType'
    unrefGHashTable maybeParams
    return ()

data MessageHeadersSetContentTypeMethodInfo
instance (signature ~ (T.Text -> Maybe (Map.Map T.Text T.Text) -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentTypeMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetContentType

-- method MessageHeaders::set_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TInterface (Name {namespace = "Soup", name = "Encoding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupEncoding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_encoding" soup_message_headers_set_encoding :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CUInt ->                                -- encoding : TInterface (Name {namespace = "Soup", name = "Encoding"})
    IO ()

{- |
Sets the message body encoding that /@hdrs@/ will declare. In particular,
you should use this if you are going to send a request or response in
chunked encoding.
-}
messageHeadersSetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Soup.Enums.Encoding
    {- ^ /@encoding@/: a 'GI.Soup.Enums.Encoding' -}
    -> m ()
messageHeadersSetEncoding hdrs encoding = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    let encoding' = (fromIntegral . fromEnum) encoding
    soup_message_headers_set_encoding hdrs' encoding'
    touchManagedPtr hdrs
    return ()

data MessageHeadersSetEncodingMethodInfo
instance (signature ~ (Soup.Enums.Encoding -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetEncodingMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetEncoding

-- method MessageHeaders::set_expectations
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expectations", argType = TInterface (Name {namespace = "Soup", name = "Expectation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the expectations to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_expectations" soup_message_headers_set_expectations :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CUInt ->                                -- expectations : TInterface (Name {namespace = "Soup", name = "Expectation"})
    IO ()

{- |
Sets /@hdrs@/\'s \"Expect\" header according to /@expectations@/.

Currently 'GI.Soup.Flags.ExpectationContinue' is the only known expectation
value. You should set this value on a request if you are sending a
large message body (eg, via POST or PUT), and want to give the
server a chance to reject the request after seeing just the headers
(eg, because it will require authentication before allowing you to
post, or because you\'re POSTing to a URL that doesn\'t exist). This
saves you from having to transmit the large request body when the
server is just going to ignore it anyway.
-}
messageHeadersSetExpectations ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> [Soup.Flags.Expectation]
    {- ^ /@expectations@/: the expectations to set -}
    -> m ()
messageHeadersSetExpectations hdrs expectations = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    let expectations' = gflagsToWord expectations
    soup_message_headers_set_expectations hdrs' expectations'
    touchManagedPtr hdrs
    return ()

data MessageHeadersSetExpectationsMethodInfo
instance (signature ~ ([Soup.Flags.Expectation] -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetExpectationsMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetExpectations

-- method MessageHeaders::set_range
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start of the range to request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the end of the range to request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_range" soup_message_headers_set_range :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- start : TBasicType TInt64
    Int64 ->                                -- end : TBasicType TInt64
    IO ()

{- |
Sets /@hdrs@/\'s Range header to request the indicated range.
/@start@/ and /@end@/ are interpreted as in a 'GI.Soup.Structs.Range.Range'.

If you need to request multiple ranges, use
'GI.Soup.Structs.MessageHeaders.messageHeadersSetRanges'.

@since 2.26
-}
messageHeadersSetRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Int64
    {- ^ /@start@/: the start of the range to request -}
    -> Int64
    {- ^ /@end@/: the end of the range to request -}
    -> m ()
messageHeadersSetRange hdrs start end = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    soup_message_headers_set_range hdrs' start end
    touchManagedPtr hdrs
    return ()

data MessageHeadersSetRangeMethodInfo
instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetRangeMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetRange

-- method MessageHeaders::set_ranges
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "hdrs", argType = TInterface (Name {namespace = "Soup", name = "MessageHeaders"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageHeaders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ranges", argType = TInterface (Name {namespace = "Soup", name = "Range"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an array of #SoupRange", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @range", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_ranges" soup_message_headers_set_ranges :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr Soup.Range.Range ->                 -- ranges : TInterface (Name {namespace = "Soup", name = "Range"})
    Int32 ->                                -- length : TBasicType TInt
    IO ()

{- |
Sets /@hdrs@/\'s Range header to request the indicated ranges. (If you
only want to request a single range, you can use
'GI.Soup.Structs.MessageHeaders.messageHeadersSetRange'.)

@since 2.26
-}
messageHeadersSetRanges ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -}
    -> Soup.Range.Range
    {- ^ /@ranges@/: an array of 'GI.Soup.Structs.Range.Range' -}
    -> Int32
    {- ^ /@length@/: the length of /@range@/ -}
    -> m ()
messageHeadersSetRanges hdrs ranges length_ = liftIO $ do
    hdrs' <- unsafeManagedPtrGetPtr hdrs
    ranges' <- unsafeManagedPtrGetPtr ranges
    soup_message_headers_set_ranges hdrs' ranges' length_
    touchManagedPtr hdrs
    touchManagedPtr ranges
    return ()

data MessageHeadersSetRangesMethodInfo
instance (signature ~ (Soup.Range.Range -> Int32 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetRangesMethodInfo MessageHeaders signature where
    overloadedMethod _ = messageHeadersSetRanges

type family ResolveMessageHeadersMethod (t :: Symbol) (o :: *) :: * where
    ResolveMessageHeadersMethod "append" o = MessageHeadersAppendMethodInfo
    ResolveMessageHeadersMethod "cleanConnectionHeaders" o = MessageHeadersCleanConnectionHeadersMethodInfo
    ResolveMessageHeadersMethod "clear" o = MessageHeadersClearMethodInfo
    ResolveMessageHeadersMethod "foreach" o = MessageHeadersForeachMethodInfo
    ResolveMessageHeadersMethod "free" o = MessageHeadersFreeMethodInfo
    ResolveMessageHeadersMethod "freeRanges" o = MessageHeadersFreeRangesMethodInfo
    ResolveMessageHeadersMethod "get" o = MessageHeadersGetMethodInfo
    ResolveMessageHeadersMethod "headerContains" o = MessageHeadersHeaderContainsMethodInfo
    ResolveMessageHeadersMethod "headerEquals" o = MessageHeadersHeaderEqualsMethodInfo
    ResolveMessageHeadersMethod "remove" o = MessageHeadersRemoveMethodInfo
    ResolveMessageHeadersMethod "replace" o = MessageHeadersReplaceMethodInfo
    ResolveMessageHeadersMethod "getContentDisposition" o = MessageHeadersGetContentDispositionMethodInfo
    ResolveMessageHeadersMethod "getContentLength" o = MessageHeadersGetContentLengthMethodInfo
    ResolveMessageHeadersMethod "getContentRange" o = MessageHeadersGetContentRangeMethodInfo
    ResolveMessageHeadersMethod "getContentType" o = MessageHeadersGetContentTypeMethodInfo
    ResolveMessageHeadersMethod "getEncoding" o = MessageHeadersGetEncodingMethodInfo
    ResolveMessageHeadersMethod "getExpectations" o = MessageHeadersGetExpectationsMethodInfo
    ResolveMessageHeadersMethod "getHeadersType" o = MessageHeadersGetHeadersTypeMethodInfo
    ResolveMessageHeadersMethod "getList" o = MessageHeadersGetListMethodInfo
    ResolveMessageHeadersMethod "getOne" o = MessageHeadersGetOneMethodInfo
    ResolveMessageHeadersMethod "getRanges" o = MessageHeadersGetRangesMethodInfo
    ResolveMessageHeadersMethod "setContentDisposition" o = MessageHeadersSetContentDispositionMethodInfo
    ResolveMessageHeadersMethod "setContentLength" o = MessageHeadersSetContentLengthMethodInfo
    ResolveMessageHeadersMethod "setContentRange" o = MessageHeadersSetContentRangeMethodInfo
    ResolveMessageHeadersMethod "setContentType" o = MessageHeadersSetContentTypeMethodInfo
    ResolveMessageHeadersMethod "setEncoding" o = MessageHeadersSetEncodingMethodInfo
    ResolveMessageHeadersMethod "setExpectations" o = MessageHeadersSetExpectationsMethodInfo
    ResolveMessageHeadersMethod "setRange" o = MessageHeadersSetRangeMethodInfo
    ResolveMessageHeadersMethod "setRanges" o = MessageHeadersSetRangesMethodInfo
    ResolveMessageHeadersMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveMessageHeadersMethod t MessageHeaders, O.MethodInfo info MessageHeaders p) => O.IsLabelProxy t (MessageHeaders -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveMessageHeadersMethod t MessageHeaders, O.MethodInfo info MessageHeaders p) => O.IsLabel t (MessageHeaders -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif