{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents an HTTP message being sent or received.
-- 
-- A t'GI.Soup.Objects.Message.Message' represents an HTTP message that is being sent or
-- received.
-- 
-- You would create a t'GI.Soup.Objects.Message.Message' with [ctor/@message@/.new] or
-- [ctor/@message@/.new_from_uri], set up its fields appropriately, and send it.
-- 
-- [property/@message@/:status-code] will normally be a [enum/@status@/] value, eg,
-- 'GI.Soup.Enums.StatusOk', though of course it might actually be an unknown status
-- code. [property/@message@/:reason-phrase] is the actual text returned from the
-- server, which may or may not correspond to the \"standard\" description of
-- /@statusCode@/. At any rate, it is almost certainly not localized, and not very
-- descriptive even if it is in the user\'s language; you should not use
-- [property/@message@/:reason-phrase] in user-visible messages. Rather, you should
-- look at [property/@message@/:status-code], and determine an end-user-appropriate
-- message based on that and on what you were trying to do.
-- 
-- Note that libsoup\'s terminology here does not quite match the HTTP
-- specification: in RFC 2616, an \"HTTP-message\" is *either* a Request, *or* a
-- Response. In libsoup, a t'GI.Soup.Objects.Message.Message' combines both the request and the
-- response.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Soup.Objects.Message
    ( 

-- * Exported types
    Message(..)                             ,
    IsMessage                               ,
    toMessage                               ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addFlags]("GI.Soup.Objects.Message#g:method:addFlags"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [disableFeature]("GI.Soup.Objects.Message#g:method:disableFeature"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFeatureDisabled]("GI.Soup.Objects.Message#g:method:isFeatureDisabled"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isKeepalive]("GI.Soup.Objects.Message#g:method:isKeepalive"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [queryFlags]("GI.Soup.Objects.Message#g:method:queryFlags"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeFlags]("GI.Soup.Objects.Message#g:method:removeFlags"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [tlsClientCertificatePasswordRequestComplete]("GI.Soup.Objects.Message#g:method:tlsClientCertificatePasswordRequestComplete"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getConnectionId]("GI.Soup.Objects.Message#g:method:getConnectionId"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFirstParty]("GI.Soup.Objects.Message#g:method:getFirstParty"), [getFlags]("GI.Soup.Objects.Message#g:method:getFlags"), [getForceHttp1]("GI.Soup.Objects.Message#g:method:getForceHttp1"), [getHttpVersion]("GI.Soup.Objects.Message#g:method:getHttpVersion"), [getIsOptionsPing]("GI.Soup.Objects.Message#g:method:getIsOptionsPing"), [getIsTopLevelNavigation]("GI.Soup.Objects.Message#g:method:getIsTopLevelNavigation"), [getMethod]("GI.Soup.Objects.Message#g:method:getMethod"), [getMetrics]("GI.Soup.Objects.Message#g:method:getMetrics"), [getPriority]("GI.Soup.Objects.Message#g:method:getPriority"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getReasonPhrase]("GI.Soup.Objects.Message#g:method:getReasonPhrase"), [getRemoteAddress]("GI.Soup.Objects.Message#g:method:getRemoteAddress"), [getRequestHeaders]("GI.Soup.Objects.Message#g:method:getRequestHeaders"), [getResponseHeaders]("GI.Soup.Objects.Message#g:method:getResponseHeaders"), [getSiteForCookies]("GI.Soup.Objects.Message#g:method:getSiteForCookies"), [getStatus]("GI.Soup.Objects.Message#g:method:getStatus"), [getTlsCiphersuiteName]("GI.Soup.Objects.Message#g:method:getTlsCiphersuiteName"), [getTlsPeerCertificate]("GI.Soup.Objects.Message#g:method:getTlsPeerCertificate"), [getTlsPeerCertificateErrors]("GI.Soup.Objects.Message#g:method:getTlsPeerCertificateErrors"), [getTlsProtocolVersion]("GI.Soup.Objects.Message#g:method:getTlsProtocolVersion"), [getUri]("GI.Soup.Objects.Message#g:method:getUri").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFirstParty]("GI.Soup.Objects.Message#g:method:setFirstParty"), [setFlags]("GI.Soup.Objects.Message#g:method:setFlags"), [setForceHttp1]("GI.Soup.Objects.Message#g:method:setForceHttp1"), [setIsOptionsPing]("GI.Soup.Objects.Message#g:method:setIsOptionsPing"), [setIsTopLevelNavigation]("GI.Soup.Objects.Message#g:method:setIsTopLevelNavigation"), [setMethod]("GI.Soup.Objects.Message#g:method:setMethod"), [setPriority]("GI.Soup.Objects.Message#g:method:setPriority"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRequestBody]("GI.Soup.Objects.Message#g:method:setRequestBody"), [setRequestBodyFromBytes]("GI.Soup.Objects.Message#g:method:setRequestBodyFromBytes"), [setSiteForCookies]("GI.Soup.Objects.Message#g:method:setSiteForCookies"), [setTlsClientCertificate]("GI.Soup.Objects.Message#g:method:setTlsClientCertificate"), [setUri]("GI.Soup.Objects.Message#g:method:setUri").

#if defined(ENABLE_OVERLOADING)
    ResolveMessageMethod                    ,
#endif

-- ** addFlags #method:addFlags#

#if defined(ENABLE_OVERLOADING)
    MessageAddFlagsMethodInfo               ,
#endif
    messageAddFlags                         ,


-- ** disableFeature #method:disableFeature#

#if defined(ENABLE_OVERLOADING)
    MessageDisableFeatureMethodInfo         ,
#endif
    messageDisableFeature                   ,


-- ** getConnectionId #method:getConnectionId#

#if defined(ENABLE_OVERLOADING)
    MessageGetConnectionIdMethodInfo        ,
#endif
    messageGetConnectionId                  ,


-- ** getFirstParty #method:getFirstParty#

#if defined(ENABLE_OVERLOADING)
    MessageGetFirstPartyMethodInfo          ,
#endif
    messageGetFirstParty                    ,


-- ** getFlags #method:getFlags#

#if defined(ENABLE_OVERLOADING)
    MessageGetFlagsMethodInfo               ,
#endif
    messageGetFlags                         ,


-- ** getForceHttp1 #method:getForceHttp1#

#if defined(ENABLE_OVERLOADING)
    MessageGetForceHttp1MethodInfo          ,
#endif
    messageGetForceHttp1                    ,


-- ** getHttpVersion #method:getHttpVersion#

#if defined(ENABLE_OVERLOADING)
    MessageGetHttpVersionMethodInfo         ,
#endif
    messageGetHttpVersion                   ,


-- ** getIsOptionsPing #method:getIsOptionsPing#

#if defined(ENABLE_OVERLOADING)
    MessageGetIsOptionsPingMethodInfo       ,
#endif
    messageGetIsOptionsPing                 ,


-- ** getIsTopLevelNavigation #method:getIsTopLevelNavigation#

#if defined(ENABLE_OVERLOADING)
    MessageGetIsTopLevelNavigationMethodInfo,
#endif
    messageGetIsTopLevelNavigation          ,


-- ** getMethod #method:getMethod#

#if defined(ENABLE_OVERLOADING)
    MessageGetMethodMethodInfo              ,
#endif
    messageGetMethod                        ,


-- ** getMetrics #method:getMetrics#

#if defined(ENABLE_OVERLOADING)
    MessageGetMetricsMethodInfo             ,
#endif
    messageGetMetrics                       ,


-- ** getPriority #method:getPriority#

#if defined(ENABLE_OVERLOADING)
    MessageGetPriorityMethodInfo            ,
#endif
    messageGetPriority                      ,


-- ** getReasonPhrase #method:getReasonPhrase#

#if defined(ENABLE_OVERLOADING)
    MessageGetReasonPhraseMethodInfo        ,
#endif
    messageGetReasonPhrase                  ,


-- ** getRemoteAddress #method:getRemoteAddress#

#if defined(ENABLE_OVERLOADING)
    MessageGetRemoteAddressMethodInfo       ,
#endif
    messageGetRemoteAddress                 ,


-- ** getRequestHeaders #method:getRequestHeaders#

#if defined(ENABLE_OVERLOADING)
    MessageGetRequestHeadersMethodInfo      ,
#endif
    messageGetRequestHeaders                ,


-- ** getResponseHeaders #method:getResponseHeaders#

#if defined(ENABLE_OVERLOADING)
    MessageGetResponseHeadersMethodInfo     ,
#endif
    messageGetResponseHeaders               ,


-- ** getSiteForCookies #method:getSiteForCookies#

#if defined(ENABLE_OVERLOADING)
    MessageGetSiteForCookiesMethodInfo      ,
#endif
    messageGetSiteForCookies                ,


-- ** getStatus #method:getStatus#

#if defined(ENABLE_OVERLOADING)
    MessageGetStatusMethodInfo              ,
#endif
    messageGetStatus                        ,


-- ** getTlsCiphersuiteName #method:getTlsCiphersuiteName#

#if defined(ENABLE_OVERLOADING)
    MessageGetTlsCiphersuiteNameMethodInfo  ,
#endif
    messageGetTlsCiphersuiteName            ,


-- ** getTlsPeerCertificate #method:getTlsPeerCertificate#

#if defined(ENABLE_OVERLOADING)
    MessageGetTlsPeerCertificateMethodInfo  ,
#endif
    messageGetTlsPeerCertificate            ,


-- ** getTlsPeerCertificateErrors #method:getTlsPeerCertificateErrors#

#if defined(ENABLE_OVERLOADING)
    MessageGetTlsPeerCertificateErrorsMethodInfo,
#endif
    messageGetTlsPeerCertificateErrors      ,


-- ** getTlsProtocolVersion #method:getTlsProtocolVersion#

#if defined(ENABLE_OVERLOADING)
    MessageGetTlsProtocolVersionMethodInfo  ,
#endif
    messageGetTlsProtocolVersion            ,


-- ** getUri #method:getUri#

#if defined(ENABLE_OVERLOADING)
    MessageGetUriMethodInfo                 ,
#endif
    messageGetUri                           ,


-- ** isFeatureDisabled #method:isFeatureDisabled#

#if defined(ENABLE_OVERLOADING)
    MessageIsFeatureDisabledMethodInfo      ,
#endif
    messageIsFeatureDisabled                ,


-- ** isKeepalive #method:isKeepalive#

#if defined(ENABLE_OVERLOADING)
    MessageIsKeepaliveMethodInfo            ,
#endif
    messageIsKeepalive                      ,


-- ** new #method:new#

    messageNew                              ,


-- ** newFromEncodedForm #method:newFromEncodedForm#

    messageNewFromEncodedForm               ,


-- ** newFromMultipart #method:newFromMultipart#

    messageNewFromMultipart                 ,


-- ** newFromUri #method:newFromUri#

    messageNewFromUri                       ,


-- ** newOptionsPing #method:newOptionsPing#

    messageNewOptionsPing                   ,


-- ** queryFlags #method:queryFlags#

#if defined(ENABLE_OVERLOADING)
    MessageQueryFlagsMethodInfo             ,
#endif
    messageQueryFlags                       ,


-- ** removeFlags #method:removeFlags#

#if defined(ENABLE_OVERLOADING)
    MessageRemoveFlagsMethodInfo            ,
#endif
    messageRemoveFlags                      ,


-- ** setFirstParty #method:setFirstParty#

#if defined(ENABLE_OVERLOADING)
    MessageSetFirstPartyMethodInfo          ,
#endif
    messageSetFirstParty                    ,


-- ** setFlags #method:setFlags#

#if defined(ENABLE_OVERLOADING)
    MessageSetFlagsMethodInfo               ,
#endif
    messageSetFlags                         ,


-- ** setForceHttp1 #method:setForceHttp1#

#if defined(ENABLE_OVERLOADING)
    MessageSetForceHttp1MethodInfo          ,
#endif
    messageSetForceHttp1                    ,


-- ** setIsOptionsPing #method:setIsOptionsPing#

#if defined(ENABLE_OVERLOADING)
    MessageSetIsOptionsPingMethodInfo       ,
#endif
    messageSetIsOptionsPing                 ,


-- ** setIsTopLevelNavigation #method:setIsTopLevelNavigation#

#if defined(ENABLE_OVERLOADING)
    MessageSetIsTopLevelNavigationMethodInfo,
#endif
    messageSetIsTopLevelNavigation          ,


-- ** setMethod #method:setMethod#

#if defined(ENABLE_OVERLOADING)
    MessageSetMethodMethodInfo              ,
#endif
    messageSetMethod                        ,


-- ** setPriority #method:setPriority#

#if defined(ENABLE_OVERLOADING)
    MessageSetPriorityMethodInfo            ,
#endif
    messageSetPriority                      ,


-- ** setRequestBody #method:setRequestBody#

#if defined(ENABLE_OVERLOADING)
    MessageSetRequestBodyMethodInfo         ,
#endif
    messageSetRequestBody                   ,


-- ** setRequestBodyFromBytes #method:setRequestBodyFromBytes#

#if defined(ENABLE_OVERLOADING)
    MessageSetRequestBodyFromBytesMethodInfo,
#endif
    messageSetRequestBodyFromBytes          ,


-- ** setSiteForCookies #method:setSiteForCookies#

#if defined(ENABLE_OVERLOADING)
    MessageSetSiteForCookiesMethodInfo      ,
#endif
    messageSetSiteForCookies                ,


-- ** setTlsClientCertificate #method:setTlsClientCertificate#

#if defined(ENABLE_OVERLOADING)
    MessageSetTlsClientCertificateMethodInfo,
#endif
    messageSetTlsClientCertificate          ,


-- ** setUri #method:setUri#

#if defined(ENABLE_OVERLOADING)
    MessageSetUriMethodInfo                 ,
#endif
    messageSetUri                           ,


-- ** tlsClientCertificatePasswordRequestComplete #method:tlsClientCertificatePasswordRequestComplete#

#if defined(ENABLE_OVERLOADING)
    MessageTlsClientCertificatePasswordRequestCompleteMethodInfo,
#endif
    messageTlsClientCertificatePasswordRequestComplete,




 -- * Properties


-- ** firstParty #attr:firstParty#
-- | The [struct/@gLib@/.Uri] loaded in the application when the message was
-- queued.

#if defined(ENABLE_OVERLOADING)
    MessageFirstPartyPropertyInfo           ,
#endif
    constructMessageFirstParty              ,
    getMessageFirstParty                    ,
#if defined(ENABLE_OVERLOADING)
    messageFirstParty                       ,
#endif
    setMessageFirstParty                    ,


-- ** flags #attr:flags#
-- | Various message options.

#if defined(ENABLE_OVERLOADING)
    MessageFlagsPropertyInfo                ,
#endif
    constructMessageFlags                   ,
    getMessageFlags                         ,
#if defined(ENABLE_OVERLOADING)
    messageFlags                            ,
#endif
    setMessageFlags                         ,


-- ** httpVersion #attr:httpVersion#
-- | The HTTP protocol version to use.

#if defined(ENABLE_OVERLOADING)
    MessageHttpVersionPropertyInfo          ,
#endif
    getMessageHttpVersion                   ,
#if defined(ENABLE_OVERLOADING)
    messageHttpVersion                      ,
#endif


-- ** isOptionsPing #attr:isOptionsPing#
-- | Whether the message is an OPTIONS ping.
-- 
-- The t'GI.Soup.Objects.Message.Message' is intended to be used to send
-- @OPTIONS *@ to a server. When set to 'P.True', the
-- path of [property/@message@/:uri] will be ignored and
-- [property/@message@/:method] set to @/SOUP_METHOD_OPTIONS/@.

#if defined(ENABLE_OVERLOADING)
    MessageIsOptionsPingPropertyInfo        ,
#endif
    constructMessageIsOptionsPing           ,
    getMessageIsOptionsPing                 ,
#if defined(ENABLE_OVERLOADING)
    messageIsOptionsPing                    ,
#endif
    setMessageIsOptionsPing                 ,


-- ** isTopLevelNavigation #attr:isTopLevelNavigation#
-- | Set when the message is navigating between top level domains.

#if defined(ENABLE_OVERLOADING)
    MessageIsTopLevelNavigationPropertyInfo ,
#endif
    constructMessageIsTopLevelNavigation    ,
    getMessageIsTopLevelNavigation          ,
#if defined(ENABLE_OVERLOADING)
    messageIsTopLevelNavigation             ,
#endif
    setMessageIsTopLevelNavigation          ,


-- ** method #attr:method#
-- | The message\'s HTTP method.

#if defined(ENABLE_OVERLOADING)
    MessageMethodPropertyInfo               ,
#endif
    constructMessageMethod                  ,
    getMessageMethod                        ,
#if defined(ENABLE_OVERLOADING)
    messageMethod                           ,
#endif
    setMessageMethod                        ,


-- ** priority #attr:priority#
-- | Sets the priority of the t'GI.Soup.Objects.Message.Message'. See
-- [method/@message@/.set_priority] for further details.

#if defined(ENABLE_OVERLOADING)
    MessagePriorityPropertyInfo             ,
#endif
    constructMessagePriority                ,
    getMessagePriority                      ,
#if defined(ENABLE_OVERLOADING)
    messagePriority                         ,
#endif
    setMessagePriority                      ,


-- ** reasonPhrase #attr:reasonPhrase#
-- | The HTTP response reason phrase.

#if defined(ENABLE_OVERLOADING)
    MessageReasonPhrasePropertyInfo         ,
#endif
    getMessageReasonPhrase                  ,
#if defined(ENABLE_OVERLOADING)
    messageReasonPhrase                     ,
#endif


-- ** remoteAddress #attr:remoteAddress#
-- | The remote t'GI.Gio.Objects.SocketAddress.SocketAddress' of the connection associated
-- with the message.

#if defined(ENABLE_OVERLOADING)
    MessageRemoteAddressPropertyInfo        ,
#endif
    getMessageRemoteAddress                 ,
#if defined(ENABLE_OVERLOADING)
    messageRemoteAddress                    ,
#endif


-- ** requestHeaders #attr:requestHeaders#
-- | The HTTP request headers.

#if defined(ENABLE_OVERLOADING)
    MessageRequestHeadersPropertyInfo       ,
#endif
    getMessageRequestHeaders                ,
#if defined(ENABLE_OVERLOADING)
    messageRequestHeaders                   ,
#endif


-- ** responseHeaders #attr:responseHeaders#
-- | The HTTP response headers.

#if defined(ENABLE_OVERLOADING)
    MessageResponseHeadersPropertyInfo      ,
#endif
    getMessageResponseHeaders               ,
#if defined(ENABLE_OVERLOADING)
    messageResponseHeaders                  ,
#endif


-- ** siteForCookies #attr:siteForCookies#
-- | Site used to compare cookies against. Used for SameSite cookie support.

#if defined(ENABLE_OVERLOADING)
    MessageSiteForCookiesPropertyInfo       ,
#endif
    clearMessageSiteForCookies              ,
    constructMessageSiteForCookies          ,
    getMessageSiteForCookies                ,
#if defined(ENABLE_OVERLOADING)
    messageSiteForCookies                   ,
#endif
    setMessageSiteForCookies                ,


-- ** statusCode #attr:statusCode#
-- | The HTTP response status code.

#if defined(ENABLE_OVERLOADING)
    MessageStatusCodePropertyInfo           ,
#endif
    getMessageStatusCode                    ,
#if defined(ENABLE_OVERLOADING)
    messageStatusCode                       ,
#endif


-- ** tlsCiphersuiteName #attr:tlsCiphersuiteName#
-- | The Name of TLS ciphersuite negotiated for this message connection.

#if defined(ENABLE_OVERLOADING)
    MessageTlsCiphersuiteNamePropertyInfo   ,
#endif
    getMessageTlsCiphersuiteName            ,
#if defined(ENABLE_OVERLOADING)
    messageTlsCiphersuiteName               ,
#endif


-- ** tlsPeerCertificate #attr:tlsPeerCertificate#
-- | The peer\'s t'GI.Gio.Objects.TlsCertificate.TlsCertificate' associated with the message.

#if defined(ENABLE_OVERLOADING)
    MessageTlsPeerCertificatePropertyInfo   ,
#endif
    getMessageTlsPeerCertificate            ,
#if defined(ENABLE_OVERLOADING)
    messageTlsPeerCertificate               ,
#endif


-- ** tlsPeerCertificateErrors #attr:tlsPeerCertificateErrors#
-- | The verification errors on [property/@message@/:tls-peer-certificate].

#if defined(ENABLE_OVERLOADING)
    MessageTlsPeerCertificateErrorsPropertyInfo,
#endif
    getMessageTlsPeerCertificateErrors      ,
#if defined(ENABLE_OVERLOADING)
    messageTlsPeerCertificateErrors         ,
#endif


-- ** tlsProtocolVersion #attr:tlsProtocolVersion#
-- | The TLS protocol version negotiated for the message connection.

#if defined(ENABLE_OVERLOADING)
    MessageTlsProtocolVersionPropertyInfo   ,
#endif
    getMessageTlsProtocolVersion            ,
#if defined(ENABLE_OVERLOADING)
    messageTlsProtocolVersion               ,
#endif


-- ** uri #attr:uri#
-- | The message\'s Request-URI.

#if defined(ENABLE_OVERLOADING)
    MessageUriPropertyInfo                  ,
#endif
    constructMessageUri                     ,
    getMessageUri                           ,
#if defined(ENABLE_OVERLOADING)
    messageUri                              ,
#endif
    setMessageUri                           ,




 -- * Signals


-- ** acceptCertificate #signal:acceptCertificate#

    MessageAcceptCertificateCallback        ,
#if defined(ENABLE_OVERLOADING)
    MessageAcceptCertificateSignalInfo      ,
#endif
    afterMessageAcceptCertificate           ,
    onMessageAcceptCertificate              ,


-- ** authenticate #signal:authenticate#

    MessageAuthenticateCallback             ,
#if defined(ENABLE_OVERLOADING)
    MessageAuthenticateSignalInfo           ,
#endif
    afterMessageAuthenticate                ,
    onMessageAuthenticate                   ,


-- ** contentSniffed #signal:contentSniffed#

    MessageContentSniffedCallback           ,
#if defined(ENABLE_OVERLOADING)
    MessageContentSniffedSignalInfo         ,
#endif
    afterMessageContentSniffed              ,
    onMessageContentSniffed                 ,


-- ** finished #signal:finished#

    MessageFinishedCallback                 ,
#if defined(ENABLE_OVERLOADING)
    MessageFinishedSignalInfo               ,
#endif
    afterMessageFinished                    ,
    onMessageFinished                       ,


-- ** gotBody #signal:gotBody#

    MessageGotBodyCallback                  ,
#if defined(ENABLE_OVERLOADING)
    MessageGotBodySignalInfo                ,
#endif
    afterMessageGotBody                     ,
    onMessageGotBody                        ,


-- ** gotBodyData #signal:gotBodyData#

    MessageGotBodyDataCallback              ,
#if defined(ENABLE_OVERLOADING)
    MessageGotBodyDataSignalInfo            ,
#endif
    afterMessageGotBodyData                 ,
    onMessageGotBodyData                    ,


-- ** gotHeaders #signal:gotHeaders#

    MessageGotHeadersCallback               ,
#if defined(ENABLE_OVERLOADING)
    MessageGotHeadersSignalInfo             ,
#endif
    afterMessageGotHeaders                  ,
    onMessageGotHeaders                     ,


-- ** gotInformational #signal:gotInformational#

    MessageGotInformationalCallback         ,
#if defined(ENABLE_OVERLOADING)
    MessageGotInformationalSignalInfo       ,
#endif
    afterMessageGotInformational            ,
    onMessageGotInformational               ,


-- ** hstsEnforced #signal:hstsEnforced#

    MessageHstsEnforcedCallback             ,
#if defined(ENABLE_OVERLOADING)
    MessageHstsEnforcedSignalInfo           ,
#endif
    afterMessageHstsEnforced                ,
    onMessageHstsEnforced                   ,


-- ** networkEvent #signal:networkEvent#

    MessageNetworkEventCallback             ,
#if defined(ENABLE_OVERLOADING)
    MessageNetworkEventSignalInfo           ,
#endif
    afterMessageNetworkEvent                ,
    onMessageNetworkEvent                   ,


-- ** requestCertificate #signal:requestCertificate#

    MessageRequestCertificateCallback       ,
#if defined(ENABLE_OVERLOADING)
    MessageRequestCertificateSignalInfo     ,
#endif
    afterMessageRequestCertificate          ,
    onMessageRequestCertificate             ,


-- ** requestCertificatePassword #signal:requestCertificatePassword#

    MessageRequestCertificatePasswordCallback,
#if defined(ENABLE_OVERLOADING)
    MessageRequestCertificatePasswordSignalInfo,
#endif
    afterMessageRequestCertificatePassword  ,
    onMessageRequestCertificatePassword     ,


-- ** restarted #signal:restarted#

    MessageRestartedCallback                ,
#if defined(ENABLE_OVERLOADING)
    MessageRestartedSignalInfo              ,
#endif
    afterMessageRestarted                   ,
    onMessageRestarted                      ,


-- ** starting #signal:starting#

    MessageStartingCallback                 ,
#if defined(ENABLE_OVERLOADING)
    MessageStartingSignalInfo               ,
#endif
    afterMessageStarting                    ,
    onMessageStarting                       ,


-- ** wroteBody #signal:wroteBody#

    MessageWroteBodyCallback                ,
#if defined(ENABLE_OVERLOADING)
    MessageWroteBodySignalInfo              ,
#endif
    afterMessageWroteBody                   ,
    onMessageWroteBody                      ,


-- ** wroteBodyData #signal:wroteBodyData#

    MessageWroteBodyDataCallback            ,
#if defined(ENABLE_OVERLOADING)
    MessageWroteBodyDataSignalInfo          ,
#endif
    afterMessageWroteBodyData               ,
    onMessageWroteBodyData                  ,


-- ** wroteHeaders #signal:wroteHeaders#

    MessageWroteHeadersCallback             ,
#if defined(ENABLE_OVERLOADING)
    MessageWroteHeadersSignalInfo           ,
#endif
    afterMessageWroteHeaders                ,
    onMessageWroteHeaders                   ,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.Uri as GLib.Uri
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Enums as Gio.Enums
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.TlsClientConnection as Gio.TlsClientConnection
import qualified GI.Gio.Objects.IOStream as Gio.IOStream
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress
import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import qualified GI.Gio.Objects.TlsPassword as Gio.TlsPassword
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Flags as Soup.Flags
import {-# SOURCE #-} qualified GI.Soup.Objects.Auth as Soup.Auth
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageMetrics as Soup.MessageMetrics
import {-# SOURCE #-} qualified GI.Soup.Structs.Multipart as Soup.Multipart

-- | Memory-managed wrapper type.
newtype Message = Message (SP.ManagedPtr Message)
    deriving (Message -> Message -> Bool
(Message -> Message -> Bool)
-> (Message -> Message -> Bool) -> Eq Message
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Message -> Message -> Bool
== :: Message -> Message -> Bool
$c/= :: Message -> Message -> Bool
/= :: Message -> Message -> Bool
Eq)

instance SP.ManagedPtrNewtype Message where
    toManagedPtr :: Message -> ManagedPtr Message
toManagedPtr (Message ManagedPtr Message
p) = ManagedPtr Message
p

foreign import ccall "soup_message_get_type"
    c_soup_message_get_type :: IO B.Types.GType

instance B.Types.TypedObject Message where
    glibType :: IO GType
glibType = IO GType
c_soup_message_get_type

instance B.Types.GObject Message

-- | Type class for types which can be safely cast to `Message`, for instance with `toMessage`.
class (SP.GObject o, O.IsDescendantOf Message o) => IsMessage o
instance (SP.GObject o, O.IsDescendantOf Message o) => IsMessage o

instance O.HasParentTypes Message
type instance O.ParentTypes Message = '[GObject.Object.Object]

-- | Cast to `Message`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toMessage :: (MIO.MonadIO m, IsMessage o) => o -> m Message
toMessage :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Message
toMessage = IO Message -> m Message
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Message -> m Message) -> (o -> IO Message) -> o -> m Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Message -> Message) -> o -> IO Message
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Message -> Message
Message

-- | Convert 'Message' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Message) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_message_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Message -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Message
P.Nothing = Ptr GValue -> Ptr Message -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Message
forall a. Ptr a
FP.nullPtr :: FP.Ptr Message)
    gvalueSet_ Ptr GValue
gv (P.Just Message
obj) = Message -> (Ptr Message -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Message
obj (Ptr GValue -> Ptr Message -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Message)
gvalueGet_ Ptr GValue
gv = do
        Ptr Message
ptr <- Ptr GValue -> IO (Ptr Message)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Message)
        if Ptr Message
ptr Ptr Message -> Ptr Message -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Message
forall a. Ptr a
FP.nullPtr
        then Message -> Maybe Message
forall a. a -> Maybe a
P.Just (Message -> Maybe Message) -> IO Message -> IO (Maybe Message)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Message -> Message
Message Ptr Message
ptr
        else Maybe Message -> IO (Maybe Message)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveMessageMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveMessageMethod "addFlags" o = MessageAddFlagsMethodInfo
    ResolveMessageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveMessageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveMessageMethod "disableFeature" o = MessageDisableFeatureMethodInfo
    ResolveMessageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveMessageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveMessageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveMessageMethod "isFeatureDisabled" o = MessageIsFeatureDisabledMethodInfo
    ResolveMessageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveMessageMethod "isKeepalive" o = MessageIsKeepaliveMethodInfo
    ResolveMessageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveMessageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveMessageMethod "queryFlags" o = MessageQueryFlagsMethodInfo
    ResolveMessageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveMessageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveMessageMethod "removeFlags" o = MessageRemoveFlagsMethodInfo
    ResolveMessageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveMessageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveMessageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveMessageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveMessageMethod "tlsClientCertificatePasswordRequestComplete" o = MessageTlsClientCertificatePasswordRequestCompleteMethodInfo
    ResolveMessageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveMessageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveMessageMethod "getConnectionId" o = MessageGetConnectionIdMethodInfo
    ResolveMessageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveMessageMethod "getFirstParty" o = MessageGetFirstPartyMethodInfo
    ResolveMessageMethod "getFlags" o = MessageGetFlagsMethodInfo
    ResolveMessageMethod "getForceHttp1" o = MessageGetForceHttp1MethodInfo
    ResolveMessageMethod "getHttpVersion" o = MessageGetHttpVersionMethodInfo
    ResolveMessageMethod "getIsOptionsPing" o = MessageGetIsOptionsPingMethodInfo
    ResolveMessageMethod "getIsTopLevelNavigation" o = MessageGetIsTopLevelNavigationMethodInfo
    ResolveMessageMethod "getMethod" o = MessageGetMethodMethodInfo
    ResolveMessageMethod "getMetrics" o = MessageGetMetricsMethodInfo
    ResolveMessageMethod "getPriority" o = MessageGetPriorityMethodInfo
    ResolveMessageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveMessageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveMessageMethod "getReasonPhrase" o = MessageGetReasonPhraseMethodInfo
    ResolveMessageMethod "getRemoteAddress" o = MessageGetRemoteAddressMethodInfo
    ResolveMessageMethod "getRequestHeaders" o = MessageGetRequestHeadersMethodInfo
    ResolveMessageMethod "getResponseHeaders" o = MessageGetResponseHeadersMethodInfo
    ResolveMessageMethod "getSiteForCookies" o = MessageGetSiteForCookiesMethodInfo
    ResolveMessageMethod "getStatus" o = MessageGetStatusMethodInfo
    ResolveMessageMethod "getTlsCiphersuiteName" o = MessageGetTlsCiphersuiteNameMethodInfo
    ResolveMessageMethod "getTlsPeerCertificate" o = MessageGetTlsPeerCertificateMethodInfo
    ResolveMessageMethod "getTlsPeerCertificateErrors" o = MessageGetTlsPeerCertificateErrorsMethodInfo
    ResolveMessageMethod "getTlsProtocolVersion" o = MessageGetTlsProtocolVersionMethodInfo
    ResolveMessageMethod "getUri" o = MessageGetUriMethodInfo
    ResolveMessageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveMessageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveMessageMethod "setFirstParty" o = MessageSetFirstPartyMethodInfo
    ResolveMessageMethod "setFlags" o = MessageSetFlagsMethodInfo
    ResolveMessageMethod "setForceHttp1" o = MessageSetForceHttp1MethodInfo
    ResolveMessageMethod "setIsOptionsPing" o = MessageSetIsOptionsPingMethodInfo
    ResolveMessageMethod "setIsTopLevelNavigation" o = MessageSetIsTopLevelNavigationMethodInfo
    ResolveMessageMethod "setMethod" o = MessageSetMethodMethodInfo
    ResolveMessageMethod "setPriority" o = MessageSetPriorityMethodInfo
    ResolveMessageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveMessageMethod "setRequestBody" o = MessageSetRequestBodyMethodInfo
    ResolveMessageMethod "setRequestBodyFromBytes" o = MessageSetRequestBodyFromBytesMethodInfo
    ResolveMessageMethod "setSiteForCookies" o = MessageSetSiteForCookiesMethodInfo
    ResolveMessageMethod "setTlsClientCertificate" o = MessageSetTlsClientCertificateMethodInfo
    ResolveMessageMethod "setUri" o = MessageSetUriMethodInfo
    ResolveMessageMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveMessageMethod t Message, O.OverloadedMethod info Message p) => OL.IsLabel t (Message -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveMessageMethod t Message, O.OverloadedMethod info Message p, R.HasField t Message p) => R.HasField t Message p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveMessageMethod t Message, O.OverloadedMethodInfo info Message) => OL.IsLabel t (O.MethodProxy info Message) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal Message::accept-certificate
-- | Emitted during the /@msg@/\'s connection TLS handshake
-- after an unacceptable TLS certificate has been received.
-- 
-- You can return 'P.True' to accept /@tlsCertificate@/ despite
-- /@tlsErrors@/.
type MessageAcceptCertificateCallback =
    Gio.TlsCertificate.TlsCertificate
    -- ^ /@tlsPeerCertificate@/: the peer\'s t'GI.Gio.Objects.TlsCertificate.TlsCertificate'
    -> [Gio.Flags.TlsCertificateFlags]
    -- ^ /@tlsPeerErrors@/: the tls errors of /@tlsCertificate@/
    -> IO Bool
    -- ^ __Returns:__ 'P.True' to accept the TLS certificate and stop other
    --   handlers from being invoked, or 'P.False' to propagate the
    --   event further.

type C_MessageAcceptCertificateCallback =
    Ptr Message ->                          -- object
    Ptr Gio.TlsCertificate.TlsCertificate ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_MessageAcceptCertificateCallback`.
foreign import ccall "wrapper"
    mk_MessageAcceptCertificateCallback :: C_MessageAcceptCertificateCallback -> IO (FunPtr C_MessageAcceptCertificateCallback)

wrap_MessageAcceptCertificateCallback :: 
    GObject a => (a -> MessageAcceptCertificateCallback) ->
    C_MessageAcceptCertificateCallback
wrap_MessageAcceptCertificateCallback :: forall a.
GObject a =>
(a -> MessageAcceptCertificateCallback)
-> C_MessageAcceptCertificateCallback
wrap_MessageAcceptCertificateCallback a -> MessageAcceptCertificateCallback
gi'cb Ptr Message
gi'selfPtr Ptr TlsCertificate
tlsPeerCertificate CUInt
tlsPeerErrors Ptr ()
_ = do
    TlsCertificate
tlsPeerCertificate' <- ((ManagedPtr TlsCertificate -> TlsCertificate)
-> Ptr TlsCertificate -> IO TlsCertificate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TlsCertificate -> TlsCertificate
Gio.TlsCertificate.TlsCertificate) Ptr TlsCertificate
tlsPeerCertificate
    let tlsPeerErrors' :: [TlsCertificateFlags]
tlsPeerErrors' = CUInt -> [TlsCertificateFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
tlsPeerErrors
    Bool
result <- Ptr Message -> (Message -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO Bool) -> IO Bool)
-> (Message -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageAcceptCertificateCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  TlsCertificate
tlsPeerCertificate' [TlsCertificateFlags]
tlsPeerErrors'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [acceptCertificate](#signal:acceptCertificate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #acceptCertificate callback
-- @
-- 
-- 
onMessageAcceptCertificate :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageAcceptCertificateCallback) -> m SignalHandlerId
onMessageAcceptCertificate :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageAcceptCertificateCallback)
-> m SignalHandlerId
onMessageAcceptCertificate a
obj (?self::a) => MessageAcceptCertificateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageAcceptCertificateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageAcceptCertificateCallback
MessageAcceptCertificateCallback
cb
    let wrapped' :: C_MessageAcceptCertificateCallback
wrapped' = (a -> MessageAcceptCertificateCallback)
-> C_MessageAcceptCertificateCallback
forall a.
GObject a =>
(a -> MessageAcceptCertificateCallback)
-> C_MessageAcceptCertificateCallback
wrap_MessageAcceptCertificateCallback a -> MessageAcceptCertificateCallback
wrapped
    FunPtr C_MessageAcceptCertificateCallback
wrapped'' <- C_MessageAcceptCertificateCallback
-> IO (FunPtr C_MessageAcceptCertificateCallback)
mk_MessageAcceptCertificateCallback C_MessageAcceptCertificateCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageAcceptCertificateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"accept-certificate" FunPtr C_MessageAcceptCertificateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [acceptCertificate](#signal:acceptCertificate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #acceptCertificate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageAcceptCertificate :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageAcceptCertificateCallback) -> m SignalHandlerId
afterMessageAcceptCertificate :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageAcceptCertificateCallback)
-> m SignalHandlerId
afterMessageAcceptCertificate a
obj (?self::a) => MessageAcceptCertificateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageAcceptCertificateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageAcceptCertificateCallback
MessageAcceptCertificateCallback
cb
    let wrapped' :: C_MessageAcceptCertificateCallback
wrapped' = (a -> MessageAcceptCertificateCallback)
-> C_MessageAcceptCertificateCallback
forall a.
GObject a =>
(a -> MessageAcceptCertificateCallback)
-> C_MessageAcceptCertificateCallback
wrap_MessageAcceptCertificateCallback a -> MessageAcceptCertificateCallback
wrapped
    FunPtr C_MessageAcceptCertificateCallback
wrapped'' <- C_MessageAcceptCertificateCallback
-> IO (FunPtr C_MessageAcceptCertificateCallback)
mk_MessageAcceptCertificateCallback C_MessageAcceptCertificateCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageAcceptCertificateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"accept-certificate" FunPtr C_MessageAcceptCertificateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageAcceptCertificateSignalInfo
instance SignalInfo MessageAcceptCertificateSignalInfo where
    type HaskellCallbackType MessageAcceptCertificateSignalInfo = MessageAcceptCertificateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageAcceptCertificateCallback cb
        cb'' <- mk_MessageAcceptCertificateCallback cb'
        connectSignalFunPtr obj "accept-certificate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::accept-certificate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:acceptCertificate"})

#endif

-- signal Message::authenticate
-- | Emitted when the message requires authentication.
-- 
-- If credentials are available call [method/@auth@/.authenticate] on
-- /@auth@/. If these credentials fail, the signal will be emitted again,
-- with /@retrying@/ set to 'P.True', which will continue until you return
-- without calling [method/@auth@/.authenticate] on /@auth@/.
-- 
-- Note that this may be emitted before /@msg@/\'s body has been
-- fully read.
-- 
-- You can authenticate /@auth@/ asynchronously by calling
-- 'GI.GObject.Objects.Object.objectRef' on /@auth@/ and returning 'P.True'. The operation will
-- complete once either [method/@auth@/.authenticate] or
-- [method/@auth@/.cancel] are called.
type MessageAuthenticateCallback =
    Soup.Auth.Auth
    -- ^ /@auth@/: the t'GI.Soup.Objects.Auth.Auth' to authenticate
    -> Bool
    -- ^ /@retrying@/: 'P.True' if this is the second (or later) attempt
    -> IO Bool
    -- ^ __Returns:__ 'P.True' to stop other handlers from being invoked
    --   or 'P.False' to propagate the event further.

type C_MessageAuthenticateCallback =
    Ptr Message ->                          -- object
    Ptr Soup.Auth.Auth ->
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_MessageAuthenticateCallback`.
foreign import ccall "wrapper"
    mk_MessageAuthenticateCallback :: C_MessageAuthenticateCallback -> IO (FunPtr C_MessageAuthenticateCallback)

wrap_MessageAuthenticateCallback :: 
    GObject a => (a -> MessageAuthenticateCallback) ->
    C_MessageAuthenticateCallback
wrap_MessageAuthenticateCallback :: forall a.
GObject a =>
(a -> MessageAuthenticateCallback) -> C_MessageAuthenticateCallback
wrap_MessageAuthenticateCallback a -> MessageAuthenticateCallback
gi'cb Ptr Message
gi'selfPtr Ptr Auth
auth CInt
retrying Ptr ()
_ = do
    Auth
auth' <- ((ManagedPtr Auth -> Auth) -> Ptr Auth -> IO Auth
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Auth -> Auth
Soup.Auth.Auth) Ptr Auth
auth
    let retrying' :: Bool
retrying' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
retrying
    Bool
result <- Ptr Message -> (Message -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO Bool) -> IO Bool)
-> (Message -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageAuthenticateCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  Auth
auth' Bool
retrying'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [authenticate](#signal:authenticate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #authenticate callback
-- @
-- 
-- 
onMessageAuthenticate :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageAuthenticateCallback) -> m SignalHandlerId
onMessageAuthenticate :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageAuthenticateCallback) -> m SignalHandlerId
onMessageAuthenticate a
obj (?self::a) => MessageAuthenticateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageAuthenticateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageAuthenticateCallback
MessageAuthenticateCallback
cb
    let wrapped' :: C_MessageAuthenticateCallback
wrapped' = (a -> MessageAuthenticateCallback) -> C_MessageAuthenticateCallback
forall a.
GObject a =>
(a -> MessageAuthenticateCallback) -> C_MessageAuthenticateCallback
wrap_MessageAuthenticateCallback a -> MessageAuthenticateCallback
wrapped
    FunPtr C_MessageAuthenticateCallback
wrapped'' <- C_MessageAuthenticateCallback
-> IO (FunPtr C_MessageAuthenticateCallback)
mk_MessageAuthenticateCallback C_MessageAuthenticateCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageAuthenticateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"authenticate" FunPtr C_MessageAuthenticateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [authenticate](#signal:authenticate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #authenticate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageAuthenticate :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageAuthenticateCallback) -> m SignalHandlerId
afterMessageAuthenticate :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageAuthenticateCallback) -> m SignalHandlerId
afterMessageAuthenticate a
obj (?self::a) => MessageAuthenticateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageAuthenticateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageAuthenticateCallback
MessageAuthenticateCallback
cb
    let wrapped' :: C_MessageAuthenticateCallback
wrapped' = (a -> MessageAuthenticateCallback) -> C_MessageAuthenticateCallback
forall a.
GObject a =>
(a -> MessageAuthenticateCallback) -> C_MessageAuthenticateCallback
wrap_MessageAuthenticateCallback a -> MessageAuthenticateCallback
wrapped
    FunPtr C_MessageAuthenticateCallback
wrapped'' <- C_MessageAuthenticateCallback
-> IO (FunPtr C_MessageAuthenticateCallback)
mk_MessageAuthenticateCallback C_MessageAuthenticateCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageAuthenticateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"authenticate" FunPtr C_MessageAuthenticateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageAuthenticateSignalInfo
instance SignalInfo MessageAuthenticateSignalInfo where
    type HaskellCallbackType MessageAuthenticateSignalInfo = MessageAuthenticateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageAuthenticateCallback cb
        cb'' <- mk_MessageAuthenticateCallback cb'
        connectSignalFunPtr obj "authenticate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::authenticate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:authenticate"})

#endif

-- signal Message::content-sniffed
-- | This signal is emitted after [signal/@message@/[gotHeaders](#g:signal:gotHeaders)].
-- 
-- If content sniffing is disabled, or no content sniffing will be
-- performed, due to the sniffer deciding to trust the
-- Content-Type sent by the server, this signal is emitted
-- immediately after [signal/@message@/[gotHeaders](#g:signal:gotHeaders)], and /@type@/ is
-- 'P.Nothing'.
type MessageContentSniffedCallback =
    T.Text
    -- ^ /@type@/: the content type that we got from sniffing
    -> Map.Map T.Text T.Text
    -- ^ /@params@/: a t'GI.GLib.Structs.HashTable.HashTable' with the parameters
    -> IO ()

type C_MessageContentSniffedCallback =
    Ptr Message ->                          -- object
    CString ->
    Ptr (GHashTable CString CString) ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageContentSniffedCallback`.
foreign import ccall "wrapper"
    mk_MessageContentSniffedCallback :: C_MessageContentSniffedCallback -> IO (FunPtr C_MessageContentSniffedCallback)

wrap_MessageContentSniffedCallback :: 
    GObject a => (a -> MessageContentSniffedCallback) ->
    C_MessageContentSniffedCallback
wrap_MessageContentSniffedCallback :: forall a.
GObject a =>
(a -> MessageContentSniffedCallback)
-> C_MessageContentSniffedCallback
wrap_MessageContentSniffedCallback a -> MessageContentSniffedCallback
gi'cb Ptr Message
gi'selfPtr CString
type_ Ptr (GHashTable CString CString)
params Ptr ()
_ = do
    Text
type_' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
type_
    [(PtrWrapped CString, PtrWrapped CString)]
params' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
params
    let params'' :: [(CString, PtrWrapped CString)]
params'' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
params'
    [(Text, PtrWrapped CString)]
params''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
params''
    let params'''' :: [(Text, CString)]
params'''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(Text, PtrWrapped CString)]
params'''
    [(Text, Text)]
params''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
params''''
    let params'''''' :: Map Text Text
params'''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
params'''''
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageContentSniffedCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  Text
type_' Map Text Text
params''''''


-- | Connect a signal handler for the [contentSniffed](#signal:contentSniffed) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #contentSniffed callback
-- @
-- 
-- 
onMessageContentSniffed :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageContentSniffedCallback) -> m SignalHandlerId
onMessageContentSniffed :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageContentSniffedCallback)
-> m SignalHandlerId
onMessageContentSniffed a
obj (?self::a) => MessageContentSniffedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageContentSniffedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageContentSniffedCallback
MessageContentSniffedCallback
cb
    let wrapped' :: C_MessageContentSniffedCallback
wrapped' = (a -> MessageContentSniffedCallback)
-> C_MessageContentSniffedCallback
forall a.
GObject a =>
(a -> MessageContentSniffedCallback)
-> C_MessageContentSniffedCallback
wrap_MessageContentSniffedCallback a -> MessageContentSniffedCallback
wrapped
    FunPtr C_MessageContentSniffedCallback
wrapped'' <- C_MessageContentSniffedCallback
-> IO (FunPtr C_MessageContentSniffedCallback)
mk_MessageContentSniffedCallback C_MessageContentSniffedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageContentSniffedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"content-sniffed" FunPtr C_MessageContentSniffedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [contentSniffed](#signal:contentSniffed) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #contentSniffed callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageContentSniffed :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageContentSniffedCallback) -> m SignalHandlerId
afterMessageContentSniffed :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageContentSniffedCallback)
-> m SignalHandlerId
afterMessageContentSniffed a
obj (?self::a) => MessageContentSniffedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageContentSniffedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageContentSniffedCallback
MessageContentSniffedCallback
cb
    let wrapped' :: C_MessageContentSniffedCallback
wrapped' = (a -> MessageContentSniffedCallback)
-> C_MessageContentSniffedCallback
forall a.
GObject a =>
(a -> MessageContentSniffedCallback)
-> C_MessageContentSniffedCallback
wrap_MessageContentSniffedCallback a -> MessageContentSniffedCallback
wrapped
    FunPtr C_MessageContentSniffedCallback
wrapped'' <- C_MessageContentSniffedCallback
-> IO (FunPtr C_MessageContentSniffedCallback)
mk_MessageContentSniffedCallback C_MessageContentSniffedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageContentSniffedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"content-sniffed" FunPtr C_MessageContentSniffedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageContentSniffedSignalInfo
instance SignalInfo MessageContentSniffedSignalInfo where
    type HaskellCallbackType MessageContentSniffedSignalInfo = MessageContentSniffedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageContentSniffedCallback cb
        cb'' <- mk_MessageContentSniffedCallback cb'
        connectSignalFunPtr obj "content-sniffed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::content-sniffed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:contentSniffed"})

#endif

-- signal Message::finished
-- | Emitted when all HTTP processing is finished for a message.
-- 
-- (After [signal/@message@/[got_body](#g:signal:got_body)]).
type MessageFinishedCallback =
    IO ()

type C_MessageFinishedCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageFinishedCallback`.
foreign import ccall "wrapper"
    mk_MessageFinishedCallback :: C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)

wrap_MessageFinishedCallback :: 
    GObject a => (a -> MessageFinishedCallback) ->
    C_MessageFinishedCallback
wrap_MessageFinishedCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageFinishedCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [finished](#signal:finished) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #finished callback
-- @
-- 
-- 
onMessageFinished :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageFinishedCallback) -> m SignalHandlerId
onMessageFinished :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageFinished a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageFinishedCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageFinishedCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"finished" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [finished](#signal:finished) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #finished callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageFinished :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageFinishedCallback) -> m SignalHandlerId
afterMessageFinished :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageFinished a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageFinishedCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageFinishedCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"finished" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageFinishedSignalInfo
instance SignalInfo MessageFinishedSignalInfo where
    type HaskellCallbackType MessageFinishedSignalInfo = MessageFinishedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageFinishedCallback cb
        cb'' <- mk_MessageFinishedCallback cb'
        connectSignalFunPtr obj "finished" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::finished"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:finished"})

#endif

-- signal Message::got-body
-- | Emitted after receiving the complete message response body.
type MessageGotBodyCallback =
    IO ()

type C_MessageGotBodyCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageGotBodyCallback`.
foreign import ccall "wrapper"
    mk_MessageGotBodyCallback :: C_MessageGotBodyCallback -> IO (FunPtr C_MessageGotBodyCallback)

wrap_MessageGotBodyCallback :: 
    GObject a => (a -> MessageGotBodyCallback) ->
    C_MessageGotBodyCallback
wrap_MessageGotBodyCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotBodyCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [gotBody](#signal:gotBody) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #gotBody callback
-- @
-- 
-- 
onMessageGotBody :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotBodyCallback) -> m SignalHandlerId
onMessageGotBody :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageGotBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotBodyCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageGotBodyCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-body" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gotBody](#signal:gotBody) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #gotBody callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageGotBody :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotBodyCallback) -> m SignalHandlerId
afterMessageGotBody :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageGotBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotBodyCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageGotBodyCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-body" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageGotBodySignalInfo
instance SignalInfo MessageGotBodySignalInfo where
    type HaskellCallbackType MessageGotBodySignalInfo = MessageGotBodyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageGotBodyCallback cb
        cb'' <- mk_MessageGotBodyCallback cb'
        connectSignalFunPtr obj "got-body" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::got-body"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:gotBody"})

#endif

-- signal Message::got-body-data
-- | Emitted after reading a portion of the message
-- body from the network.
-- 
-- /Since: 3.4/
type MessageGotBodyDataCallback =
    Word32
    -- ^ /@chunkSize@/: the number of bytes read
    -> IO ()

type C_MessageGotBodyDataCallback =
    Ptr Message ->                          -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageGotBodyDataCallback`.
foreign import ccall "wrapper"
    mk_MessageGotBodyDataCallback :: C_MessageGotBodyDataCallback -> IO (FunPtr C_MessageGotBodyDataCallback)

wrap_MessageGotBodyDataCallback :: 
    GObject a => (a -> MessageGotBodyDataCallback) ->
    C_MessageGotBodyDataCallback
wrap_MessageGotBodyDataCallback :: forall a.
GObject a =>
(a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
wrap_MessageGotBodyDataCallback a -> MessageGotBodyDataCallback
gi'cb Ptr Message
gi'selfPtr Word32
chunkSize Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageGotBodyDataCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  Word32
chunkSize


-- | Connect a signal handler for the [gotBodyData](#signal:gotBodyData) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #gotBodyData callback
-- @
-- 
-- 
onMessageGotBodyData :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotBodyDataCallback) -> m SignalHandlerId
onMessageGotBodyData :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageGotBodyDataCallback) -> m SignalHandlerId
onMessageGotBodyData a
obj (?self::a) => MessageGotBodyDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageGotBodyDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageGotBodyDataCallback
MessageGotBodyDataCallback
cb
    let wrapped' :: C_MessageGotBodyDataCallback
wrapped' = (a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
forall a.
GObject a =>
(a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
wrap_MessageGotBodyDataCallback a -> MessageGotBodyDataCallback
wrapped
    FunPtr C_MessageGotBodyDataCallback
wrapped'' <- C_MessageGotBodyDataCallback
-> IO (FunPtr C_MessageGotBodyDataCallback)
mk_MessageGotBodyDataCallback C_MessageGotBodyDataCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageGotBodyDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-body-data" FunPtr C_MessageGotBodyDataCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gotBodyData](#signal:gotBodyData) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #gotBodyData callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageGotBodyData :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotBodyDataCallback) -> m SignalHandlerId
afterMessageGotBodyData :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageGotBodyDataCallback) -> m SignalHandlerId
afterMessageGotBodyData a
obj (?self::a) => MessageGotBodyDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageGotBodyDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageGotBodyDataCallback
MessageGotBodyDataCallback
cb
    let wrapped' :: C_MessageGotBodyDataCallback
wrapped' = (a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
forall a.
GObject a =>
(a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
wrap_MessageGotBodyDataCallback a -> MessageGotBodyDataCallback
wrapped
    FunPtr C_MessageGotBodyDataCallback
wrapped'' <- C_MessageGotBodyDataCallback
-> IO (FunPtr C_MessageGotBodyDataCallback)
mk_MessageGotBodyDataCallback C_MessageGotBodyDataCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageGotBodyDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-body-data" FunPtr C_MessageGotBodyDataCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageGotBodyDataSignalInfo
instance SignalInfo MessageGotBodyDataSignalInfo where
    type HaskellCallbackType MessageGotBodyDataSignalInfo = MessageGotBodyDataCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageGotBodyDataCallback cb
        cb'' <- mk_MessageGotBodyDataCallback cb'
        connectSignalFunPtr obj "got-body-data" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::got-body-data"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:gotBodyData"})

#endif

-- signal Message::got-headers
-- | Emitted after receiving the Status-Line and response headers.
-- 
-- See also [method/@message@/.add_header_handler] and
-- [method/@message@/.add_status_code_handler], which can be used to
-- connect to a subset of emissions of this signal.
-- 
-- If you cancel or requeue /@msg@/ while processing this signal,
-- then the current HTTP I\/O will be stopped after this signal
-- emission finished, and /@msg@/\'s connection will be closed.
-- (If you need to requeue a message--eg, after handling
-- authentication or redirection--it is usually better to
-- requeue it from a [signal/@message@/[gotBody](#g:signal:gotBody)] handler rather
-- than a [signal/@message@/[got_headers](#g:signal:got_headers)] handler, so that the
-- existing HTTP connection can be reused.)
type MessageGotHeadersCallback =
    IO ()

type C_MessageGotHeadersCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageGotHeadersCallback`.
foreign import ccall "wrapper"
    mk_MessageGotHeadersCallback :: C_MessageGotHeadersCallback -> IO (FunPtr C_MessageGotHeadersCallback)

wrap_MessageGotHeadersCallback :: 
    GObject a => (a -> MessageGotHeadersCallback) ->
    C_MessageGotHeadersCallback
wrap_MessageGotHeadersCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotHeadersCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [gotHeaders](#signal:gotHeaders) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #gotHeaders callback
-- @
-- 
-- 
onMessageGotHeaders :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotHeadersCallback) -> m SignalHandlerId
onMessageGotHeaders :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageGotHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotHeadersCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageGotHeadersCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-headers" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gotHeaders](#signal:gotHeaders) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #gotHeaders callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageGotHeaders :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotHeadersCallback) -> m SignalHandlerId
afterMessageGotHeaders :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageGotHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotHeadersCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageGotHeadersCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-headers" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageGotHeadersSignalInfo
instance SignalInfo MessageGotHeadersSignalInfo where
    type HaskellCallbackType MessageGotHeadersSignalInfo = MessageGotHeadersCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageGotHeadersCallback cb
        cb'' <- mk_MessageGotHeadersCallback cb'
        connectSignalFunPtr obj "got-headers" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::got-headers"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:gotHeaders"})

#endif

-- signal Message::got-informational
-- | Emitted after receiving a 1xx (Informational) response for
-- a (client-side) message.
-- 
-- The response_headers will be filled in with the headers associated
-- with the informational response; however, those header values will be
-- erased after this signal is done.
-- 
-- If you cancel or requeue /@msg@/ while processing this signal,
-- then the current HTTP I\/O will be stopped after this signal
-- emission finished, and /@msg@/\'s connection will be closed.
type MessageGotInformationalCallback =
    IO ()

type C_MessageGotInformationalCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageGotInformationalCallback`.
foreign import ccall "wrapper"
    mk_MessageGotInformationalCallback :: C_MessageGotInformationalCallback -> IO (FunPtr C_MessageGotInformationalCallback)

wrap_MessageGotInformationalCallback :: 
    GObject a => (a -> MessageGotInformationalCallback) ->
    C_MessageGotInformationalCallback
wrap_MessageGotInformationalCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotInformationalCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [gotInformational](#signal:gotInformational) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #gotInformational callback
-- @
-- 
-- 
onMessageGotInformational :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotInformationalCallback) -> m SignalHandlerId
onMessageGotInformational :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageGotInformational a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotInformationalCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageGotInformationalCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-informational" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gotInformational](#signal:gotInformational) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #gotInformational callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageGotInformational :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageGotInformationalCallback) -> m SignalHandlerId
afterMessageGotInformational :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageGotInformational a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageGotInformationalCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageGotInformationalCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-informational" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageGotInformationalSignalInfo
instance SignalInfo MessageGotInformationalSignalInfo where
    type HaskellCallbackType MessageGotInformationalSignalInfo = MessageGotInformationalCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageGotInformationalCallback cb
        cb'' <- mk_MessageGotInformationalCallback cb'
        connectSignalFunPtr obj "got-informational" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::got-informational"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:gotInformational"})

#endif

-- signal Message::hsts-enforced
-- | Emitted when [class/@hSTSEnforcer@/] has upgraded the protocol
-- for /@msg@/ to HTTPS as a result of matching its domain with
-- a HSTS policy.
type MessageHstsEnforcedCallback =
    IO ()

type C_MessageHstsEnforcedCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageHstsEnforcedCallback`.
foreign import ccall "wrapper"
    mk_MessageHstsEnforcedCallback :: C_MessageHstsEnforcedCallback -> IO (FunPtr C_MessageHstsEnforcedCallback)

wrap_MessageHstsEnforcedCallback :: 
    GObject a => (a -> MessageHstsEnforcedCallback) ->
    C_MessageHstsEnforcedCallback
wrap_MessageHstsEnforcedCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageHstsEnforcedCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [hstsEnforced](#signal:hstsEnforced) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #hstsEnforced callback
-- @
-- 
-- 
onMessageHstsEnforced :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageHstsEnforcedCallback) -> m SignalHandlerId
onMessageHstsEnforced :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageHstsEnforced a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageHstsEnforcedCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageHstsEnforcedCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hsts-enforced" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hstsEnforced](#signal:hstsEnforced) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #hstsEnforced callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageHstsEnforced :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageHstsEnforcedCallback) -> m SignalHandlerId
afterMessageHstsEnforced :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageHstsEnforced a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageHstsEnforcedCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageHstsEnforcedCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hsts-enforced" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageHstsEnforcedSignalInfo
instance SignalInfo MessageHstsEnforcedSignalInfo where
    type HaskellCallbackType MessageHstsEnforcedSignalInfo = MessageHstsEnforcedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageHstsEnforcedCallback cb
        cb'' <- mk_MessageHstsEnforcedCallback cb'
        connectSignalFunPtr obj "hsts-enforced" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::hsts-enforced"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:hstsEnforced"})

#endif

-- signal Message::network-event
-- | Emitted to indicate that some network-related event
-- related to /@msg@/ has occurred.
-- 
-- This essentially proxies the [SocketClient::event]("GI.Gio.Objects.SocketClient#g:signal:event") signal,
-- but only for events that occur while /@msg@/ \"owns\" the connection; if
-- /@msg@/ is sent on an existing persistent connection, then this signal
-- will not be emitted. (If you want to force the message to be sent on
-- a new connection, set the 'GI.Soup.Flags.MessageFlagsNewConnection' flag on it.)
-- 
-- See [SocketClient::event]("GI.Gio.Objects.SocketClient#g:signal:event") for more information on what
-- the different values of /@event@/ correspond to, and what
-- /@connection@/ will be in each case.
type MessageNetworkEventCallback =
    Gio.Enums.SocketClientEvent
    -- ^ /@event@/: the network event
    -> Gio.IOStream.IOStream
    -- ^ /@connection@/: the current state of the network connection
    -> IO ()

type C_MessageNetworkEventCallback =
    Ptr Message ->                          -- object
    CUInt ->
    Ptr Gio.IOStream.IOStream ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageNetworkEventCallback`.
foreign import ccall "wrapper"
    mk_MessageNetworkEventCallback :: C_MessageNetworkEventCallback -> IO (FunPtr C_MessageNetworkEventCallback)

wrap_MessageNetworkEventCallback :: 
    GObject a => (a -> MessageNetworkEventCallback) ->
    C_MessageNetworkEventCallback
wrap_MessageNetworkEventCallback :: forall a.
GObject a =>
(a -> MessageNetworkEventCallback) -> C_MessageNetworkEventCallback
wrap_MessageNetworkEventCallback a -> MessageNetworkEventCallback
gi'cb Ptr Message
gi'selfPtr CUInt
event Ptr IOStream
connection Ptr ()
_ = do
    let event' :: SocketClientEvent
event' = (Int -> SocketClientEvent
forall a. Enum a => Int -> a
toEnum (Int -> SocketClientEvent)
-> (CUInt -> Int) -> CUInt -> SocketClientEvent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
event
    IOStream
connection' <- ((ManagedPtr IOStream -> IOStream) -> Ptr IOStream -> IO IOStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr IOStream -> IOStream
Gio.IOStream.IOStream) Ptr IOStream
connection
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageNetworkEventCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  SocketClientEvent
event' IOStream
connection'


-- | Connect a signal handler for the [networkEvent](#signal:networkEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #networkEvent callback
-- @
-- 
-- 
onMessageNetworkEvent :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageNetworkEventCallback) -> m SignalHandlerId
onMessageNetworkEvent :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageNetworkEventCallback) -> m SignalHandlerId
onMessageNetworkEvent a
obj (?self::a) => MessageNetworkEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageNetworkEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageNetworkEventCallback
MessageNetworkEventCallback
cb
    let wrapped' :: C_MessageNetworkEventCallback
wrapped' = (a -> MessageNetworkEventCallback) -> C_MessageNetworkEventCallback
forall a.
GObject a =>
(a -> MessageNetworkEventCallback) -> C_MessageNetworkEventCallback
wrap_MessageNetworkEventCallback a -> MessageNetworkEventCallback
wrapped
    FunPtr C_MessageNetworkEventCallback
wrapped'' <- C_MessageNetworkEventCallback
-> IO (FunPtr C_MessageNetworkEventCallback)
mk_MessageNetworkEventCallback C_MessageNetworkEventCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageNetworkEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"network-event" FunPtr C_MessageNetworkEventCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [networkEvent](#signal:networkEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #networkEvent callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageNetworkEvent :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageNetworkEventCallback) -> m SignalHandlerId
afterMessageNetworkEvent :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageNetworkEventCallback) -> m SignalHandlerId
afterMessageNetworkEvent a
obj (?self::a) => MessageNetworkEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageNetworkEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageNetworkEventCallback
MessageNetworkEventCallback
cb
    let wrapped' :: C_MessageNetworkEventCallback
wrapped' = (a -> MessageNetworkEventCallback) -> C_MessageNetworkEventCallback
forall a.
GObject a =>
(a -> MessageNetworkEventCallback) -> C_MessageNetworkEventCallback
wrap_MessageNetworkEventCallback a -> MessageNetworkEventCallback
wrapped
    FunPtr C_MessageNetworkEventCallback
wrapped'' <- C_MessageNetworkEventCallback
-> IO (FunPtr C_MessageNetworkEventCallback)
mk_MessageNetworkEventCallback C_MessageNetworkEventCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageNetworkEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"network-event" FunPtr C_MessageNetworkEventCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageNetworkEventSignalInfo
instance SignalInfo MessageNetworkEventSignalInfo where
    type HaskellCallbackType MessageNetworkEventSignalInfo = MessageNetworkEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageNetworkEventCallback cb
        cb'' <- mk_MessageNetworkEventCallback cb'
        connectSignalFunPtr obj "network-event" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::network-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:networkEvent"})

#endif

-- signal Message::request-certificate
-- | Emitted during the /@msg@/\'s connection TLS handshake when
-- /@tlsConnection@/ requests a certificate from the client.
-- 
-- You can set the client certificate by calling
-- [method/@message@/.set_tls_client_certificate] and returning 'P.True'. It\'s
-- possible to handle the request asynchornously by returning 'P.True' and
-- call [method/@message@/.set_tls_client_certificate] later once the
-- certificate is available. Note that this signal is not emitted if
-- [property/@session@/:tls-interaction] was set, or if
-- [method/@message@/.set_tls_client_certificate] was called before the
-- connection TLS handshake started.
type MessageRequestCertificateCallback =
    Gio.TlsClientConnection.TlsClientConnection
    -- ^ /@tlsConnection@/: the t'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' to handle the request, or 'P.False' to make the connection
    --   fail with 'GI.Gio.Enums.TlsErrorCertificateRequired'.

type C_MessageRequestCertificateCallback =
    Ptr Message ->                          -- object
    Ptr Gio.TlsClientConnection.TlsClientConnection ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_MessageRequestCertificateCallback`.
foreign import ccall "wrapper"
    mk_MessageRequestCertificateCallback :: C_MessageRequestCertificateCallback -> IO (FunPtr C_MessageRequestCertificateCallback)

wrap_MessageRequestCertificateCallback :: 
    GObject a => (a -> MessageRequestCertificateCallback) ->
    C_MessageRequestCertificateCallback
wrap_MessageRequestCertificateCallback :: forall a.
GObject a =>
(a -> MessageRequestCertificateCallback)
-> C_MessageRequestCertificateCallback
wrap_MessageRequestCertificateCallback a -> MessageRequestCertificateCallback
gi'cb Ptr Message
gi'selfPtr Ptr TlsClientConnection
tlsConnection Ptr ()
_ = do
    TlsClientConnection
tlsConnection' <- ((ManagedPtr TlsClientConnection -> TlsClientConnection)
-> Ptr TlsClientConnection -> IO TlsClientConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TlsClientConnection -> TlsClientConnection
Gio.TlsClientConnection.TlsClientConnection) Ptr TlsClientConnection
tlsConnection
    Bool
result <- Ptr Message -> (Message -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO Bool) -> IO Bool)
-> (Message -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageRequestCertificateCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  TlsClientConnection
tlsConnection'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [requestCertificate](#signal:requestCertificate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #requestCertificate callback
-- @
-- 
-- 
onMessageRequestCertificate :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageRequestCertificateCallback) -> m SignalHandlerId
onMessageRequestCertificate :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageRequestCertificateCallback)
-> m SignalHandlerId
onMessageRequestCertificate a
obj (?self::a) => MessageRequestCertificateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageRequestCertificateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageRequestCertificateCallback
MessageRequestCertificateCallback
cb
    let wrapped' :: C_MessageRequestCertificateCallback
wrapped' = (a -> MessageRequestCertificateCallback)
-> C_MessageRequestCertificateCallback
forall a.
GObject a =>
(a -> MessageRequestCertificateCallback)
-> C_MessageRequestCertificateCallback
wrap_MessageRequestCertificateCallback a -> MessageRequestCertificateCallback
wrapped
    FunPtr C_MessageRequestCertificateCallback
wrapped'' <- C_MessageRequestCertificateCallback
-> IO (FunPtr C_MessageRequestCertificateCallback)
mk_MessageRequestCertificateCallback C_MessageRequestCertificateCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageRequestCertificateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"request-certificate" FunPtr C_MessageRequestCertificateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [requestCertificate](#signal:requestCertificate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #requestCertificate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageRequestCertificate :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageRequestCertificateCallback) -> m SignalHandlerId
afterMessageRequestCertificate :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageRequestCertificateCallback)
-> m SignalHandlerId
afterMessageRequestCertificate a
obj (?self::a) => MessageRequestCertificateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageRequestCertificateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageRequestCertificateCallback
MessageRequestCertificateCallback
cb
    let wrapped' :: C_MessageRequestCertificateCallback
wrapped' = (a -> MessageRequestCertificateCallback)
-> C_MessageRequestCertificateCallback
forall a.
GObject a =>
(a -> MessageRequestCertificateCallback)
-> C_MessageRequestCertificateCallback
wrap_MessageRequestCertificateCallback a -> MessageRequestCertificateCallback
wrapped
    FunPtr C_MessageRequestCertificateCallback
wrapped'' <- C_MessageRequestCertificateCallback
-> IO (FunPtr C_MessageRequestCertificateCallback)
mk_MessageRequestCertificateCallback C_MessageRequestCertificateCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageRequestCertificateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"request-certificate" FunPtr C_MessageRequestCertificateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageRequestCertificateSignalInfo
instance SignalInfo MessageRequestCertificateSignalInfo where
    type HaskellCallbackType MessageRequestCertificateSignalInfo = MessageRequestCertificateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageRequestCertificateCallback cb
        cb'' <- mk_MessageRequestCertificateCallback cb'
        connectSignalFunPtr obj "request-certificate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::request-certificate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:requestCertificate"})

#endif

-- signal Message::request-certificate-password
-- | Emitted during the /@msg@/\'s connection TLS handshake when
-- /@tlsConnection@/ requests a certificate password from the client.
-- 
-- You can set the certificate password on /@password@/, then call
-- [method/@message@/.tls_client_certificate_password_request_complete] and
-- return 'P.True' to handle the signal synchronously. It\'s possible to
-- handle the request asynchornously by calling
-- 'GI.GObject.Objects.Object.objectRef' on /@password@/, then returning 'P.True' and
-- call
-- [method/@message@/.tls_client_certificate_password_request_complete]
-- later after setting the password on /@password@/. Note that this signal
-- is not emitted if [property/@session@/:tls-interaction] was set.
type MessageRequestCertificatePasswordCallback =
    Gio.TlsPassword.TlsPassword
    -- ^ /@tlsPassword@/: the t'GI.Gio.Objects.TlsPassword.TlsPassword'
    -> IO Bool
    -- ^ __Returns:__ 'P.True' to handle the request, or 'P.False' to make the connection
    --   fail with 'GI.Gio.Enums.TlsErrorCertificateRequired'.

type C_MessageRequestCertificatePasswordCallback =
    Ptr Message ->                          -- object
    Ptr Gio.TlsPassword.TlsPassword ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_MessageRequestCertificatePasswordCallback`.
foreign import ccall "wrapper"
    mk_MessageRequestCertificatePasswordCallback :: C_MessageRequestCertificatePasswordCallback -> IO (FunPtr C_MessageRequestCertificatePasswordCallback)

wrap_MessageRequestCertificatePasswordCallback :: 
    GObject a => (a -> MessageRequestCertificatePasswordCallback) ->
    C_MessageRequestCertificatePasswordCallback
wrap_MessageRequestCertificatePasswordCallback :: forall a.
GObject a =>
(a -> MessageRequestCertificatePasswordCallback)
-> C_MessageRequestCertificatePasswordCallback
wrap_MessageRequestCertificatePasswordCallback a -> MessageRequestCertificatePasswordCallback
gi'cb Ptr Message
gi'selfPtr Ptr TlsPassword
tlsPassword Ptr ()
_ = do
    TlsPassword
tlsPassword' <- ((ManagedPtr TlsPassword -> TlsPassword)
-> Ptr TlsPassword -> IO TlsPassword
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TlsPassword -> TlsPassword
Gio.TlsPassword.TlsPassword) Ptr TlsPassword
tlsPassword
    Bool
result <- Ptr Message -> (Message -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO Bool) -> IO Bool)
-> (Message -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageRequestCertificatePasswordCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  TlsPassword
tlsPassword'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [requestCertificatePassword](#signal:requestCertificatePassword) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #requestCertificatePassword callback
-- @
-- 
-- 
onMessageRequestCertificatePassword :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageRequestCertificatePasswordCallback) -> m SignalHandlerId
onMessageRequestCertificatePassword :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageRequestCertificatePasswordCallback)
-> m SignalHandlerId
onMessageRequestCertificatePassword a
obj (?self::a) => MessageRequestCertificatePasswordCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageRequestCertificatePasswordCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageRequestCertificatePasswordCallback
MessageRequestCertificatePasswordCallback
cb
    let wrapped' :: C_MessageRequestCertificatePasswordCallback
wrapped' = (a -> MessageRequestCertificatePasswordCallback)
-> C_MessageRequestCertificatePasswordCallback
forall a.
GObject a =>
(a -> MessageRequestCertificatePasswordCallback)
-> C_MessageRequestCertificatePasswordCallback
wrap_MessageRequestCertificatePasswordCallback a -> MessageRequestCertificatePasswordCallback
wrapped
    FunPtr C_MessageRequestCertificatePasswordCallback
wrapped'' <- C_MessageRequestCertificatePasswordCallback
-> IO (FunPtr C_MessageRequestCertificatePasswordCallback)
mk_MessageRequestCertificatePasswordCallback C_MessageRequestCertificatePasswordCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageRequestCertificatePasswordCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"request-certificate-password" FunPtr C_MessageRequestCertificatePasswordCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [requestCertificatePassword](#signal:requestCertificatePassword) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #requestCertificatePassword callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageRequestCertificatePassword :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageRequestCertificatePasswordCallback) -> m SignalHandlerId
afterMessageRequestCertificatePassword :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageRequestCertificatePasswordCallback)
-> m SignalHandlerId
afterMessageRequestCertificatePassword a
obj (?self::a) => MessageRequestCertificatePasswordCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageRequestCertificatePasswordCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageRequestCertificatePasswordCallback
MessageRequestCertificatePasswordCallback
cb
    let wrapped' :: C_MessageRequestCertificatePasswordCallback
wrapped' = (a -> MessageRequestCertificatePasswordCallback)
-> C_MessageRequestCertificatePasswordCallback
forall a.
GObject a =>
(a -> MessageRequestCertificatePasswordCallback)
-> C_MessageRequestCertificatePasswordCallback
wrap_MessageRequestCertificatePasswordCallback a -> MessageRequestCertificatePasswordCallback
wrapped
    FunPtr C_MessageRequestCertificatePasswordCallback
wrapped'' <- C_MessageRequestCertificatePasswordCallback
-> IO (FunPtr C_MessageRequestCertificatePasswordCallback)
mk_MessageRequestCertificatePasswordCallback C_MessageRequestCertificatePasswordCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageRequestCertificatePasswordCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"request-certificate-password" FunPtr C_MessageRequestCertificatePasswordCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageRequestCertificatePasswordSignalInfo
instance SignalInfo MessageRequestCertificatePasswordSignalInfo where
    type HaskellCallbackType MessageRequestCertificatePasswordSignalInfo = MessageRequestCertificatePasswordCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageRequestCertificatePasswordCallback cb
        cb'' <- mk_MessageRequestCertificatePasswordCallback cb'
        connectSignalFunPtr obj "request-certificate-password" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::request-certificate-password"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:requestCertificatePassword"})

#endif

-- signal Message::restarted
-- | Emitted when a request that was already sent once is now
-- being sent again.
-- 
-- e.g. because the first attempt received a
-- redirection response, or because we needed to use
-- authentication.
type MessageRestartedCallback =
    IO ()

type C_MessageRestartedCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageRestartedCallback`.
foreign import ccall "wrapper"
    mk_MessageRestartedCallback :: C_MessageRestartedCallback -> IO (FunPtr C_MessageRestartedCallback)

wrap_MessageRestartedCallback :: 
    GObject a => (a -> MessageRestartedCallback) ->
    C_MessageRestartedCallback
wrap_MessageRestartedCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageRestartedCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [restarted](#signal:restarted) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #restarted callback
-- @
-- 
-- 
onMessageRestarted :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageRestartedCallback) -> m SignalHandlerId
onMessageRestarted :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageRestarted a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageRestartedCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageRestartedCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"restarted" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [restarted](#signal:restarted) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #restarted callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageRestarted :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageRestartedCallback) -> m SignalHandlerId
afterMessageRestarted :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageRestarted a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageRestartedCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageRestartedCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"restarted" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageRestartedSignalInfo
instance SignalInfo MessageRestartedSignalInfo where
    type HaskellCallbackType MessageRestartedSignalInfo = MessageRestartedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageRestartedCallback cb
        cb'' <- mk_MessageRestartedCallback cb'
        connectSignalFunPtr obj "restarted" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::restarted"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:restarted"})

#endif

-- signal Message::starting
-- | Emitted just before a message is sent.
type MessageStartingCallback =
    IO ()

type C_MessageStartingCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageStartingCallback`.
foreign import ccall "wrapper"
    mk_MessageStartingCallback :: C_MessageStartingCallback -> IO (FunPtr C_MessageStartingCallback)

wrap_MessageStartingCallback :: 
    GObject a => (a -> MessageStartingCallback) ->
    C_MessageStartingCallback
wrap_MessageStartingCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageStartingCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [starting](#signal:starting) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #starting callback
-- @
-- 
-- 
onMessageStarting :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageStartingCallback) -> m SignalHandlerId
onMessageStarting :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageStarting a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageStartingCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageStartingCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"starting" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [starting](#signal:starting) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #starting callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageStarting :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageStartingCallback) -> m SignalHandlerId
afterMessageStarting :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageStarting a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageStartingCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageStartingCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"starting" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageStartingSignalInfo
instance SignalInfo MessageStartingSignalInfo where
    type HaskellCallbackType MessageStartingSignalInfo = MessageStartingCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageStartingCallback cb
        cb'' <- mk_MessageStartingCallback cb'
        connectSignalFunPtr obj "starting" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::starting"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:starting"})

#endif

-- signal Message::wrote-body
-- | Emitted immediately after writing the complete body for a
-- message.
type MessageWroteBodyCallback =
    IO ()

type C_MessageWroteBodyCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageWroteBodyCallback`.
foreign import ccall "wrapper"
    mk_MessageWroteBodyCallback :: C_MessageWroteBodyCallback -> IO (FunPtr C_MessageWroteBodyCallback)

wrap_MessageWroteBodyCallback :: 
    GObject a => (a -> MessageWroteBodyCallback) ->
    C_MessageWroteBodyCallback
wrap_MessageWroteBodyCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageWroteBodyCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [wroteBody](#signal:wroteBody) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #wroteBody callback
-- @
-- 
-- 
onMessageWroteBody :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageWroteBodyCallback) -> m SignalHandlerId
onMessageWroteBody :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageWroteBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageWroteBodyCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageWroteBodyCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteBody](#signal:wroteBody) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #wroteBody callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageWroteBody :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageWroteBodyCallback) -> m SignalHandlerId
afterMessageWroteBody :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageWroteBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageWroteBodyCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageWroteBodyCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageWroteBodySignalInfo
instance SignalInfo MessageWroteBodySignalInfo where
    type HaskellCallbackType MessageWroteBodySignalInfo = MessageWroteBodyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageWroteBodyCallback cb
        cb'' <- mk_MessageWroteBodyCallback cb'
        connectSignalFunPtr obj "wrote-body" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::wrote-body"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:wroteBody"})

#endif

-- signal Message::wrote-body-data
-- | Emitted immediately after writing a portion of the message
-- body to the network.
type MessageWroteBodyDataCallback =
    Word32
    -- ^ /@chunkSize@/: the number of bytes written
    -> IO ()

type C_MessageWroteBodyDataCallback =
    Ptr Message ->                          -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageWroteBodyDataCallback`.
foreign import ccall "wrapper"
    mk_MessageWroteBodyDataCallback :: C_MessageWroteBodyDataCallback -> IO (FunPtr C_MessageWroteBodyDataCallback)

wrap_MessageWroteBodyDataCallback :: 
    GObject a => (a -> MessageWroteBodyDataCallback) ->
    C_MessageWroteBodyDataCallback
wrap_MessageWroteBodyDataCallback :: forall a.
GObject a =>
(a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
wrap_MessageWroteBodyDataCallback a -> MessageGotBodyDataCallback
gi'cb Ptr Message
gi'selfPtr Word32
chunkSize Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> MessageGotBodyDataCallback
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self)  Word32
chunkSize


-- | Connect a signal handler for the [wroteBodyData](#signal:wroteBodyData) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #wroteBodyData callback
-- @
-- 
-- 
onMessageWroteBodyData :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageWroteBodyDataCallback) -> m SignalHandlerId
onMessageWroteBodyData :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageGotBodyDataCallback) -> m SignalHandlerId
onMessageWroteBodyData a
obj (?self::a) => MessageGotBodyDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageGotBodyDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageGotBodyDataCallback
MessageGotBodyDataCallback
cb
    let wrapped' :: C_MessageGotBodyDataCallback
wrapped' = (a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
forall a.
GObject a =>
(a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
wrap_MessageWroteBodyDataCallback a -> MessageGotBodyDataCallback
wrapped
    FunPtr C_MessageGotBodyDataCallback
wrapped'' <- C_MessageGotBodyDataCallback
-> IO (FunPtr C_MessageGotBodyDataCallback)
mk_MessageWroteBodyDataCallback C_MessageGotBodyDataCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageGotBodyDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body-data" FunPtr C_MessageGotBodyDataCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteBodyData](#signal:wroteBodyData) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #wroteBodyData callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageWroteBodyData :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageWroteBodyDataCallback) -> m SignalHandlerId
afterMessageWroteBodyData :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a
-> ((?self::a) => MessageGotBodyDataCallback) -> m SignalHandlerId
afterMessageWroteBodyData a
obj (?self::a) => MessageGotBodyDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> MessageGotBodyDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageGotBodyDataCallback
MessageGotBodyDataCallback
cb
    let wrapped' :: C_MessageGotBodyDataCallback
wrapped' = (a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
forall a.
GObject a =>
(a -> MessageGotBodyDataCallback) -> C_MessageGotBodyDataCallback
wrap_MessageWroteBodyDataCallback a -> MessageGotBodyDataCallback
wrapped
    FunPtr C_MessageGotBodyDataCallback
wrapped'' <- C_MessageGotBodyDataCallback
-> IO (FunPtr C_MessageGotBodyDataCallback)
mk_MessageWroteBodyDataCallback C_MessageGotBodyDataCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageGotBodyDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body-data" FunPtr C_MessageGotBodyDataCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageWroteBodyDataSignalInfo
instance SignalInfo MessageWroteBodyDataSignalInfo where
    type HaskellCallbackType MessageWroteBodyDataSignalInfo = MessageWroteBodyDataCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageWroteBodyDataCallback cb
        cb'' <- mk_MessageWroteBodyDataCallback cb'
        connectSignalFunPtr obj "wrote-body-data" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::wrote-body-data"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:wroteBodyData"})

#endif

-- signal Message::wrote-headers
-- | Emitted immediately after writing the request headers for a
-- message.
type MessageWroteHeadersCallback =
    IO ()

type C_MessageWroteHeadersCallback =
    Ptr Message ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_MessageWroteHeadersCallback`.
foreign import ccall "wrapper"
    mk_MessageWroteHeadersCallback :: C_MessageWroteHeadersCallback -> IO (FunPtr C_MessageWroteHeadersCallback)

wrap_MessageWroteHeadersCallback :: 
    GObject a => (a -> MessageWroteHeadersCallback) ->
    C_MessageWroteHeadersCallback
wrap_MessageWroteHeadersCallback :: forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageWroteHeadersCallback a -> IO ()
gi'cb Ptr Message
gi'selfPtr Ptr ()
_ = do
    Ptr Message -> (Message -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Message
gi'selfPtr ((Message -> IO ()) -> IO ()) -> (Message -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Message
gi'self -> a -> IO ()
gi'cb (Message -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Message
gi'self) 


-- | Connect a signal handler for the [wroteHeaders](#signal:wroteHeaders) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' message #wroteHeaders callback
-- @
-- 
-- 
onMessageWroteHeaders :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageWroteHeadersCallback) -> m SignalHandlerId
onMessageWroteHeaders :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onMessageWroteHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageWroteHeadersCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageWroteHeadersCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-headers" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteHeaders](#signal:wroteHeaders) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' message #wroteHeaders callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterMessageWroteHeaders :: (IsMessage a, MonadIO m) => a -> ((?self :: a) => MessageWroteHeadersCallback) -> m SignalHandlerId
afterMessageWroteHeaders :: forall a (m :: * -> *).
(IsMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterMessageWroteHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_MessageFinishedCallback
wrapped' = (a -> IO ()) -> C_MessageFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_MessageFinishedCallback
wrap_MessageWroteHeadersCallback a -> IO ()
wrapped
    FunPtr C_MessageFinishedCallback
wrapped'' <- C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
mk_MessageWroteHeadersCallback C_MessageFinishedCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-headers" FunPtr C_MessageFinishedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data MessageWroteHeadersSignalInfo
instance SignalInfo MessageWroteHeadersSignalInfo where
    type HaskellCallbackType MessageWroteHeadersSignalInfo = MessageWroteHeadersCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageWroteHeadersCallback cb
        cb'' <- mk_MessageWroteHeadersCallback cb'
        connectSignalFunPtr obj "wrote-headers" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message::wrote-headers"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:signal:wroteHeaders"})

#endif

-- VVV Prop "first-party"
   -- Type: TInterface (Name {namespace = "GLib", name = "Uri"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@first-party@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #firstParty
-- @
getMessageFirstParty :: (MonadIO m, IsMessage o) => o -> m GLib.Uri.Uri
getMessageFirstParty :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Uri
getMessageFirstParty o
obj = IO Uri -> m Uri
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Uri -> m Uri) -> IO Uri -> m Uri
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Uri) -> IO Uri
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getMessageFirstParty" (IO (Maybe Uri) -> IO Uri) -> IO (Maybe Uri) -> IO Uri
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Uri -> Uri) -> IO (Maybe Uri)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"first-party" ManagedPtr Uri -> Uri
GLib.Uri.Uri

-- | Set the value of the “@first-party@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #firstParty 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageFirstParty :: (MonadIO m, IsMessage o) => o -> GLib.Uri.Uri -> m ()
setMessageFirstParty :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> Uri -> m ()
setMessageFirstParty o
obj Uri
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Uri -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"first-party" (Uri -> Maybe Uri
forall a. a -> Maybe a
Just Uri
val)

-- | Construct a `GValueConstruct` with valid value for the “@first-party@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageFirstParty :: (IsMessage o, MIO.MonadIO m) => GLib.Uri.Uri -> m (GValueConstruct o)
constructMessageFirstParty :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
Uri -> m (GValueConstruct o)
constructMessageFirstParty Uri
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Uri -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"first-party" (Uri -> Maybe Uri
forall a. a -> Maybe a
P.Just Uri
val)

#if defined(ENABLE_OVERLOADING)
data MessageFirstPartyPropertyInfo
instance AttrInfo MessageFirstPartyPropertyInfo where
    type AttrAllowedOps MessageFirstPartyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageFirstPartyPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageFirstPartyPropertyInfo = (~) GLib.Uri.Uri
    type AttrTransferTypeConstraint MessageFirstPartyPropertyInfo = (~) GLib.Uri.Uri
    type AttrTransferType MessageFirstPartyPropertyInfo = GLib.Uri.Uri
    type AttrGetType MessageFirstPartyPropertyInfo = GLib.Uri.Uri
    type AttrLabel MessageFirstPartyPropertyInfo = "first-party"
    type AttrOrigin MessageFirstPartyPropertyInfo = Message
    attrGet = getMessageFirstParty
    attrSet = setMessageFirstParty
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageFirstParty
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.firstParty"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:firstParty"
        })
#endif

-- VVV Prop "flags"
   -- Type: TInterface (Name {namespace = "Soup", name = "MessageFlags"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@flags@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #flags
-- @
getMessageFlags :: (MonadIO m, IsMessage o) => o -> m [Soup.Flags.MessageFlags]
getMessageFlags :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m [MessageFlags]
getMessageFlags o
obj = IO [MessageFlags] -> m [MessageFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [MessageFlags] -> m [MessageFlags])
-> IO [MessageFlags] -> m [MessageFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [MessageFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"flags"

-- | Set the value of the “@flags@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageFlags :: (MonadIO m, IsMessage o) => o -> [Soup.Flags.MessageFlags] -> m ()
setMessageFlags :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> [MessageFlags] -> m ()
setMessageFlags o
obj [MessageFlags]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> [MessageFlags] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"flags" [MessageFlags]
val

-- | Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageFlags :: (IsMessage o, MIO.MonadIO m) => [Soup.Flags.MessageFlags] -> m (GValueConstruct o)
constructMessageFlags :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
[MessageFlags] -> m (GValueConstruct o)
constructMessageFlags [MessageFlags]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [MessageFlags] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"flags" [MessageFlags]
val

#if defined(ENABLE_OVERLOADING)
data MessageFlagsPropertyInfo
instance AttrInfo MessageFlagsPropertyInfo where
    type AttrAllowedOps MessageFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageFlagsPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageFlagsPropertyInfo = (~) [Soup.Flags.MessageFlags]
    type AttrTransferTypeConstraint MessageFlagsPropertyInfo = (~) [Soup.Flags.MessageFlags]
    type AttrTransferType MessageFlagsPropertyInfo = [Soup.Flags.MessageFlags]
    type AttrGetType MessageFlagsPropertyInfo = [Soup.Flags.MessageFlags]
    type AttrLabel MessageFlagsPropertyInfo = "flags"
    type AttrOrigin MessageFlagsPropertyInfo = Message
    attrGet = getMessageFlags
    attrSet = setMessageFlags
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageFlags
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.flags"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:flags"
        })
#endif

-- VVV Prop "http-version"
   -- Type: TInterface (Name {namespace = "Soup", name = "HTTPVersion"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@http-version@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #httpVersion
-- @
getMessageHttpVersion :: (MonadIO m, IsMessage o) => o -> m Soup.Enums.HTTPVersion
getMessageHttpVersion :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m HTTPVersion
getMessageHttpVersion o
obj = IO HTTPVersion -> m HTTPVersion
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO HTTPVersion -> m HTTPVersion)
-> IO HTTPVersion -> m HTTPVersion
forall a b. (a -> b) -> a -> b
$ o -> String -> IO HTTPVersion
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"http-version"

#if defined(ENABLE_OVERLOADING)
data MessageHttpVersionPropertyInfo
instance AttrInfo MessageHttpVersionPropertyInfo where
    type AttrAllowedOps MessageHttpVersionPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint MessageHttpVersionPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageHttpVersionPropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageHttpVersionPropertyInfo = (~) ()
    type AttrTransferType MessageHttpVersionPropertyInfo = ()
    type AttrGetType MessageHttpVersionPropertyInfo = Soup.Enums.HTTPVersion
    type AttrLabel MessageHttpVersionPropertyInfo = "http-version"
    type AttrOrigin MessageHttpVersionPropertyInfo = Message
    attrGet = getMessageHttpVersion
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.httpVersion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:httpVersion"
        })
#endif

-- VVV Prop "is-options-ping"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@is-options-ping@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #isOptionsPing
-- @
getMessageIsOptionsPing :: (MonadIO m, IsMessage o) => o -> m Bool
getMessageIsOptionsPing :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Bool
getMessageIsOptionsPing o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"is-options-ping"

-- | Set the value of the “@is-options-ping@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #isOptionsPing 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageIsOptionsPing :: (MonadIO m, IsMessage o) => o -> Bool -> m ()
setMessageIsOptionsPing :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> Bool -> m ()
setMessageIsOptionsPing o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"is-options-ping" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@is-options-ping@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageIsOptionsPing :: (IsMessage o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructMessageIsOptionsPing :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructMessageIsOptionsPing Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"is-options-ping" Bool
val

#if defined(ENABLE_OVERLOADING)
data MessageIsOptionsPingPropertyInfo
instance AttrInfo MessageIsOptionsPingPropertyInfo where
    type AttrAllowedOps MessageIsOptionsPingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageIsOptionsPingPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageIsOptionsPingPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint MessageIsOptionsPingPropertyInfo = (~) Bool
    type AttrTransferType MessageIsOptionsPingPropertyInfo = Bool
    type AttrGetType MessageIsOptionsPingPropertyInfo = Bool
    type AttrLabel MessageIsOptionsPingPropertyInfo = "is-options-ping"
    type AttrOrigin MessageIsOptionsPingPropertyInfo = Message
    attrGet = getMessageIsOptionsPing
    attrSet = setMessageIsOptionsPing
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageIsOptionsPing
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.isOptionsPing"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:isOptionsPing"
        })
#endif

-- VVV Prop "is-top-level-navigation"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@is-top-level-navigation@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #isTopLevelNavigation
-- @
getMessageIsTopLevelNavigation :: (MonadIO m, IsMessage o) => o -> m Bool
getMessageIsTopLevelNavigation :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Bool
getMessageIsTopLevelNavigation o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"is-top-level-navigation"

-- | Set the value of the “@is-top-level-navigation@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #isTopLevelNavigation 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageIsTopLevelNavigation :: (MonadIO m, IsMessage o) => o -> Bool -> m ()
setMessageIsTopLevelNavigation :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> Bool -> m ()
setMessageIsTopLevelNavigation o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"is-top-level-navigation" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@is-top-level-navigation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageIsTopLevelNavigation :: (IsMessage o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructMessageIsTopLevelNavigation :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructMessageIsTopLevelNavigation Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"is-top-level-navigation" Bool
val

#if defined(ENABLE_OVERLOADING)
data MessageIsTopLevelNavigationPropertyInfo
instance AttrInfo MessageIsTopLevelNavigationPropertyInfo where
    type AttrAllowedOps MessageIsTopLevelNavigationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageIsTopLevelNavigationPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageIsTopLevelNavigationPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint MessageIsTopLevelNavigationPropertyInfo = (~) Bool
    type AttrTransferType MessageIsTopLevelNavigationPropertyInfo = Bool
    type AttrGetType MessageIsTopLevelNavigationPropertyInfo = Bool
    type AttrLabel MessageIsTopLevelNavigationPropertyInfo = "is-top-level-navigation"
    type AttrOrigin MessageIsTopLevelNavigationPropertyInfo = Message
    attrGet = getMessageIsTopLevelNavigation
    attrSet = setMessageIsTopLevelNavigation
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageIsTopLevelNavigation
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.isTopLevelNavigation"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:isTopLevelNavigation"
        })
#endif

-- VVV Prop "method"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@method@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #method
-- @
getMessageMethod :: (MonadIO m, IsMessage o) => o -> m T.Text
getMessageMethod :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Text
getMessageMethod o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getMessageMethod" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"method"

-- | Set the value of the “@method@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #method 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageMethod :: (MonadIO m, IsMessage o) => o -> T.Text -> m ()
setMessageMethod :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> Text -> m ()
setMessageMethod o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"method" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@method@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageMethod :: (IsMessage o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructMessageMethod :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructMessageMethod Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"method" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data MessageMethodPropertyInfo
instance AttrInfo MessageMethodPropertyInfo where
    type AttrAllowedOps MessageMethodPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageMethodPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageMethodPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint MessageMethodPropertyInfo = (~) T.Text
    type AttrTransferType MessageMethodPropertyInfo = T.Text
    type AttrGetType MessageMethodPropertyInfo = T.Text
    type AttrLabel MessageMethodPropertyInfo = "method"
    type AttrOrigin MessageMethodPropertyInfo = Message
    attrGet = getMessageMethod
    attrSet = setMessageMethod
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageMethod
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.method"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:method"
        })
#endif

-- VVV Prop "priority"
   -- Type: TInterface (Name {namespace = "Soup", name = "MessagePriority"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@priority@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #priority
-- @
getMessagePriority :: (MonadIO m, IsMessage o) => o -> m Soup.Enums.MessagePriority
getMessagePriority :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m MessagePriority
getMessagePriority o
obj = IO MessagePriority -> m MessagePriority
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO MessagePriority -> m MessagePriority)
-> IO MessagePriority -> m MessagePriority
forall a b. (a -> b) -> a -> b
$ o -> String -> IO MessagePriority
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"priority"

-- | Set the value of the “@priority@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #priority 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessagePriority :: (MonadIO m, IsMessage o) => o -> Soup.Enums.MessagePriority -> m ()
setMessagePriority :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> MessagePriority -> m ()
setMessagePriority o
obj MessagePriority
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> MessagePriority -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"priority" MessagePriority
val

-- | Construct a `GValueConstruct` with valid value for the “@priority@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessagePriority :: (IsMessage o, MIO.MonadIO m) => Soup.Enums.MessagePriority -> m (GValueConstruct o)
constructMessagePriority :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
MessagePriority -> m (GValueConstruct o)
constructMessagePriority MessagePriority
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> MessagePriority -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"priority" MessagePriority
val

#if defined(ENABLE_OVERLOADING)
data MessagePriorityPropertyInfo
instance AttrInfo MessagePriorityPropertyInfo where
    type AttrAllowedOps MessagePriorityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessagePriorityPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessagePriorityPropertyInfo = (~) Soup.Enums.MessagePriority
    type AttrTransferTypeConstraint MessagePriorityPropertyInfo = (~) Soup.Enums.MessagePriority
    type AttrTransferType MessagePriorityPropertyInfo = Soup.Enums.MessagePriority
    type AttrGetType MessagePriorityPropertyInfo = Soup.Enums.MessagePriority
    type AttrLabel MessagePriorityPropertyInfo = "priority"
    type AttrOrigin MessagePriorityPropertyInfo = Message
    attrGet = getMessagePriority
    attrSet = setMessagePriority
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessagePriority
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.priority"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:priority"
        })
#endif

-- VVV Prop "reason-phrase"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@reason-phrase@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #reasonPhrase
-- @
getMessageReasonPhrase :: (MonadIO m, IsMessage o) => o -> m (Maybe T.Text)
getMessageReasonPhrase :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m (Maybe Text)
getMessageReasonPhrase o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"reason-phrase"

#if defined(ENABLE_OVERLOADING)
data MessageReasonPhrasePropertyInfo
instance AttrInfo MessageReasonPhrasePropertyInfo where
    type AttrAllowedOps MessageReasonPhrasePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageReasonPhrasePropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageReasonPhrasePropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageReasonPhrasePropertyInfo = (~) ()
    type AttrTransferType MessageReasonPhrasePropertyInfo = ()
    type AttrGetType MessageReasonPhrasePropertyInfo = (Maybe T.Text)
    type AttrLabel MessageReasonPhrasePropertyInfo = "reason-phrase"
    type AttrOrigin MessageReasonPhrasePropertyInfo = Message
    attrGet = getMessageReasonPhrase
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.reasonPhrase"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:reasonPhrase"
        })
#endif

-- VVV Prop "remote-address"
   -- Type: TInterface (Name {namespace = "Gio", name = "SocketAddress"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@remote-address@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #remoteAddress
-- @
getMessageRemoteAddress :: (MonadIO m, IsMessage o) => o -> m (Maybe Gio.SocketAddress.SocketAddress)
getMessageRemoteAddress :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m (Maybe SocketAddress)
getMessageRemoteAddress o
obj = IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe SocketAddress) -> m (Maybe SocketAddress))
-> IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr SocketAddress -> SocketAddress)
-> IO (Maybe SocketAddress)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"remote-address" ManagedPtr SocketAddress -> SocketAddress
Gio.SocketAddress.SocketAddress

#if defined(ENABLE_OVERLOADING)
data MessageRemoteAddressPropertyInfo
instance AttrInfo MessageRemoteAddressPropertyInfo where
    type AttrAllowedOps MessageRemoteAddressPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageRemoteAddressPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageRemoteAddressPropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageRemoteAddressPropertyInfo = (~) ()
    type AttrTransferType MessageRemoteAddressPropertyInfo = ()
    type AttrGetType MessageRemoteAddressPropertyInfo = (Maybe Gio.SocketAddress.SocketAddress)
    type AttrLabel MessageRemoteAddressPropertyInfo = "remote-address"
    type AttrOrigin MessageRemoteAddressPropertyInfo = Message
    attrGet = getMessageRemoteAddress
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.remoteAddress"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:remoteAddress"
        })
#endif

-- VVV Prop "request-headers"
   -- Type: TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@request-headers@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #requestHeaders
-- @
getMessageRequestHeaders :: (MonadIO m, IsMessage o) => o -> m Soup.MessageHeaders.MessageHeaders
getMessageRequestHeaders :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m MessageHeaders
getMessageRequestHeaders o
obj = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe MessageHeaders) -> IO MessageHeaders
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getMessageRequestHeaders" (IO (Maybe MessageHeaders) -> IO MessageHeaders)
-> IO (Maybe MessageHeaders) -> IO MessageHeaders
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr MessageHeaders -> MessageHeaders)
-> IO (Maybe MessageHeaders)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"request-headers" ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders

#if defined(ENABLE_OVERLOADING)
data MessageRequestHeadersPropertyInfo
instance AttrInfo MessageRequestHeadersPropertyInfo where
    type AttrAllowedOps MessageRequestHeadersPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageRequestHeadersPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageRequestHeadersPropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageRequestHeadersPropertyInfo = (~) ()
    type AttrTransferType MessageRequestHeadersPropertyInfo = ()
    type AttrGetType MessageRequestHeadersPropertyInfo = Soup.MessageHeaders.MessageHeaders
    type AttrLabel MessageRequestHeadersPropertyInfo = "request-headers"
    type AttrOrigin MessageRequestHeadersPropertyInfo = Message
    attrGet = getMessageRequestHeaders
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.requestHeaders"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:requestHeaders"
        })
#endif

-- VVV Prop "response-headers"
   -- Type: TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@response-headers@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #responseHeaders
-- @
getMessageResponseHeaders :: (MonadIO m, IsMessage o) => o -> m Soup.MessageHeaders.MessageHeaders
getMessageResponseHeaders :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m MessageHeaders
getMessageResponseHeaders o
obj = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe MessageHeaders) -> IO MessageHeaders
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getMessageResponseHeaders" (IO (Maybe MessageHeaders) -> IO MessageHeaders)
-> IO (Maybe MessageHeaders) -> IO MessageHeaders
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr MessageHeaders -> MessageHeaders)
-> IO (Maybe MessageHeaders)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"response-headers" ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders

#if defined(ENABLE_OVERLOADING)
data MessageResponseHeadersPropertyInfo
instance AttrInfo MessageResponseHeadersPropertyInfo where
    type AttrAllowedOps MessageResponseHeadersPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageResponseHeadersPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageResponseHeadersPropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageResponseHeadersPropertyInfo = (~) ()
    type AttrTransferType MessageResponseHeadersPropertyInfo = ()
    type AttrGetType MessageResponseHeadersPropertyInfo = Soup.MessageHeaders.MessageHeaders
    type AttrLabel MessageResponseHeadersPropertyInfo = "response-headers"
    type AttrOrigin MessageResponseHeadersPropertyInfo = Message
    attrGet = getMessageResponseHeaders
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.responseHeaders"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:responseHeaders"
        })
#endif

-- VVV Prop "site-for-cookies"
   -- Type: TInterface (Name {namespace = "GLib", name = "Uri"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

-- | Get the value of the “@site-for-cookies@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #siteForCookies
-- @
getMessageSiteForCookies :: (MonadIO m, IsMessage o) => o -> m GLib.Uri.Uri
getMessageSiteForCookies :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Uri
getMessageSiteForCookies o
obj = IO Uri -> m Uri
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Uri -> m Uri) -> IO Uri -> m Uri
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Uri) -> IO Uri
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getMessageSiteForCookies" (IO (Maybe Uri) -> IO Uri) -> IO (Maybe Uri) -> IO Uri
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Uri -> Uri) -> IO (Maybe Uri)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"site-for-cookies" ManagedPtr Uri -> Uri
GLib.Uri.Uri

-- | Set the value of the “@site-for-cookies@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #siteForCookies 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageSiteForCookies :: (MonadIO m, IsMessage o) => o -> GLib.Uri.Uri -> m ()
setMessageSiteForCookies :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> Uri -> m ()
setMessageSiteForCookies o
obj Uri
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Uri -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"site-for-cookies" (Uri -> Maybe Uri
forall a. a -> Maybe a
Just Uri
val)

-- | Construct a `GValueConstruct` with valid value for the “@site-for-cookies@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageSiteForCookies :: (IsMessage o, MIO.MonadIO m) => GLib.Uri.Uri -> m (GValueConstruct o)
constructMessageSiteForCookies :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
Uri -> m (GValueConstruct o)
constructMessageSiteForCookies Uri
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Uri -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"site-for-cookies" (Uri -> Maybe Uri
forall a. a -> Maybe a
P.Just Uri
val)

-- | Set the value of the “@site-for-cookies@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #siteForCookies
-- @
clearMessageSiteForCookies :: (MonadIO m, IsMessage o) => o -> m ()
clearMessageSiteForCookies :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m ()
clearMessageSiteForCookies o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Uri -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"site-for-cookies" (Maybe Uri
forall a. Maybe a
Nothing :: Maybe GLib.Uri.Uri)

#if defined(ENABLE_OVERLOADING)
data MessageSiteForCookiesPropertyInfo
instance AttrInfo MessageSiteForCookiesPropertyInfo where
    type AttrAllowedOps MessageSiteForCookiesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageSiteForCookiesPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageSiteForCookiesPropertyInfo = (~) GLib.Uri.Uri
    type AttrTransferTypeConstraint MessageSiteForCookiesPropertyInfo = (~) GLib.Uri.Uri
    type AttrTransferType MessageSiteForCookiesPropertyInfo = GLib.Uri.Uri
    type AttrGetType MessageSiteForCookiesPropertyInfo = GLib.Uri.Uri
    type AttrLabel MessageSiteForCookiesPropertyInfo = "site-for-cookies"
    type AttrOrigin MessageSiteForCookiesPropertyInfo = Message
    attrGet = getMessageSiteForCookies
    attrSet = setMessageSiteForCookies
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageSiteForCookies
    attrClear = clearMessageSiteForCookies
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.siteForCookies"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:siteForCookies"
        })
#endif

-- VVV Prop "status-code"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@status-code@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #statusCode
-- @
getMessageStatusCode :: (MonadIO m, IsMessage o) => o -> m Word32
getMessageStatusCode :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Word32
getMessageStatusCode o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"status-code"

#if defined(ENABLE_OVERLOADING)
data MessageStatusCodePropertyInfo
instance AttrInfo MessageStatusCodePropertyInfo where
    type AttrAllowedOps MessageStatusCodePropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint MessageStatusCodePropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageStatusCodePropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageStatusCodePropertyInfo = (~) ()
    type AttrTransferType MessageStatusCodePropertyInfo = ()
    type AttrGetType MessageStatusCodePropertyInfo = Word32
    type AttrLabel MessageStatusCodePropertyInfo = "status-code"
    type AttrOrigin MessageStatusCodePropertyInfo = Message
    attrGet = getMessageStatusCode
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.statusCode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:statusCode"
        })
#endif

-- VVV Prop "tls-ciphersuite-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@tls-ciphersuite-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #tlsCiphersuiteName
-- @
getMessageTlsCiphersuiteName :: (MonadIO m, IsMessage o) => o -> m T.Text
getMessageTlsCiphersuiteName :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Text
getMessageTlsCiphersuiteName o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getMessageTlsCiphersuiteName" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"tls-ciphersuite-name"

#if defined(ENABLE_OVERLOADING)
data MessageTlsCiphersuiteNamePropertyInfo
instance AttrInfo MessageTlsCiphersuiteNamePropertyInfo where
    type AttrAllowedOps MessageTlsCiphersuiteNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageTlsCiphersuiteNamePropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageTlsCiphersuiteNamePropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageTlsCiphersuiteNamePropertyInfo = (~) ()
    type AttrTransferType MessageTlsCiphersuiteNamePropertyInfo = ()
    type AttrGetType MessageTlsCiphersuiteNamePropertyInfo = T.Text
    type AttrLabel MessageTlsCiphersuiteNamePropertyInfo = "tls-ciphersuite-name"
    type AttrOrigin MessageTlsCiphersuiteNamePropertyInfo = Message
    attrGet = getMessageTlsCiphersuiteName
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.tlsCiphersuiteName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:tlsCiphersuiteName"
        })
#endif

-- VVV Prop "tls-peer-certificate"
   -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@tls-peer-certificate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #tlsPeerCertificate
-- @
getMessageTlsPeerCertificate :: (MonadIO m, IsMessage o) => o -> m (Maybe Gio.TlsCertificate.TlsCertificate)
getMessageTlsPeerCertificate :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m (Maybe TlsCertificate)
getMessageTlsPeerCertificate o
obj = IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate))
-> IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr TlsCertificate -> TlsCertificate)
-> IO (Maybe TlsCertificate)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"tls-peer-certificate" ManagedPtr TlsCertificate -> TlsCertificate
Gio.TlsCertificate.TlsCertificate

#if defined(ENABLE_OVERLOADING)
data MessageTlsPeerCertificatePropertyInfo
instance AttrInfo MessageTlsPeerCertificatePropertyInfo where
    type AttrAllowedOps MessageTlsPeerCertificatePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageTlsPeerCertificatePropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageTlsPeerCertificatePropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageTlsPeerCertificatePropertyInfo = (~) ()
    type AttrTransferType MessageTlsPeerCertificatePropertyInfo = ()
    type AttrGetType MessageTlsPeerCertificatePropertyInfo = (Maybe Gio.TlsCertificate.TlsCertificate)
    type AttrLabel MessageTlsPeerCertificatePropertyInfo = "tls-peer-certificate"
    type AttrOrigin MessageTlsPeerCertificatePropertyInfo = Message
    attrGet = getMessageTlsPeerCertificate
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.tlsPeerCertificate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:tlsPeerCertificate"
        })
#endif

-- VVV Prop "tls-peer-certificate-errors"
   -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@tls-peer-certificate-errors@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #tlsPeerCertificateErrors
-- @
getMessageTlsPeerCertificateErrors :: (MonadIO m, IsMessage o) => o -> m [Gio.Flags.TlsCertificateFlags]
getMessageTlsPeerCertificateErrors :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m [TlsCertificateFlags]
getMessageTlsPeerCertificateErrors o
obj = IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [TlsCertificateFlags] -> m [TlsCertificateFlags])
-> IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [TlsCertificateFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"tls-peer-certificate-errors"

#if defined(ENABLE_OVERLOADING)
data MessageTlsPeerCertificateErrorsPropertyInfo
instance AttrInfo MessageTlsPeerCertificateErrorsPropertyInfo where
    type AttrAllowedOps MessageTlsPeerCertificateErrorsPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint MessageTlsPeerCertificateErrorsPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageTlsPeerCertificateErrorsPropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageTlsPeerCertificateErrorsPropertyInfo = (~) ()
    type AttrTransferType MessageTlsPeerCertificateErrorsPropertyInfo = ()
    type AttrGetType MessageTlsPeerCertificateErrorsPropertyInfo = [Gio.Flags.TlsCertificateFlags]
    type AttrLabel MessageTlsPeerCertificateErrorsPropertyInfo = "tls-peer-certificate-errors"
    type AttrOrigin MessageTlsPeerCertificateErrorsPropertyInfo = Message
    attrGet = getMessageTlsPeerCertificateErrors
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.tlsPeerCertificateErrors"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:tlsPeerCertificateErrors"
        })
#endif

-- VVV Prop "tls-protocol-version"
   -- Type: TInterface (Name {namespace = "Gio", name = "TlsProtocolVersion"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@tls-protocol-version@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #tlsProtocolVersion
-- @
getMessageTlsProtocolVersion :: (MonadIO m, IsMessage o) => o -> m Gio.Enums.TlsProtocolVersion
getMessageTlsProtocolVersion :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> m TlsProtocolVersion
getMessageTlsProtocolVersion o
obj = IO TlsProtocolVersion -> m TlsProtocolVersion
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TlsProtocolVersion -> m TlsProtocolVersion)
-> IO TlsProtocolVersion -> m TlsProtocolVersion
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TlsProtocolVersion
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"tls-protocol-version"

#if defined(ENABLE_OVERLOADING)
data MessageTlsProtocolVersionPropertyInfo
instance AttrInfo MessageTlsProtocolVersionPropertyInfo where
    type AttrAllowedOps MessageTlsProtocolVersionPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint MessageTlsProtocolVersionPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageTlsProtocolVersionPropertyInfo = (~) ()
    type AttrTransferTypeConstraint MessageTlsProtocolVersionPropertyInfo = (~) ()
    type AttrTransferType MessageTlsProtocolVersionPropertyInfo = ()
    type AttrGetType MessageTlsProtocolVersionPropertyInfo = Gio.Enums.TlsProtocolVersion
    type AttrLabel MessageTlsProtocolVersionPropertyInfo = "tls-protocol-version"
    type AttrOrigin MessageTlsProtocolVersionPropertyInfo = Message
    attrGet = getMessageTlsProtocolVersion
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.tlsProtocolVersion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:tlsProtocolVersion"
        })
#endif

-- VVV Prop "uri"
   -- Type: TInterface (Name {namespace = "GLib", name = "Uri"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' message #uri
-- @
getMessageUri :: (MonadIO m, IsMessage o) => o -> m GLib.Uri.Uri
getMessageUri :: forall (m :: * -> *) o. (MonadIO m, IsMessage o) => o -> m Uri
getMessageUri o
obj = IO Uri -> m Uri
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Uri -> m Uri) -> IO Uri -> m Uri
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Uri) -> IO Uri
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getMessageUri" (IO (Maybe Uri) -> IO Uri) -> IO (Maybe Uri) -> IO Uri
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Uri -> Uri) -> IO (Maybe Uri)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"uri" ManagedPtr Uri -> Uri
GLib.Uri.Uri

-- | Set the value of the “@uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' message [ #uri 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageUri :: (MonadIO m, IsMessage o) => o -> GLib.Uri.Uri -> m ()
setMessageUri :: forall (m :: * -> *) o.
(MonadIO m, IsMessage o) =>
o -> Uri -> m ()
setMessageUri o
obj Uri
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Uri -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"uri" (Uri -> Maybe Uri
forall a. a -> Maybe a
Just Uri
val)

-- | Construct a `GValueConstruct` with valid value for the “@uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageUri :: (IsMessage o, MIO.MonadIO m) => GLib.Uri.Uri -> m (GValueConstruct o)
constructMessageUri :: forall o (m :: * -> *).
(IsMessage o, MonadIO m) =>
Uri -> m (GValueConstruct o)
constructMessageUri Uri
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Uri -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"uri" (Uri -> Maybe Uri
forall a. a -> Maybe a
P.Just Uri
val)

#if defined(ENABLE_OVERLOADING)
data MessageUriPropertyInfo
instance AttrInfo MessageUriPropertyInfo where
    type AttrAllowedOps MessageUriPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageUriPropertyInfo = IsMessage
    type AttrSetTypeConstraint MessageUriPropertyInfo = (~) GLib.Uri.Uri
    type AttrTransferTypeConstraint MessageUriPropertyInfo = (~) GLib.Uri.Uri
    type AttrTransferType MessageUriPropertyInfo = GLib.Uri.Uri
    type AttrGetType MessageUriPropertyInfo = GLib.Uri.Uri
    type AttrLabel MessageUriPropertyInfo = "uri"
    type AttrOrigin MessageUriPropertyInfo = Message
    attrGet = getMessageUri
    attrSet = setMessageUri
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageUri
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.uri"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#g:attr:uri"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Message
type instance O.AttributeList Message = MessageAttributeList
type MessageAttributeList = ('[ '("firstParty", MessageFirstPartyPropertyInfo), '("flags", MessageFlagsPropertyInfo), '("httpVersion", MessageHttpVersionPropertyInfo), '("isOptionsPing", MessageIsOptionsPingPropertyInfo), '("isTopLevelNavigation", MessageIsTopLevelNavigationPropertyInfo), '("method", MessageMethodPropertyInfo), '("priority", MessagePriorityPropertyInfo), '("reasonPhrase", MessageReasonPhrasePropertyInfo), '("remoteAddress", MessageRemoteAddressPropertyInfo), '("requestHeaders", MessageRequestHeadersPropertyInfo), '("responseHeaders", MessageResponseHeadersPropertyInfo), '("siteForCookies", MessageSiteForCookiesPropertyInfo), '("statusCode", MessageStatusCodePropertyInfo), '("tlsCiphersuiteName", MessageTlsCiphersuiteNamePropertyInfo), '("tlsPeerCertificate", MessageTlsPeerCertificatePropertyInfo), '("tlsPeerCertificateErrors", MessageTlsPeerCertificateErrorsPropertyInfo), '("tlsProtocolVersion", MessageTlsProtocolVersionPropertyInfo), '("uri", MessageUriPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
messageFirstParty :: AttrLabelProxy "firstParty"
messageFirstParty = AttrLabelProxy

messageFlags :: AttrLabelProxy "flags"
messageFlags = AttrLabelProxy

messageHttpVersion :: AttrLabelProxy "httpVersion"
messageHttpVersion = AttrLabelProxy

messageIsOptionsPing :: AttrLabelProxy "isOptionsPing"
messageIsOptionsPing = AttrLabelProxy

messageIsTopLevelNavigation :: AttrLabelProxy "isTopLevelNavigation"
messageIsTopLevelNavigation = AttrLabelProxy

messageMethod :: AttrLabelProxy "method"
messageMethod = AttrLabelProxy

messagePriority :: AttrLabelProxy "priority"
messagePriority = AttrLabelProxy

messageReasonPhrase :: AttrLabelProxy "reasonPhrase"
messageReasonPhrase = AttrLabelProxy

messageRemoteAddress :: AttrLabelProxy "remoteAddress"
messageRemoteAddress = AttrLabelProxy

messageRequestHeaders :: AttrLabelProxy "requestHeaders"
messageRequestHeaders = AttrLabelProxy

messageResponseHeaders :: AttrLabelProxy "responseHeaders"
messageResponseHeaders = AttrLabelProxy

messageSiteForCookies :: AttrLabelProxy "siteForCookies"
messageSiteForCookies = AttrLabelProxy

messageStatusCode :: AttrLabelProxy "statusCode"
messageStatusCode = AttrLabelProxy

messageTlsCiphersuiteName :: AttrLabelProxy "tlsCiphersuiteName"
messageTlsCiphersuiteName = AttrLabelProxy

messageTlsPeerCertificate :: AttrLabelProxy "tlsPeerCertificate"
messageTlsPeerCertificate = AttrLabelProxy

messageTlsPeerCertificateErrors :: AttrLabelProxy "tlsPeerCertificateErrors"
messageTlsPeerCertificateErrors = AttrLabelProxy

messageTlsProtocolVersion :: AttrLabelProxy "tlsProtocolVersion"
messageTlsProtocolVersion = AttrLabelProxy

messageUri :: AttrLabelProxy "uri"
messageUri = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Message = MessageSignalList
type MessageSignalList = ('[ '("acceptCertificate", MessageAcceptCertificateSignalInfo), '("authenticate", MessageAuthenticateSignalInfo), '("contentSniffed", MessageContentSniffedSignalInfo), '("finished", MessageFinishedSignalInfo), '("gotBody", MessageGotBodySignalInfo), '("gotBodyData", MessageGotBodyDataSignalInfo), '("gotHeaders", MessageGotHeadersSignalInfo), '("gotInformational", MessageGotInformationalSignalInfo), '("hstsEnforced", MessageHstsEnforcedSignalInfo), '("networkEvent", MessageNetworkEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("requestCertificate", MessageRequestCertificateSignalInfo), '("requestCertificatePassword", MessageRequestCertificatePasswordSignalInfo), '("restarted", MessageRestartedSignalInfo), '("starting", MessageStartingSignalInfo), '("wroteBody", MessageWroteBodySignalInfo), '("wroteBodyData", MessageWroteBodyDataSignalInfo), '("wroteHeaders", MessageWroteHeadersSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method Message::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "method"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the HTTP method for the created request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri_string"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the destination endpoint (as a string)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Message" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_new" soup_message_new :: 
    CString ->                              -- method : TBasicType TUTF8
    CString ->                              -- uri_string : TBasicType TUTF8
    IO (Ptr Message)

-- | Creates a new empty t'GI.Soup.Objects.Message.Message', which will connect to /@uri@/.
messageNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@method@/: the HTTP method for the created request
    -> T.Text
    -- ^ /@uriString@/: the destination endpoint (as a string)
    -> m (Maybe Message)
    -- ^ __Returns:__ the new t'GI.Soup.Objects.Message.Message' (or 'P.Nothing' if /@uri@/
    --   could not be parsed).
messageNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> m (Maybe Message)
messageNew Text
method Text
uriString = IO (Maybe Message) -> m (Maybe Message)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
    CString
method' <- Text -> IO CString
textToCString Text
method
    CString
uriString' <- Text -> IO CString
textToCString Text
uriString
    Ptr Message
result <- CString -> CString -> IO (Ptr Message)
soup_message_new CString
method' CString
uriString'
    Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
        Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Message) Ptr Message
result'
        Message -> IO Message
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
method'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uriString'
    Maybe Message -> IO (Maybe Message)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method Message::new_from_encoded_form
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "method"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the HTTP method for the created request (GET, POST or PUT)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri_string"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the destination endpoint (as a string)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "encoded_form"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a encoded form" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Message" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_new_from_encoded_form" soup_message_new_from_encoded_form :: 
    CString ->                              -- method : TBasicType TUTF8
    CString ->                              -- uri_string : TBasicType TUTF8
    CString ->                              -- encoded_form : TBasicType TUTF8
    IO (Ptr Message)

-- | Creates a new t'GI.Soup.Objects.Message.Message' and sets it up to send the given /@encodedForm@/
-- to /@uri@/ via /@method@/. If /@method@/ is \"GET\", it will include the form data
-- into /@uri@/\'s query field, and if /@method@/ is \"POST\" or \"PUT\", it will be set as
-- request body.
-- 
-- This function takes the ownership of /@encodedForm@/, that will be released
-- with 'GI.GLib.Functions.free' when no longer in use. See also [func/@formEncode@/],
-- [func/@formEncodeHash@/] and [func/@formEncodeDatalist@/].
messageNewFromEncodedForm ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@method@/: the HTTP method for the created request (GET, POST or PUT)
    -> T.Text
    -- ^ /@uriString@/: the destination endpoint (as a string)
    -> T.Text
    -- ^ /@encodedForm@/: a encoded form
    -> m (Maybe Message)
    -- ^ __Returns:__ the new t'GI.Soup.Objects.Message.Message', or 'P.Nothing' if
    --   /@uriString@/ could not be parsed or /@method@/ is not \"GET, \"POST\" or \"PUT\"
messageNewFromEncodedForm :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> Text -> m (Maybe Message)
messageNewFromEncodedForm Text
method Text
uriString Text
encodedForm = IO (Maybe Message) -> m (Maybe Message)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
    CString
method' <- Text -> IO CString
textToCString Text
method
    CString
uriString' <- Text -> IO CString
textToCString Text
uriString
    CString
encodedForm' <- Text -> IO CString
textToCString Text
encodedForm
    Ptr Message
result <- CString -> CString -> CString -> IO (Ptr Message)
soup_message_new_from_encoded_form CString
method' CString
uriString' CString
encodedForm'
    Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
        Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Message) Ptr Message
result'
        Message -> IO Message
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
method'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uriString'
    Maybe Message -> IO (Maybe Message)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method Message::new_from_multipart
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "uri_string"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the destination endpoint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "multipart"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Multipart" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMultipart" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Message" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_new_from_multipart" soup_message_new_from_multipart :: 
    CString ->                              -- uri_string : TBasicType TUTF8
    Ptr Soup.Multipart.Multipart ->         -- multipart : TInterface (Name {namespace = "Soup", name = "Multipart"})
    IO (Ptr Message)

-- | Creates a new t'GI.Soup.Objects.Message.Message' and sets it up to send /@multipart@/ to
-- /@uriString@/ via POST.
messageNewFromMultipart ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@uriString@/: the destination endpoint
    -> Soup.Multipart.Multipart
    -- ^ /@multipart@/: a t'GI.Soup.Structs.Multipart.Multipart'
    -> m (Maybe Message)
    -- ^ __Returns:__ the new t'GI.Soup.Objects.Message.Message', or 'P.Nothing' if /@uriString@/
    --   could not be parsed
messageNewFromMultipart :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Multipart -> m (Maybe Message)
messageNewFromMultipart Text
uriString Multipart
multipart = IO (Maybe Message) -> m (Maybe Message)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
    CString
uriString' <- Text -> IO CString
textToCString Text
uriString
    Ptr Multipart
multipart' <- Multipart -> IO (Ptr Multipart)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Multipart
multipart
    Ptr Message
result <- CString -> Ptr Multipart -> IO (Ptr Message)
soup_message_new_from_multipart CString
uriString' Ptr Multipart
multipart'
    Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \Ptr Message
result' -> do
        Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Message) Ptr Message
result'
        Message -> IO Message
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
    Multipart -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Multipart
multipart
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uriString'
    Maybe Message -> IO (Maybe Message)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method Message::new_from_uri
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "method"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the HTTP method for the created request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TInterface Name { namespace = "GLib" , name = "Uri" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the destination endpoint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Message" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_new_from_uri" soup_message_new_from_uri :: 
    CString ->                              -- method : TBasicType TUTF8
    Ptr GLib.Uri.Uri ->                     -- uri : TInterface (Name {namespace = "GLib", name = "Uri"})
    IO (Ptr Message)

-- | Creates a new empty t'GI.Soup.Objects.Message.Message', which will connect to /@uri@/.
messageNewFromUri ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@method@/: the HTTP method for the created request
    -> GLib.Uri.Uri
    -- ^ /@uri@/: the destination endpoint
    -> m Message
    -- ^ __Returns:__ the new t'GI.Soup.Objects.Message.Message'
messageNewFromUri :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Uri -> m Message
messageNewFromUri Text
method Uri
uri = IO Message -> m Message
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
    CString
method' <- Text -> IO CString
textToCString Text
method
    Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
    Ptr Message
result <- CString -> Ptr Uri -> IO (Ptr Message)
soup_message_new_from_uri CString
method' Ptr Uri
uri'
    Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewFromUri" Ptr Message
result
    Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Message) Ptr Message
result
    Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
method'
    Message -> IO Message
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Message::new_options_ping
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "base_uri"
--           , argType = TInterface Name { namespace = "GLib" , name = "Uri" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the destination endpoint"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Message" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_new_options_ping" soup_message_new_options_ping :: 
    Ptr GLib.Uri.Uri ->                     -- base_uri : TInterface (Name {namespace = "GLib", name = "Uri"})
    IO (Ptr Message)

-- | Creates a new t'GI.Soup.Objects.Message.Message' to send @OPTIONS *@ to a server. The path of
-- /@baseUri@/ will be ignored.
messageNewOptionsPing ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.Uri.Uri
    -- ^ /@baseUri@/: the destination endpoint
    -> m Message
    -- ^ __Returns:__ the new t'GI.Soup.Objects.Message.Message'
messageNewOptionsPing :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Uri -> m Message
messageNewOptionsPing Uri
baseUri = IO Message -> m Message
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
    Ptr Uri
baseUri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
baseUri
    Ptr Message
result <- Ptr Uri -> IO (Ptr Message)
soup_message_new_options_ping Ptr Uri
baseUri'
    Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageNewOptionsPing" Ptr Message
result
    Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Message) Ptr Message
result
    Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
baseUri
    Message -> IO Message
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Message::add_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a set of #SoupMessageFlags values"
--                 , 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_add_flags" soup_message_add_flags :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Soup", name = "MessageFlags"})
    IO ()

-- | Adds /@flags@/ to the set of /@msg@/\'s flags.
messageAddFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> [Soup.Flags.MessageFlags]
    -- ^ /@flags@/: a set of t'GI.Soup.Flags.MessageFlags' values
    -> m ()
messageAddFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> [MessageFlags] -> m ()
messageAddFlags a
msg [MessageFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let flags' :: CUInt
flags' = [MessageFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageFlags]
flags
    Ptr Message -> CUInt -> IO ()
soup_message_add_flags Ptr Message
msg' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageAddFlagsMethodInfo
instance (signature ~ ([Soup.Flags.MessageFlags] -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageAddFlagsMethodInfo a signature where
    overloadedMethod = messageAddFlags

instance O.OverloadedMethodInfo MessageAddFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageAddFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageAddFlags"
        })


#endif

-- method Message::disable_feature
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "feature_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GType of a #SoupSessionFeature"
--                 , 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_disable_feature" soup_message_disable_feature :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CGType ->                               -- feature_type : TBasicType TGType
    IO ()

-- | Disables the actions of [iface/@sessionFeature@/]s with the
-- given /@featureType@/ (or a subclass of that type) on /@msg@/.
-- 
-- /@msg@/ is processed as though the feature(s) hadn\'t been added to the
-- session. Eg, passing @/SOUP_TYPE_CONTENT_SNIFFER/@ for /@featureType@/
-- will disable Content-Type sniffing on the message.
-- 
-- You must call this before queueing /@msg@/ on a session; calling it on
-- a message that has already been queued is undefined. In particular,
-- you cannot call this on a message that is being requeued after a
-- redirect or authentication.
messageDisableFeature ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> GType
    -- ^ /@featureType@/: the t'GType' of a t'GI.Soup.Interfaces.SessionFeature.SessionFeature'
    -> m ()
messageDisableFeature :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> GType -> m ()
messageDisableFeature a
msg GType
featureType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let featureType' :: CGType
featureType' = GType -> CGType
gtypeToCGType GType
featureType
    Ptr Message -> CGType -> IO ()
soup_message_disable_feature Ptr Message
msg' CGType
featureType'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageDisableFeatureMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageDisableFeatureMethodInfo a signature where
    overloadedMethod = messageDisableFeature

instance O.OverloadedMethodInfo MessageDisableFeatureMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageDisableFeature",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageDisableFeature"
        })


#endif

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

foreign import ccall "soup_message_get_connection_id" soup_message_get_connection_id :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO Word64

-- | Returns the unique idenfier for the last connection used.
-- 
-- This may be 0 if it was a cached resource or it has not gotten
-- a connection yet.
messageGetConnectionId ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m Word64
    -- ^ __Returns:__ An id or 0 if no connection.
messageGetConnectionId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m CGType
messageGetConnectionId a
msg = IO CGType -> m CGType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CGType -> m CGType) -> IO CGType -> m CGType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CGType
result <- Ptr Message -> IO CGType
soup_message_get_connection_id Ptr Message
msg'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    CGType -> IO CGType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CGType
result

#if defined(ENABLE_OVERLOADING)
data MessageGetConnectionIdMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetConnectionIdMethodInfo a signature where
    overloadedMethod = messageGetConnectionId

instance O.OverloadedMethodInfo MessageGetConnectionIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetConnectionId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetConnectionId"
        })


#endif

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

foreign import ccall "soup_message_get_first_party" soup_message_get_first_party :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr GLib.Uri.Uri)

-- | Gets /@msg@/\'s first-party [struct/@gLib@/.Uri].
messageGetFirstParty ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m GLib.Uri.Uri
    -- ^ __Returns:__ the /@msg@/\'s first party t'GI.GLib.Structs.Uri.Uri'
messageGetFirstParty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Uri
messageGetFirstParty a
msg = IO Uri -> m Uri
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Uri -> m Uri) -> IO Uri -> m Uri
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Uri
result <- Ptr Message -> IO (Ptr Uri)
soup_message_get_first_party Ptr Message
msg'
    Text -> Ptr Uri -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageGetFirstParty" Ptr Uri
result
    Uri
result' <- ((ManagedPtr Uri -> Uri) -> Ptr Uri -> IO Uri
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Uri -> Uri
GLib.Uri.Uri) Ptr Uri
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Uri -> IO Uri
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetFirstPartyMethodInfo
instance (signature ~ (m GLib.Uri.Uri), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetFirstPartyMethodInfo a signature where
    overloadedMethod = messageGetFirstParty

instance O.OverloadedMethodInfo MessageGetFirstPartyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetFirstParty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetFirstParty"
        })


#endif

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

foreign import ccall "soup_message_get_flags" soup_message_get_flags :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CUInt

-- | Gets the flags on /@msg@/.
messageGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m [Soup.Flags.MessageFlags]
    -- ^ __Returns:__ the flags
messageGetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m [MessageFlags]
messageGetFlags a
msg = IO [MessageFlags] -> m [MessageFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [MessageFlags] -> m [MessageFlags])
-> IO [MessageFlags] -> m [MessageFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr Message -> IO CUInt
soup_message_get_flags Ptr Message
msg'
    let result' :: [MessageFlags]
result' = CUInt -> [MessageFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    [MessageFlags] -> IO [MessageFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [MessageFlags]
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetFlagsMethodInfo
instance (signature ~ (m [Soup.Flags.MessageFlags]), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetFlagsMethodInfo a signature where
    overloadedMethod = messageGetFlags

instance O.OverloadedMethodInfo MessageGetFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetFlags"
        })


#endif

-- method Message::get_force_http1
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #SoupMessage" , 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_get_force_http1" soup_message_get_force_http1 :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CInt

-- | Returns whether HTTP\/1 version is currently demanded for the /@msg@/ send.
-- 
-- /Since: 3.4/
messageGetForceHttp1 ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m Bool
    -- ^ __Returns:__ 'P.True', when HTTP\/1 is demanded, 'P.False' otherwise.
messageGetForceHttp1 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Bool
messageGetForceHttp1 a
msg = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CInt
result <- Ptr Message -> IO CInt
soup_message_get_force_http1 Ptr Message
msg'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetForceHttp1MethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetForceHttp1MethodInfo a signature where
    overloadedMethod = messageGetForceHttp1

instance O.OverloadedMethodInfo MessageGetForceHttp1MethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetForceHttp1",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetForceHttp1"
        })


#endif

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

foreign import ccall "soup_message_get_http_version" soup_message_get_http_version :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CUInt

-- | Gets the HTTP version of /@msg@/.
-- 
-- This is the minimum of the version from the request and the version from the
-- response.
messageGetHttpVersion ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m Soup.Enums.HTTPVersion
    -- ^ __Returns:__ the HTTP version
messageGetHttpVersion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m HTTPVersion
messageGetHttpVersion a
msg = IO HTTPVersion -> m HTTPVersion
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HTTPVersion -> m HTTPVersion)
-> IO HTTPVersion -> m HTTPVersion
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr Message -> IO CUInt
soup_message_get_http_version Ptr Message
msg'
    let result' :: HTTPVersion
result' = (Int -> HTTPVersion
forall a. Enum a => Int -> a
toEnum (Int -> HTTPVersion) -> (CUInt -> Int) -> CUInt -> HTTPVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    HTTPVersion -> IO HTTPVersion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return HTTPVersion
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetHttpVersionMethodInfo
instance (signature ~ (m Soup.Enums.HTTPVersion), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetHttpVersionMethodInfo a signature where
    overloadedMethod = messageGetHttpVersion

instance O.OverloadedMethodInfo MessageGetHttpVersionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetHttpVersion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetHttpVersion"
        })


#endif

-- method Message::get_is_options_ping
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , 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_get_is_options_ping" soup_message_get_is_options_ping :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CInt

-- | Gets whether /@msg@/ is intended to be used to send @OPTIONS *@ to a server.
messageGetIsOptionsPing ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the message is options ping, or 'P.False' otherwise
messageGetIsOptionsPing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Bool
messageGetIsOptionsPing a
msg = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CInt
result <- Ptr Message -> IO CInt
soup_message_get_is_options_ping Ptr Message
msg'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetIsOptionsPingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetIsOptionsPingMethodInfo a signature where
    overloadedMethod = messageGetIsOptionsPing

instance O.OverloadedMethodInfo MessageGetIsOptionsPingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetIsOptionsPing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetIsOptionsPing"
        })


#endif

-- method Message::get_is_top_level_navigation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , 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_get_is_top_level_navigation" soup_message_get_is_top_level_navigation :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CInt

-- | Returns if this message is set as a top level navigation.
-- 
-- Used for same-site policy checks.
messageGetIsTopLevelNavigation ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m Bool
    -- ^ __Returns:__ Whether the current request is a top-level navitation
messageGetIsTopLevelNavigation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Bool
messageGetIsTopLevelNavigation a
msg = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CInt
result <- Ptr Message -> IO CInt
soup_message_get_is_top_level_navigation Ptr Message
msg'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetIsTopLevelNavigationMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetIsTopLevelNavigationMethodInfo a signature where
    overloadedMethod = messageGetIsTopLevelNavigation

instance O.OverloadedMethodInfo MessageGetIsTopLevelNavigationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetIsTopLevelNavigation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetIsTopLevelNavigation"
        })


#endif

-- method Message::get_method
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #SoupMessage" , 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_get_method" soup_message_get_method :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CString

-- | Returns the method of this message.
messageGetMethod ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m T.Text
    -- ^ __Returns:__ A method such as @/SOUP_METHOD_GET/@
messageGetMethod :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Text
messageGetMethod a
msg = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
result <- Ptr Message -> IO CString
soup_message_get_method Ptr Message
msg'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageGetMethod" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetMethodMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetMethodMethodInfo a signature where
    overloadedMethod = messageGetMethod

instance O.OverloadedMethodInfo MessageGetMethodMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetMethod",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetMethod"
        })


#endif

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

foreign import ccall "soup_message_get_metrics" soup_message_get_metrics :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr Soup.MessageMetrics.MessageMetrics)

-- | Get the [struct/@messageMetrics@/] of /@msg@/.
-- 
-- If the flag 'GI.Soup.Flags.MessageFlagsCollectMetrics' is not enabled for /@msg@/ this will
-- return 'P.Nothing'.
messageGetMetrics ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m (Maybe Soup.MessageMetrics.MessageMetrics)
    -- ^ __Returns:__ a t'GI.Soup.Structs.MessageMetrics.MessageMetrics'
messageGetMetrics :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m (Maybe MessageMetrics)
messageGetMetrics a
msg = IO (Maybe MessageMetrics) -> m (Maybe MessageMetrics)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MessageMetrics) -> m (Maybe MessageMetrics))
-> IO (Maybe MessageMetrics) -> m (Maybe MessageMetrics)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr MessageMetrics
result <- Ptr Message -> IO (Ptr MessageMetrics)
soup_message_get_metrics Ptr Message
msg'
    Maybe MessageMetrics
maybeResult <- Ptr MessageMetrics
-> (Ptr MessageMetrics -> IO MessageMetrics)
-> IO (Maybe MessageMetrics)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MessageMetrics
result ((Ptr MessageMetrics -> IO MessageMetrics)
 -> IO (Maybe MessageMetrics))
-> (Ptr MessageMetrics -> IO MessageMetrics)
-> IO (Maybe MessageMetrics)
forall a b. (a -> b) -> a -> b
$ \Ptr MessageMetrics
result' -> do
        MessageMetrics
result'' <- ((ManagedPtr MessageMetrics -> MessageMetrics)
-> Ptr MessageMetrics -> IO MessageMetrics
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageMetrics -> MessageMetrics
Soup.MessageMetrics.MessageMetrics) Ptr MessageMetrics
result'
        MessageMetrics -> IO MessageMetrics
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageMetrics
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe MessageMetrics -> IO (Maybe MessageMetrics)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MessageMetrics
maybeResult

#if defined(ENABLE_OVERLOADING)
data MessageGetMetricsMethodInfo
instance (signature ~ (m (Maybe Soup.MessageMetrics.MessageMetrics)), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetMetricsMethodInfo a signature where
    overloadedMethod = messageGetMetrics

instance O.OverloadedMethodInfo MessageGetMetricsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetMetrics",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetMetrics"
        })


#endif

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

foreign import ccall "soup_message_get_priority" soup_message_get_priority :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CUInt

-- | Retrieves the [enum/@messagePriority@/].
-- 
-- If not set this value defaults to @/SOUP_MESSAGE_PRIORITY_NORMAL/@.
messageGetPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m Soup.Enums.MessagePriority
    -- ^ __Returns:__ the priority of the message.
messageGetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m MessagePriority
messageGetPriority a
msg = IO MessagePriority -> m MessagePriority
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessagePriority -> m MessagePriority)
-> IO MessagePriority -> m MessagePriority
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr Message -> IO CUInt
soup_message_get_priority Ptr Message
msg'
    let result' :: MessagePriority
result' = (Int -> MessagePriority
forall a. Enum a => Int -> a
toEnum (Int -> MessagePriority)
-> (CUInt -> Int) -> CUInt -> MessagePriority
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    MessagePriority -> IO MessagePriority
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessagePriority
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetPriorityMethodInfo
instance (signature ~ (m Soup.Enums.MessagePriority), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetPriorityMethodInfo a signature where
    overloadedMethod = messageGetPriority

instance O.OverloadedMethodInfo MessageGetPriorityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetPriority",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetPriority"
        })


#endif

-- method Message::get_reason_phrase
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #SoupMessage" , 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_get_reason_phrase" soup_message_get_reason_phrase :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CString

-- | Returns the reason phrase for the status of this message.
messageGetReasonPhrase ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the phrase
messageGetReasonPhrase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m (Maybe Text)
messageGetReasonPhrase a
msg = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
result <- Ptr Message -> IO CString
soup_message_get_reason_phrase Ptr Message
msg'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data MessageGetReasonPhraseMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetReasonPhraseMethodInfo a signature where
    overloadedMethod = messageGetReasonPhrase

instance O.OverloadedMethodInfo MessageGetReasonPhraseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetReasonPhrase",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetReasonPhrase"
        })


#endif

-- method Message::get_remote_address
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "SocketAddress" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_get_remote_address" soup_message_get_remote_address :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr Gio.SocketAddress.SocketAddress)

-- | Get the remote t'GI.Gio.Objects.SocketAddress.SocketAddress' of the connection associated with
-- the message.
-- 
-- The returned address can be 'P.Nothing' if the connection hasn\'t been established
-- yet, or the resource was loaded from the disk cache. In case of proxy
-- connections, the remote address returned is a t'GI.Gio.Objects.ProxyAddress.ProxyAddress'. If
-- [property/@session@/:remote-connectable] is set the returned address id for the
-- connection to the session\'s remote connectable.
messageGetRemoteAddress ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m (Maybe Gio.SocketAddress.SocketAddress)
    -- ^ __Returns:__ a t'GI.Gio.Objects.SocketAddress.SocketAddress' or 'P.Nothing' if the connection
    --     hasn\'t been established
messageGetRemoteAddress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m (Maybe SocketAddress)
messageGetRemoteAddress a
msg = IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SocketAddress) -> m (Maybe SocketAddress))
-> IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr SocketAddress
result <- Ptr Message -> IO (Ptr SocketAddress)
soup_message_get_remote_address Ptr Message
msg'
    Maybe SocketAddress
maybeResult <- Ptr SocketAddress
-> (Ptr SocketAddress -> IO SocketAddress)
-> IO (Maybe SocketAddress)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr SocketAddress
result ((Ptr SocketAddress -> IO SocketAddress)
 -> IO (Maybe SocketAddress))
-> (Ptr SocketAddress -> IO SocketAddress)
-> IO (Maybe SocketAddress)
forall a b. (a -> b) -> a -> b
$ \Ptr SocketAddress
result' -> do
        SocketAddress
result'' <- ((ManagedPtr SocketAddress -> SocketAddress)
-> Ptr SocketAddress -> IO SocketAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SocketAddress -> SocketAddress
Gio.SocketAddress.SocketAddress) Ptr SocketAddress
result'
        SocketAddress -> IO SocketAddress
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SocketAddress
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe SocketAddress -> IO (Maybe SocketAddress)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SocketAddress
maybeResult

#if defined(ENABLE_OVERLOADING)
data MessageGetRemoteAddressMethodInfo
instance (signature ~ (m (Maybe Gio.SocketAddress.SocketAddress)), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetRemoteAddressMethodInfo a signature where
    overloadedMethod = messageGetRemoteAddress

instance O.OverloadedMethodInfo MessageGetRemoteAddressMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetRemoteAddress",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetRemoteAddress"
        })


#endif

-- method Message::get_request_headers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #SoupMessage" , 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_get_request_headers" soup_message_get_request_headers :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr Soup.MessageHeaders.MessageHeaders)

-- | Returns the headers sent with the request.
messageGetRequestHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m Soup.MessageHeaders.MessageHeaders
    -- ^ __Returns:__ The t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
messageGetRequestHeaders :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m MessageHeaders
messageGetRequestHeaders a
msg = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr MessageHeaders
result <- Ptr Message -> IO (Ptr MessageHeaders)
soup_message_get_request_headers Ptr Message
msg'
    Text -> Ptr MessageHeaders -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageGetRequestHeaders" Ptr MessageHeaders
result
    MessageHeaders
result' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders) Ptr MessageHeaders
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    MessageHeaders -> IO MessageHeaders
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetRequestHeadersMethodInfo
instance (signature ~ (m Soup.MessageHeaders.MessageHeaders), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetRequestHeadersMethodInfo a signature where
    overloadedMethod = messageGetRequestHeaders

instance O.OverloadedMethodInfo MessageGetRequestHeadersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetRequestHeaders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetRequestHeaders"
        })


#endif

-- method Message::get_response_headers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #SoupMessage" , 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_get_response_headers" soup_message_get_response_headers :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr Soup.MessageHeaders.MessageHeaders)

-- | Returns the headers recieved with the response.
messageGetResponseHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m Soup.MessageHeaders.MessageHeaders
    -- ^ __Returns:__ The t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
messageGetResponseHeaders :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m MessageHeaders
messageGetResponseHeaders a
msg = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr MessageHeaders
result <- Ptr Message -> IO (Ptr MessageHeaders)
soup_message_get_response_headers Ptr Message
msg'
    Text -> Ptr MessageHeaders -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageGetResponseHeaders" Ptr MessageHeaders
result
    MessageHeaders
result' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders) Ptr MessageHeaders
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    MessageHeaders -> IO MessageHeaders
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetResponseHeadersMethodInfo
instance (signature ~ (m Soup.MessageHeaders.MessageHeaders), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetResponseHeadersMethodInfo a signature where
    overloadedMethod = messageGetResponseHeaders

instance O.OverloadedMethodInfo MessageGetResponseHeadersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetResponseHeaders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetResponseHeaders"
        })


#endif

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

foreign import ccall "soup_message_get_site_for_cookies" soup_message_get_site_for_cookies :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr GLib.Uri.Uri)

-- | Gets /@msg@/\'s site for cookies t'GI.GLib.Structs.Uri.Uri'.
messageGetSiteForCookies ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m GLib.Uri.Uri
    -- ^ __Returns:__ the /@msg@/\'s site for cookies t'GI.GLib.Structs.Uri.Uri'
messageGetSiteForCookies :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Uri
messageGetSiteForCookies a
msg = IO Uri -> m Uri
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Uri -> m Uri) -> IO Uri -> m Uri
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Uri
result <- Ptr Message -> IO (Ptr Uri)
soup_message_get_site_for_cookies Ptr Message
msg'
    Text -> Ptr Uri -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageGetSiteForCookies" Ptr Uri
result
    Uri
result' <- ((ManagedPtr Uri -> Uri) -> Ptr Uri -> IO Uri
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Uri -> Uri
GLib.Uri.Uri) Ptr Uri
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Uri -> IO Uri
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetSiteForCookiesMethodInfo
instance (signature ~ (m GLib.Uri.Uri), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetSiteForCookiesMethodInfo a signature where
    overloadedMethod = messageGetSiteForCookies

instance O.OverloadedMethodInfo MessageGetSiteForCookiesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetSiteForCookies",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetSiteForCookies"
        })


#endif

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

foreign import ccall "soup_message_get_status" soup_message_get_status :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CUInt

-- | Returns the set status of this message.
messageGetStatus ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> m Soup.Enums.Status
    -- ^ __Returns:__ The t'GI.Soup.Enums.Status'
messageGetStatus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Status
messageGetStatus a
msg = IO Status -> m Status
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Status -> m Status) -> IO Status -> m Status
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr Message -> IO CUInt
soup_message_get_status Ptr Message
msg'
    let result' :: Status
result' = (Int -> Status
forall a. Enum a => Int -> a
toEnum (Int -> Status) -> (CUInt -> Int) -> CUInt -> Status
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Status -> IO Status
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Status
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetStatusMethodInfo
instance (signature ~ (m Soup.Enums.Status), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetStatusMethodInfo a signature where
    overloadedMethod = messageGetStatus

instance O.OverloadedMethodInfo MessageGetStatusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetStatus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetStatus"
        })


#endif

-- method Message::get_tls_ciphersuite_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , 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_get_tls_ciphersuite_name" soup_message_get_tls_ciphersuite_name :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CString

-- | Gets the name of the TLS ciphersuite negotiated for /@msg@/\'s connection.
messageGetTlsCiphersuiteName ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m T.Text
    -- ^ __Returns:__ the name of the TLS ciphersuite,
    --   or 'P.Nothing' if /@msg@/\'s connection is not SSL.
messageGetTlsCiphersuiteName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Text
messageGetTlsCiphersuiteName a
msg = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
result <- Ptr Message -> IO CString
soup_message_get_tls_ciphersuite_name Ptr Message
msg'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageGetTlsCiphersuiteName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetTlsCiphersuiteNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetTlsCiphersuiteNameMethodInfo a signature where
    overloadedMethod = messageGetTlsCiphersuiteName

instance O.OverloadedMethodInfo MessageGetTlsCiphersuiteNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetTlsCiphersuiteName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetTlsCiphersuiteName"
        })


#endif

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

foreign import ccall "soup_message_get_tls_peer_certificate" soup_message_get_tls_peer_certificate :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr Gio.TlsCertificate.TlsCertificate)

-- | Gets the peer\'s t'GI.Gio.Objects.TlsCertificate.TlsCertificate' associated with /@msg@/\'s connection.
-- 
-- Note that this is not set yet during the emission of
-- [signal/@message@/[acceptCertificate](#g:signal:acceptCertificate)] signal.
messageGetTlsPeerCertificate ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m (Maybe Gio.TlsCertificate.TlsCertificate)
    -- ^ __Returns:__ /@msg@/\'s TLS peer certificate,
    --   or 'P.Nothing' if /@msg@/\'s connection is not SSL.
messageGetTlsPeerCertificate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m (Maybe TlsCertificate)
messageGetTlsPeerCertificate a
msg = IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate))
-> IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr TlsCertificate
result <- Ptr Message -> IO (Ptr TlsCertificate)
soup_message_get_tls_peer_certificate Ptr Message
msg'
    Maybe TlsCertificate
maybeResult <- Ptr TlsCertificate
-> (Ptr TlsCertificate -> IO TlsCertificate)
-> IO (Maybe TlsCertificate)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TlsCertificate
result ((Ptr TlsCertificate -> IO TlsCertificate)
 -> IO (Maybe TlsCertificate))
-> (Ptr TlsCertificate -> IO TlsCertificate)
-> IO (Maybe TlsCertificate)
forall a b. (a -> b) -> a -> b
$ \Ptr TlsCertificate
result' -> do
        TlsCertificate
result'' <- ((ManagedPtr TlsCertificate -> TlsCertificate)
-> Ptr TlsCertificate -> IO TlsCertificate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TlsCertificate -> TlsCertificate
Gio.TlsCertificate.TlsCertificate) Ptr TlsCertificate
result'
        TlsCertificate -> IO TlsCertificate
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TlsCertificate
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe TlsCertificate -> IO (Maybe TlsCertificate)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TlsCertificate
maybeResult

#if defined(ENABLE_OVERLOADING)
data MessageGetTlsPeerCertificateMethodInfo
instance (signature ~ (m (Maybe Gio.TlsCertificate.TlsCertificate)), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetTlsPeerCertificateMethodInfo a signature where
    overloadedMethod = messageGetTlsPeerCertificate

instance O.OverloadedMethodInfo MessageGetTlsPeerCertificateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetTlsPeerCertificate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetTlsPeerCertificate"
        })


#endif

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

foreign import ccall "soup_message_get_tls_peer_certificate_errors" soup_message_get_tls_peer_certificate_errors :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CUInt

-- | Gets the errors associated with validating /@msg@/\'s TLS peer certificate.
-- Note that this is not set yet during the emission of
-- [signal/@message@/[acceptCertificate](#g:signal:acceptCertificate)] signal.
messageGetTlsPeerCertificateErrors ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m [Gio.Flags.TlsCertificateFlags]
    -- ^ __Returns:__ a t'GI.Gio.Flags.TlsCertificateFlags' with /@msg@/\'s TLS peer certificate errors.
messageGetTlsPeerCertificateErrors :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m [TlsCertificateFlags]
messageGetTlsPeerCertificateErrors a
msg = IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TlsCertificateFlags] -> m [TlsCertificateFlags])
-> IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr Message -> IO CUInt
soup_message_get_tls_peer_certificate_errors Ptr Message
msg'
    let result' :: [TlsCertificateFlags]
result' = CUInt -> [TlsCertificateFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    [TlsCertificateFlags] -> IO [TlsCertificateFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TlsCertificateFlags]
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetTlsPeerCertificateErrorsMethodInfo
instance (signature ~ (m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetTlsPeerCertificateErrorsMethodInfo a signature where
    overloadedMethod = messageGetTlsPeerCertificateErrors

instance O.OverloadedMethodInfo MessageGetTlsPeerCertificateErrorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetTlsPeerCertificateErrors",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetTlsPeerCertificateErrors"
        })


#endif

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

foreign import ccall "soup_message_get_tls_protocol_version" soup_message_get_tls_protocol_version :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CUInt

-- | Gets the TLS protocol version negotiated for /@msg@/\'s connection.
-- 
-- If the message connection is not SSL, 'GI.Gio.Enums.TlsProtocolVersionUnknown' is returned.
messageGetTlsProtocolVersion ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m Gio.Enums.TlsProtocolVersion
    -- ^ __Returns:__ a t'GI.Gio.Enums.TlsProtocolVersion'
messageGetTlsProtocolVersion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m TlsProtocolVersion
messageGetTlsProtocolVersion a
msg = IO TlsProtocolVersion -> m TlsProtocolVersion
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TlsProtocolVersion -> m TlsProtocolVersion)
-> IO TlsProtocolVersion -> m TlsProtocolVersion
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr Message -> IO CUInt
soup_message_get_tls_protocol_version Ptr Message
msg'
    let result' :: TlsProtocolVersion
result' = (Int -> TlsProtocolVersion
forall a. Enum a => Int -> a
toEnum (Int -> TlsProtocolVersion)
-> (CUInt -> Int) -> CUInt -> TlsProtocolVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    TlsProtocolVersion -> IO TlsProtocolVersion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TlsProtocolVersion
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetTlsProtocolVersionMethodInfo
instance (signature ~ (m Gio.Enums.TlsProtocolVersion), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetTlsProtocolVersionMethodInfo a signature where
    overloadedMethod = messageGetTlsProtocolVersion

instance O.OverloadedMethodInfo MessageGetTlsProtocolVersionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetTlsProtocolVersion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetTlsProtocolVersion"
        })


#endif

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

foreign import ccall "soup_message_get_uri" soup_message_get_uri :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr GLib.Uri.Uri)

-- | Gets /@msg@/\'s URI.
messageGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m GLib.Uri.Uri
    -- ^ __Returns:__ the URI /@msg@/ is targeted for.
messageGetUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Uri
messageGetUri a
msg = IO Uri -> m Uri
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Uri -> m Uri) -> IO Uri -> m Uri
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Uri
result <- Ptr Message -> IO (Ptr Uri)
soup_message_get_uri Ptr Message
msg'
    Text -> Ptr Uri -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageGetUri" Ptr Uri
result
    Uri
result' <- ((ManagedPtr Uri -> Uri) -> Ptr Uri -> IO Uri
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Uri -> Uri
GLib.Uri.Uri) Ptr Uri
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Uri -> IO Uri
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result'

#if defined(ENABLE_OVERLOADING)
data MessageGetUriMethodInfo
instance (signature ~ (m GLib.Uri.Uri), MonadIO m, IsMessage a) => O.OverloadedMethod MessageGetUriMethodInfo a signature where
    overloadedMethod = messageGetUri

instance O.OverloadedMethodInfo MessageGetUriMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageGetUri",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageGetUri"
        })


#endif

-- method Message::is_feature_disabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "feature_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GType of a #SoupSessionFeature"
--                 , 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_is_feature_disabled" soup_message_is_feature_disabled :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CGType ->                               -- feature_type : TBasicType TGType
    IO CInt

-- | Get whether [iface/@sessionFeature@/]s of the given /@featureType@/
-- (or a subclass of that type) are disabled on /@msg@/.
-- 
-- See [method/@message@/.disable_feature].
messageIsFeatureDisabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> GType
    -- ^ /@featureType@/: the t'GType' of a t'GI.Soup.Interfaces.SessionFeature.SessionFeature'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if feature is disabled, or 'P.False' otherwise.
messageIsFeatureDisabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> GType -> m Bool
messageIsFeatureDisabled a
msg GType
featureType = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let featureType' :: CGType
featureType' = GType -> CGType
gtypeToCGType GType
featureType
    CInt
result <- Ptr Message -> CGType -> IO CInt
soup_message_is_feature_disabled Ptr Message
msg' CGType
featureType'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageIsFeatureDisabledMethodInfo
instance (signature ~ (GType -> m Bool), MonadIO m, IsMessage a) => O.OverloadedMethod MessageIsFeatureDisabledMethodInfo a signature where
    overloadedMethod = messageIsFeatureDisabled

instance O.OverloadedMethodInfo MessageIsFeatureDisabledMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageIsFeatureDisabled",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageIsFeatureDisabled"
        })


#endif

-- method Message::is_keepalive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , 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_is_keepalive" soup_message_is_keepalive :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO CInt

-- | Determines whether or not /@msg@/\'s connection can be kept alive for
-- further requests after processing /@msg@/.
-- 
-- The result is based on the HTTP version, Connection header, etc.
messageIsKeepalive ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m Bool
    -- ^ __Returns:__ 'P.True' or 'P.False'.
messageIsKeepalive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m Bool
messageIsKeepalive a
msg = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CInt
result <- Ptr Message -> IO CInt
soup_message_is_keepalive Ptr Message
msg'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageIsKeepaliveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMessage a) => O.OverloadedMethod MessageIsKeepaliveMethodInfo a signature where
    overloadedMethod = messageIsKeepalive

instance O.OverloadedMethodInfo MessageIsKeepaliveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageIsKeepalive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageIsKeepalive"
        })


#endif

-- method Message::query_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a set of #SoupMessageFlags values"
--                 , 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_query_flags" soup_message_query_flags :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Soup", name = "MessageFlags"})
    IO CInt

-- | Queries if /@flags@/ are present in the set of /@msg@/\'s flags.
messageQueryFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> [Soup.Flags.MessageFlags]
    -- ^ /@flags@/: a set of t'GI.Soup.Flags.MessageFlags' values
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@flags@/ are enabled in /@msg@/
messageQueryFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> [MessageFlags] -> m Bool
messageQueryFlags a
msg [MessageFlags]
flags = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let flags' :: CUInt
flags' = [MessageFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageFlags]
flags
    CInt
result <- Ptr Message -> CUInt -> IO CInt
soup_message_query_flags Ptr Message
msg' CUInt
flags'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageQueryFlagsMethodInfo
instance (signature ~ ([Soup.Flags.MessageFlags] -> m Bool), MonadIO m, IsMessage a) => O.OverloadedMethod MessageQueryFlagsMethodInfo a signature where
    overloadedMethod = messageQueryFlags

instance O.OverloadedMethodInfo MessageQueryFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageQueryFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageQueryFlags"
        })


#endif

-- method Message::remove_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a set of #SoupMessageFlags values"
--                 , 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_remove_flags" soup_message_remove_flags :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Soup", name = "MessageFlags"})
    IO ()

-- | Removes /@flags@/ from the set of /@msg@/\'s flags.
messageRemoveFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> [Soup.Flags.MessageFlags]
    -- ^ /@flags@/: a set of t'GI.Soup.Flags.MessageFlags' values
    -> m ()
messageRemoveFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> [MessageFlags] -> m ()
messageRemoveFlags a
msg [MessageFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let flags' :: CUInt
flags' = [MessageFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageFlags]
flags
    Ptr Message -> CUInt -> IO ()
soup_message_remove_flags Ptr Message
msg' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageRemoveFlagsMethodInfo
instance (signature ~ ([Soup.Flags.MessageFlags] -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageRemoveFlagsMethodInfo a signature where
    overloadedMethod = messageRemoveFlags

instance O.OverloadedMethodInfo MessageRemoveFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageRemoveFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageRemoveFlags"
        })


#endif

-- method Message::set_first_party
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "first_party"
--           , argType = TInterface Name { namespace = "GLib" , name = "Uri" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GUri for the @msg's first party"
--                 , 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_set_first_party" soup_message_set_first_party :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    Ptr GLib.Uri.Uri ->                     -- first_party : TInterface (Name {namespace = "GLib", name = "Uri"})
    IO ()

-- | Sets /@firstParty@/ as the main document t'GI.GLib.Structs.Uri.Uri' for /@msg@/.
-- 
-- For details of when and how this is used refer to the documentation for
-- [enum/@cookieJarAcceptPolicy@/].
messageSetFirstParty ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> GLib.Uri.Uri
    -- ^ /@firstParty@/: the t'GI.GLib.Structs.Uri.Uri' for the /@msg@/\'s first party
    -> m ()
messageSetFirstParty :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Uri -> m ()
messageSetFirstParty a
msg Uri
firstParty = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Uri
firstParty' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
firstParty
    Ptr Message -> Ptr Uri -> IO ()
soup_message_set_first_party Ptr Message
msg' Ptr Uri
firstParty'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
firstParty
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetFirstPartyMethodInfo
instance (signature ~ (GLib.Uri.Uri -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetFirstPartyMethodInfo a signature where
    overloadedMethod = messageSetFirstParty

instance O.OverloadedMethodInfo MessageSetFirstPartyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetFirstParty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetFirstParty"
        })


#endif

-- method Message::set_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a set of #SoupMessageFlags values"
--                 , 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_set_flags" soup_message_set_flags :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Soup", name = "MessageFlags"})
    IO ()

-- | Sets the specified flags on /@msg@/.
messageSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> [Soup.Flags.MessageFlags]
    -- ^ /@flags@/: a set of t'GI.Soup.Flags.MessageFlags' values
    -> m ()
messageSetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> [MessageFlags] -> m ()
messageSetFlags a
msg [MessageFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let flags' :: CUInt
flags' = [MessageFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageFlags]
flags
    Ptr Message -> CUInt -> IO ()
soup_message_set_flags Ptr Message
msg' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetFlagsMethodInfo
instance (signature ~ ([Soup.Flags.MessageFlags] -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetFlagsMethodInfo a signature where
    overloadedMethod = messageSetFlags

instance O.OverloadedMethodInfo MessageSetFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetFlags"
        })


#endif

-- method Message::set_force_http1
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "value 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_set_force_http1" soup_message_set_force_http1 :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

-- | Sets whether HTTP\/1 version should be used when sending this message.
-- Some connections can still override it, if needed.
-- 
-- Note the value is unset after the message send is finished.
-- 
-- /Since: 3.4/
messageSetForceHttp1 ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: The t'GI.Soup.Objects.Message.Message'
    -> Bool
    -- ^ /@value@/: value to set
    -> m ()
messageSetForceHttp1 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Bool -> m ()
messageSetForceHttp1 a
msg Bool
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let value' :: CInt
value' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
value
    Ptr Message -> CInt -> IO ()
soup_message_set_force_http1 Ptr Message
msg' CInt
value'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetForceHttp1MethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetForceHttp1MethodInfo a signature where
    overloadedMethod = messageSetForceHttp1

instance O.OverloadedMethodInfo MessageSetForceHttp1MethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetForceHttp1",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetForceHttp1"
        })


#endif

-- method Message::set_is_options_ping
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_options_ping"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value 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_set_is_options_ping" soup_message_set_is_options_ping :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CInt ->                                 -- is_options_ping : TBasicType TBoolean
    IO ()

-- | Set whether /@msg@/ is intended to be used to send @OPTIONS *@ to a server.
-- 
-- When set to 'P.True', the path of [property/@message@/:uri] will be ignored and
-- [property/@message@/:method] set to @/SOUP_METHOD_OPTIONS/@.
messageSetIsOptionsPing ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Bool
    -- ^ /@isOptionsPing@/: the value to set
    -> m ()
messageSetIsOptionsPing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Bool -> m ()
messageSetIsOptionsPing a
msg Bool
isOptionsPing = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let isOptionsPing' :: CInt
isOptionsPing' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isOptionsPing
    Ptr Message -> CInt -> IO ()
soup_message_set_is_options_ping Ptr Message
msg' CInt
isOptionsPing'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetIsOptionsPingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetIsOptionsPingMethodInfo a signature where
    overloadedMethod = messageSetIsOptionsPing

instance O.OverloadedMethodInfo MessageSetIsOptionsPingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetIsOptionsPing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetIsOptionsPing"
        })


#endif

-- method Message::set_is_top_level_navigation
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_top_level_navigation"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "if %TRUE indicate the current request is a top-level navigation"
--                 , 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_set_is_top_level_navigation" soup_message_set_is_top_level_navigation :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CInt ->                                 -- is_top_level_navigation : TBasicType TBoolean
    IO ()

-- | Sets whether the current request is a top-level navitation.
-- 
-- See the <https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00 same-site spec>
-- for more information.
messageSetIsTopLevelNavigation ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Bool
    -- ^ /@isTopLevelNavigation@/: if 'P.True' indicate the current request is a top-level navigation
    -> m ()
messageSetIsTopLevelNavigation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Bool -> m ()
messageSetIsTopLevelNavigation a
msg Bool
isTopLevelNavigation = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let isTopLevelNavigation' :: CInt
isTopLevelNavigation' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isTopLevelNavigation
    Ptr Message -> CInt -> IO ()
soup_message_set_is_top_level_navigation Ptr Message
msg' CInt
isTopLevelNavigation'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetIsTopLevelNavigationMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetIsTopLevelNavigationMethodInfo a signature where
    overloadedMethod = messageSetIsTopLevelNavigation

instance O.OverloadedMethodInfo MessageSetIsTopLevelNavigationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetIsTopLevelNavigation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetIsTopLevelNavigation"
        })


#endif

-- method Message::set_method
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "method"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value 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_set_method" soup_message_set_method :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CString ->                              -- method : TBasicType TUTF8
    IO ()

-- | Set /@msg@/\'s HTTP method to /@method@/.
messageSetMethod ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> T.Text
    -- ^ /@method@/: the value to set
    -> m ()
messageSetMethod :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Text -> m ()
messageSetMethod a
msg Text
method = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
method' <- Text -> IO CString
textToCString Text
method
    Ptr Message -> CString -> IO ()
soup_message_set_method Ptr Message
msg' CString
method'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
method'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetMethodMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetMethodMethodInfo a signature where
    overloadedMethod = messageSetMethod

instance O.OverloadedMethodInfo MessageSetMethodMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetMethod",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetMethod"
        })


#endif

-- method Message::set_priority
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "priority"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessagePriority" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupMessagePriority"
--                 , 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_set_priority" soup_message_set_priority :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CUInt ->                                -- priority : TInterface (Name {namespace = "Soup", name = "MessagePriority"})
    IO ()

-- | Sets the priority of a message.
-- 
-- Note that this won\'t have any effect unless used before the message is added
-- to the session\'s message processing queue.
-- 
-- The message will be placed just before any other previously added
-- message with lower priority (messages with the same priority are
-- processed on a FIFO basis).
-- 
-- Setting priorities does not currently work with synchronous messages
-- because in the synchronous\/blocking case, priority ends up being determined
-- semi-randomly by thread scheduling.
messageSetPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Soup.Enums.MessagePriority
    -- ^ /@priority@/: the t'GI.Soup.Enums.MessagePriority'
    -> m ()
messageSetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> MessagePriority -> m ()
messageSetPriority a
msg MessagePriority
priority = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let priority' :: CUInt
priority' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MessagePriority -> Int) -> MessagePriority -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MessagePriority -> Int
forall a. Enum a => a -> Int
fromEnum) MessagePriority
priority
    Ptr Message -> CUInt -> IO ()
soup_message_set_priority Ptr Message
msg' CUInt
priority'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetPriorityMethodInfo
instance (signature ~ (Soup.Enums.MessagePriority -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetPriorityMethodInfo a signature where
    overloadedMethod = messageSetPriority

instance O.OverloadedMethodInfo MessageSetPriorityMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetPriority",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetPriority"
        })


#endif

-- method Message::set_request_body
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "MIME Content-Type of the body, or %NULL if unknown"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GInputStream to read the request body from"
--                 , 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 byte length of @stream 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_set_request_body" soup_message_set_request_body :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CString ->                              -- content_type : TBasicType TUTF8
    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Int64 ->                                -- content_length : TBasicType TInt64
    IO ()

-- | Set the request body of a t'GI.Soup.Objects.Message.Message'.
-- 
-- If /@contentType@/ is 'P.Nothing' and /@stream@/ is not 'P.Nothing' the Content-Type header will
-- not be changed if present.
-- The request body needs to be set again in case /@msg@/ is restarted
-- (in case of redirection or authentication).
messageSetRequestBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a, Gio.InputStream.IsInputStream b) =>
    a
    -- ^ /@msg@/: the message
    -> Maybe (T.Text)
    -- ^ /@contentType@/: MIME Content-Type of the body, or 'P.Nothing' if unknown
    -> Maybe (b)
    -- ^ /@stream@/: a t'GI.Gio.Objects.InputStream.InputStream' to read the request body from
    -> Int64
    -- ^ /@contentLength@/: the byte length of /@stream@/ or -1 if unknown
    -> m ()
messageSetRequestBody :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMessage a, IsInputStream b) =>
a -> Maybe Text -> Maybe b -> Int64 -> m ()
messageSetRequestBody a
msg Maybe Text
contentType Maybe b
stream Int64
contentLength = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
maybeContentType <- case Maybe Text
contentType of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jContentType -> do
            CString
jContentType' <- Text -> IO CString
textToCString Text
jContentType
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jContentType'
    Ptr InputStream
maybeStream <- case Maybe b
stream of
        Maybe b
Nothing -> Ptr InputStream -> IO (Ptr InputStream)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputStream
forall a. Ptr a
nullPtr
        Just b
jStream -> do
            Ptr InputStream
jStream' <- b -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jStream
            Ptr InputStream -> IO (Ptr InputStream)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputStream
jStream'
    Ptr Message -> CString -> Ptr InputStream -> Int64 -> IO ()
soup_message_set_request_body Ptr Message
msg' CString
maybeContentType Ptr InputStream
maybeStream Int64
contentLength
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
stream b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeContentType
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetRequestBodyMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (b) -> Int64 -> m ()), MonadIO m, IsMessage a, Gio.InputStream.IsInputStream b) => O.OverloadedMethod MessageSetRequestBodyMethodInfo a signature where
    overloadedMethod = messageSetRequestBody

instance O.OverloadedMethodInfo MessageSetRequestBodyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetRequestBody",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetRequestBody"
        })


#endif

-- method Message::set_request_body_from_bytes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "MIME Content-Type of the body, or %NULL if unknown"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GBytes with the request body data"
--                 , 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_set_request_body_from_bytes" soup_message_set_request_body_from_bytes :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CString ->                              -- content_type : TBasicType TUTF8
    Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO ()

-- | Set the request body of a t'GI.Soup.Objects.Message.Message' from [struct/@gLib@/.Bytes].
-- 
-- If /@contentType@/ is 'P.Nothing' and /@bytes@/ is not 'P.Nothing' the Content-Type header will
-- not be changed if present.
-- The request body needs to be set again in case /@msg@/ is restarted
-- (in case of redirection or authentication).
messageSetRequestBodyFromBytes ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: the message
    -> Maybe (T.Text)
    -- ^ /@contentType@/: MIME Content-Type of the body, or 'P.Nothing' if unknown
    -> Maybe (GLib.Bytes.Bytes)
    -- ^ /@bytes@/: a t'GI.GLib.Structs.Bytes.Bytes' with the request body data
    -> m ()
messageSetRequestBodyFromBytes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Maybe Text -> Maybe Bytes -> m ()
messageSetRequestBodyFromBytes a
msg Maybe Text
contentType Maybe Bytes
bytes = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
maybeContentType <- case Maybe Text
contentType of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jContentType -> do
            CString
jContentType' <- Text -> IO CString
textToCString Text
jContentType
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jContentType'
    Ptr Bytes
maybeBytes <- case Maybe Bytes
bytes of
        Maybe Bytes
Nothing -> Ptr Bytes -> IO (Ptr Bytes)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Bytes
forall a. Ptr a
nullPtr
        Just Bytes
jBytes -> do
            Ptr Bytes
jBytes' <- Bytes -> IO (Ptr Bytes)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
jBytes
            Ptr Bytes -> IO (Ptr Bytes)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Bytes
jBytes'
    Ptr Message -> CString -> Ptr Bytes -> IO ()
soup_message_set_request_body_from_bytes Ptr Message
msg' CString
maybeContentType Ptr Bytes
maybeBytes
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe Bytes -> (Bytes -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Bytes
bytes Bytes -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeContentType
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetRequestBodyFromBytesMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (GLib.Bytes.Bytes) -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetRequestBodyFromBytesMethodInfo a signature where
    overloadedMethod = messageSetRequestBodyFromBytes

instance O.OverloadedMethodInfo MessageSetRequestBodyFromBytesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetRequestBodyFromBytes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetRequestBodyFromBytes"
        })


#endif

-- method Message::set_site_for_cookies
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "site_for_cookies"
--           , argType = TInterface Name { namespace = "GLib" , name = "Uri" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GUri for the @msg's site for cookies"
--                 , 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_set_site_for_cookies" soup_message_set_site_for_cookies :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    Ptr GLib.Uri.Uri ->                     -- site_for_cookies : TInterface (Name {namespace = "GLib", name = "Uri"})
    IO ()

-- | Sets /@siteForCookies@/ as the policy URL for same-site cookies for /@msg@/.
-- 
-- It is either the URL of the top-level document or 'P.Nothing' depending on whether
-- the registrable domain of this document\'s URL matches the registrable domain
-- of its parent\'s\/opener\'s URL. For the top-level document it is set to the
-- document\'s URL.
-- 
-- See the <https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00 same-site spec>
-- for more information.
messageSetSiteForCookies ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Maybe (GLib.Uri.Uri)
    -- ^ /@siteForCookies@/: the t'GI.GLib.Structs.Uri.Uri' for the /@msg@/\'s site for cookies
    -> m ()
messageSetSiteForCookies :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Maybe Uri -> m ()
messageSetSiteForCookies a
msg Maybe Uri
siteForCookies = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Uri
maybeSiteForCookies <- case Maybe Uri
siteForCookies of
        Maybe Uri
Nothing -> Ptr Uri -> IO (Ptr Uri)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Uri
forall a. Ptr a
nullPtr
        Just Uri
jSiteForCookies -> do
            Ptr Uri
jSiteForCookies' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
jSiteForCookies
            Ptr Uri -> IO (Ptr Uri)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Uri
jSiteForCookies'
    Ptr Message -> Ptr Uri -> IO ()
soup_message_set_site_for_cookies Ptr Message
msg' Ptr Uri
maybeSiteForCookies
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe Uri -> (Uri -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Uri
siteForCookies Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetSiteForCookiesMethodInfo
instance (signature ~ (Maybe (GLib.Uri.Uri) -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetSiteForCookiesMethodInfo a signature where
    overloadedMethod = messageSetSiteForCookies

instance O.OverloadedMethodInfo MessageSetSiteForCookiesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetSiteForCookies",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetSiteForCookies"
        })


#endif

-- method Message::set_tls_client_certificate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "certificate"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "TlsCertificate" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GTlsCertificate to set, 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_set_tls_client_certificate" soup_message_set_tls_client_certificate :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
    IO ()

-- | Sets the /@certificate@/ to be used by /@msg@/\'s connection when a
-- client certificate is requested during the TLS handshake.
-- 
-- You can call this as a response to [signal/@message@/[requestCertificate](#g:signal:requestCertificate)]
-- signal, or before the connection is started. If /@certificate@/ is 'P.Nothing'
-- the handshake will continue without providing a GTlsCertificate.
-- Note that the t'GI.Gio.Objects.TlsCertificate.TlsCertificate' set by this function will be ignored if
-- [property/@session@/:tls-interaction] is not 'P.Nothing'.
messageSetTlsClientCertificate ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a, Gio.TlsCertificate.IsTlsCertificate b) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Maybe (b)
    -- ^ /@certificate@/: the t'GI.Gio.Objects.TlsCertificate.TlsCertificate' to set, or 'P.Nothing'
    -> m ()
messageSetTlsClientCertificate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMessage a, IsTlsCertificate b) =>
a -> Maybe b -> m ()
messageSetTlsClientCertificate a
msg Maybe b
certificate = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr TlsCertificate
maybeCertificate <- case Maybe b
certificate of
        Maybe b
Nothing -> Ptr TlsCertificate -> IO (Ptr TlsCertificate)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TlsCertificate
forall a. Ptr a
nullPtr
        Just b
jCertificate -> do
            Ptr TlsCertificate
jCertificate' <- b -> IO (Ptr TlsCertificate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCertificate
            Ptr TlsCertificate -> IO (Ptr TlsCertificate)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TlsCertificate
jCertificate'
    Ptr Message -> Ptr TlsCertificate -> IO ()
soup_message_set_tls_client_certificate Ptr Message
msg' Ptr TlsCertificate
maybeCertificate
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
certificate b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetTlsClientCertificateMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsMessage a, Gio.TlsCertificate.IsTlsCertificate b) => O.OverloadedMethod MessageSetTlsClientCertificateMethodInfo a signature where
    overloadedMethod = messageSetTlsClientCertificate

instance O.OverloadedMethodInfo MessageSetTlsClientCertificateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetTlsClientCertificate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetTlsClientCertificate"
        })


#endif

-- method Message::set_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TInterface Name { namespace = "GLib" , name = "Uri" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new #GUri" , 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_set_uri" soup_message_set_uri :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    Ptr GLib.Uri.Uri ->                     -- uri : TInterface (Name {namespace = "GLib", name = "Uri"})
    IO ()

-- | Sets /@msg@/\'s URI to /@uri@/.
-- 
-- If /@msg@/ has already been sent and you want to re-send it with the new URI,
-- you need to send it again.
messageSetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> GLib.Uri.Uri
    -- ^ /@uri@/: the new t'GI.GLib.Structs.Uri.Uri'
    -> m ()
messageSetUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Uri -> m ()
messageSetUri a
msg Uri
uri = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Uri
uri' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri
    Ptr Message -> Ptr Uri -> IO ()
soup_message_set_uri Ptr Message
msg' Ptr Uri
uri'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageSetUriMethodInfo
instance (signature ~ (GLib.Uri.Uri -> m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageSetUriMethodInfo a signature where
    overloadedMethod = messageSetUri

instance O.OverloadedMethodInfo MessageSetUriMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageSetUri",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageSetUri"
        })


#endif

-- method Message::tls_client_certificate_password_request_complete
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , 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_tls_client_certificate_password_request_complete" soup_message_tls_client_certificate_password_request_complete :: 
    Ptr Message ->                          -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO ()

-- | Completes a certificate password request.
-- 
-- You must call this as a response to
-- [signal/@message@/[requestCertificatePassword](#g:signal:requestCertificatePassword)] signal, to notify /@msg@/ that
-- the t'GI.Gio.Objects.TlsPassword.TlsPassword' has already been updated.
messageTlsClientCertificatePasswordRequestComplete ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m ()
messageTlsClientCertificatePasswordRequestComplete :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m ()
messageTlsClientCertificatePasswordRequestComplete a
msg = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Message -> IO ()
soup_message_tls_client_certificate_password_request_complete Ptr Message
msg'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageTlsClientCertificatePasswordRequestCompleteMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.OverloadedMethod MessageTlsClientCertificatePasswordRequestCompleteMethodInfo a signature where
    overloadedMethod = messageTlsClientCertificatePasswordRequestComplete

instance O.OverloadedMethodInfo MessageTlsClientCertificatePasswordRequestCompleteMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.Message.messageTlsClientCertificatePasswordRequestComplete",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-Message.html#v:messageTlsClientCertificatePasswordRequestComplete"
        })


#endif