gi-gio-2.0.20: GI/Gio/Objects/DBusMessage.hs

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

A type for representing D-Bus messages that can be sent or received
on a 'GI.Gio.Objects.DBusConnection.DBusConnection'.

/Since: 2.26/
-}

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

module GI.Gio.Objects.DBusMessage
    ( 

-- * Exported types
    DBusMessage(..)                         ,
    IsDBusMessage                           ,
    toDBusMessage                           ,
    noDBusMessage                           ,


 -- * Methods
-- ** bytesNeeded #method:bytesNeeded#

    dBusMessageBytesNeeded                  ,


-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    DBusMessageCopyMethodInfo               ,
#endif
    dBusMessageCopy                         ,


-- ** getArg0 #method:getArg0#

#if ENABLE_OVERLOADING
    DBusMessageGetArg0MethodInfo            ,
#endif
    dBusMessageGetArg0                      ,


-- ** getBody #method:getBody#

#if ENABLE_OVERLOADING
    DBusMessageGetBodyMethodInfo            ,
#endif
    dBusMessageGetBody                      ,


-- ** getByteOrder #method:getByteOrder#

#if ENABLE_OVERLOADING
    DBusMessageGetByteOrderMethodInfo       ,
#endif
    dBusMessageGetByteOrder                 ,


-- ** getDestination #method:getDestination#

#if ENABLE_OVERLOADING
    DBusMessageGetDestinationMethodInfo     ,
#endif
    dBusMessageGetDestination               ,


-- ** getErrorName #method:getErrorName#

#if ENABLE_OVERLOADING
    DBusMessageGetErrorNameMethodInfo       ,
#endif
    dBusMessageGetErrorName                 ,


-- ** getFlags #method:getFlags#

#if ENABLE_OVERLOADING
    DBusMessageGetFlagsMethodInfo           ,
#endif
    dBusMessageGetFlags                     ,


-- ** getHeader #method:getHeader#

#if ENABLE_OVERLOADING
    DBusMessageGetHeaderMethodInfo          ,
#endif
    dBusMessageGetHeader                    ,


-- ** getHeaderFields #method:getHeaderFields#

#if ENABLE_OVERLOADING
    DBusMessageGetHeaderFieldsMethodInfo    ,
#endif
    dBusMessageGetHeaderFields              ,


-- ** getInterface #method:getInterface#

#if ENABLE_OVERLOADING
    DBusMessageGetInterfaceMethodInfo       ,
#endif
    dBusMessageGetInterface                 ,


-- ** getLocked #method:getLocked#

#if ENABLE_OVERLOADING
    DBusMessageGetLockedMethodInfo          ,
#endif
    dBusMessageGetLocked                    ,


-- ** getMember #method:getMember#

#if ENABLE_OVERLOADING
    DBusMessageGetMemberMethodInfo          ,
#endif
    dBusMessageGetMember                    ,


-- ** getMessageType #method:getMessageType#

#if ENABLE_OVERLOADING
    DBusMessageGetMessageTypeMethodInfo     ,
#endif
    dBusMessageGetMessageType               ,


-- ** getNumUnixFds #method:getNumUnixFds#

#if ENABLE_OVERLOADING
    DBusMessageGetNumUnixFdsMethodInfo      ,
#endif
    dBusMessageGetNumUnixFds                ,


-- ** getPath #method:getPath#

#if ENABLE_OVERLOADING
    DBusMessageGetPathMethodInfo            ,
#endif
    dBusMessageGetPath                      ,


-- ** getReplySerial #method:getReplySerial#

#if ENABLE_OVERLOADING
    DBusMessageGetReplySerialMethodInfo     ,
#endif
    dBusMessageGetReplySerial               ,


-- ** getSender #method:getSender#

#if ENABLE_OVERLOADING
    DBusMessageGetSenderMethodInfo          ,
#endif
    dBusMessageGetSender                    ,


-- ** getSerial #method:getSerial#

#if ENABLE_OVERLOADING
    DBusMessageGetSerialMethodInfo          ,
#endif
    dBusMessageGetSerial                    ,


-- ** getSignature #method:getSignature#

#if ENABLE_OVERLOADING
    DBusMessageGetSignatureMethodInfo       ,
#endif
    dBusMessageGetSignature                 ,


-- ** getUnixFdList #method:getUnixFdList#

#if ENABLE_OVERLOADING
    DBusMessageGetUnixFdListMethodInfo      ,
#endif
    dBusMessageGetUnixFdList                ,


-- ** lock #method:lock#

#if ENABLE_OVERLOADING
    DBusMessageLockMethodInfo               ,
#endif
    dBusMessageLock                         ,


-- ** new #method:new#

    dBusMessageNew                          ,


-- ** newFromBlob #method:newFromBlob#

    dBusMessageNewFromBlob                  ,


-- ** newMethodCall #method:newMethodCall#

    dBusMessageNewMethodCall                ,


-- ** newMethodErrorLiteral #method:newMethodErrorLiteral#

#if ENABLE_OVERLOADING
    DBusMessageNewMethodErrorLiteralMethodInfo,
#endif
    dBusMessageNewMethodErrorLiteral        ,


-- ** newMethodReply #method:newMethodReply#

#if ENABLE_OVERLOADING
    DBusMessageNewMethodReplyMethodInfo     ,
#endif
    dBusMessageNewMethodReply               ,


-- ** newSignal #method:newSignal#

    dBusMessageNewSignal                    ,


-- ** print #method:print#

#if ENABLE_OVERLOADING
    DBusMessagePrintMethodInfo              ,
#endif
    dBusMessagePrint                        ,


-- ** setBody #method:setBody#

#if ENABLE_OVERLOADING
    DBusMessageSetBodyMethodInfo            ,
#endif
    dBusMessageSetBody                      ,


-- ** setByteOrder #method:setByteOrder#

#if ENABLE_OVERLOADING
    DBusMessageSetByteOrderMethodInfo       ,
#endif
    dBusMessageSetByteOrder                 ,


-- ** setDestination #method:setDestination#

#if ENABLE_OVERLOADING
    DBusMessageSetDestinationMethodInfo     ,
#endif
    dBusMessageSetDestination               ,


-- ** setErrorName #method:setErrorName#

#if ENABLE_OVERLOADING
    DBusMessageSetErrorNameMethodInfo       ,
#endif
    dBusMessageSetErrorName                 ,


-- ** setFlags #method:setFlags#

#if ENABLE_OVERLOADING
    DBusMessageSetFlagsMethodInfo           ,
#endif
    dBusMessageSetFlags                     ,


-- ** setHeader #method:setHeader#

#if ENABLE_OVERLOADING
    DBusMessageSetHeaderMethodInfo          ,
#endif
    dBusMessageSetHeader                    ,


-- ** setInterface #method:setInterface#

#if ENABLE_OVERLOADING
    DBusMessageSetInterfaceMethodInfo       ,
#endif
    dBusMessageSetInterface                 ,


-- ** setMember #method:setMember#

#if ENABLE_OVERLOADING
    DBusMessageSetMemberMethodInfo          ,
#endif
    dBusMessageSetMember                    ,


-- ** setMessageType #method:setMessageType#

#if ENABLE_OVERLOADING
    DBusMessageSetMessageTypeMethodInfo     ,
#endif
    dBusMessageSetMessageType               ,


-- ** setNumUnixFds #method:setNumUnixFds#

#if ENABLE_OVERLOADING
    DBusMessageSetNumUnixFdsMethodInfo      ,
#endif
    dBusMessageSetNumUnixFds                ,


-- ** setPath #method:setPath#

#if ENABLE_OVERLOADING
    DBusMessageSetPathMethodInfo            ,
#endif
    dBusMessageSetPath                      ,


-- ** setReplySerial #method:setReplySerial#

#if ENABLE_OVERLOADING
    DBusMessageSetReplySerialMethodInfo     ,
#endif
    dBusMessageSetReplySerial               ,


-- ** setSender #method:setSender#

#if ENABLE_OVERLOADING
    DBusMessageSetSenderMethodInfo          ,
#endif
    dBusMessageSetSender                    ,


-- ** setSerial #method:setSerial#

#if ENABLE_OVERLOADING
    DBusMessageSetSerialMethodInfo          ,
#endif
    dBusMessageSetSerial                    ,


-- ** setSignature #method:setSignature#

#if ENABLE_OVERLOADING
    DBusMessageSetSignatureMethodInfo       ,
#endif
    dBusMessageSetSignature                 ,


-- ** setUnixFdList #method:setUnixFdList#

#if ENABLE_OVERLOADING
    DBusMessageSetUnixFdListMethodInfo      ,
#endif
    dBusMessageSetUnixFdList                ,


-- ** toBlob #method:toBlob#

#if ENABLE_OVERLOADING
    DBusMessageToBlobMethodInfo             ,
#endif
    dBusMessageToBlob                       ,


-- ** toGerror #method:toGerror#

#if ENABLE_OVERLOADING
    DBusMessageToGerrorMethodInfo           ,
#endif
    dBusMessageToGerror                     ,




 -- * Properties
-- ** locked #attr:locked#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    DBusMessageLockedPropertyInfo           ,
#endif
#if ENABLE_OVERLOADING
    dBusMessageLocked                       ,
#endif
    getDBusMessageLocked                    ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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.Text as T
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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList

-- | Memory-managed wrapper type.
newtype DBusMessage = DBusMessage (ManagedPtr DBusMessage)
foreign import ccall "g_dbus_message_get_type"
    c_g_dbus_message_get_type :: IO GType

instance GObject DBusMessage where
    gobjectType = c_g_dbus_message_get_type
    

-- | Type class for types which can be safely cast to `DBusMessage`, for instance with `toDBusMessage`.
class (GObject o, O.IsDescendantOf DBusMessage o) => IsDBusMessage o
instance (GObject o, O.IsDescendantOf DBusMessage o) => IsDBusMessage o

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

-- | Cast to `DBusMessage`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDBusMessage :: (MonadIO m, IsDBusMessage o) => o -> m DBusMessage
toDBusMessage = liftIO . unsafeCastTo DBusMessage

-- | A convenience alias for `Nothing` :: `Maybe` `DBusMessage`.
noDBusMessage :: Maybe DBusMessage
noDBusMessage = Nothing

#if ENABLE_OVERLOADING
type family ResolveDBusMessageMethod (t :: Symbol) (o :: *) :: * where
    ResolveDBusMessageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDBusMessageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDBusMessageMethod "copy" o = DBusMessageCopyMethodInfo
    ResolveDBusMessageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDBusMessageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDBusMessageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDBusMessageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDBusMessageMethod "lock" o = DBusMessageLockMethodInfo
    ResolveDBusMessageMethod "newMethodErrorLiteral" o = DBusMessageNewMethodErrorLiteralMethodInfo
    ResolveDBusMessageMethod "newMethodReply" o = DBusMessageNewMethodReplyMethodInfo
    ResolveDBusMessageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDBusMessageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDBusMessageMethod "print" o = DBusMessagePrintMethodInfo
    ResolveDBusMessageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDBusMessageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDBusMessageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDBusMessageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDBusMessageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDBusMessageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDBusMessageMethod "toBlob" o = DBusMessageToBlobMethodInfo
    ResolveDBusMessageMethod "toGerror" o = DBusMessageToGerrorMethodInfo
    ResolveDBusMessageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDBusMessageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDBusMessageMethod "getArg0" o = DBusMessageGetArg0MethodInfo
    ResolveDBusMessageMethod "getBody" o = DBusMessageGetBodyMethodInfo
    ResolveDBusMessageMethod "getByteOrder" o = DBusMessageGetByteOrderMethodInfo
    ResolveDBusMessageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDBusMessageMethod "getDestination" o = DBusMessageGetDestinationMethodInfo
    ResolveDBusMessageMethod "getErrorName" o = DBusMessageGetErrorNameMethodInfo
    ResolveDBusMessageMethod "getFlags" o = DBusMessageGetFlagsMethodInfo
    ResolveDBusMessageMethod "getHeader" o = DBusMessageGetHeaderMethodInfo
    ResolveDBusMessageMethod "getHeaderFields" o = DBusMessageGetHeaderFieldsMethodInfo
    ResolveDBusMessageMethod "getInterface" o = DBusMessageGetInterfaceMethodInfo
    ResolveDBusMessageMethod "getLocked" o = DBusMessageGetLockedMethodInfo
    ResolveDBusMessageMethod "getMember" o = DBusMessageGetMemberMethodInfo
    ResolveDBusMessageMethod "getMessageType" o = DBusMessageGetMessageTypeMethodInfo
    ResolveDBusMessageMethod "getNumUnixFds" o = DBusMessageGetNumUnixFdsMethodInfo
    ResolveDBusMessageMethod "getPath" o = DBusMessageGetPathMethodInfo
    ResolveDBusMessageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDBusMessageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDBusMessageMethod "getReplySerial" o = DBusMessageGetReplySerialMethodInfo
    ResolveDBusMessageMethod "getSender" o = DBusMessageGetSenderMethodInfo
    ResolveDBusMessageMethod "getSerial" o = DBusMessageGetSerialMethodInfo
    ResolveDBusMessageMethod "getSignature" o = DBusMessageGetSignatureMethodInfo
    ResolveDBusMessageMethod "getUnixFdList" o = DBusMessageGetUnixFdListMethodInfo
    ResolveDBusMessageMethod "setBody" o = DBusMessageSetBodyMethodInfo
    ResolveDBusMessageMethod "setByteOrder" o = DBusMessageSetByteOrderMethodInfo
    ResolveDBusMessageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDBusMessageMethod "setDestination" o = DBusMessageSetDestinationMethodInfo
    ResolveDBusMessageMethod "setErrorName" o = DBusMessageSetErrorNameMethodInfo
    ResolveDBusMessageMethod "setFlags" o = DBusMessageSetFlagsMethodInfo
    ResolveDBusMessageMethod "setHeader" o = DBusMessageSetHeaderMethodInfo
    ResolveDBusMessageMethod "setInterface" o = DBusMessageSetInterfaceMethodInfo
    ResolveDBusMessageMethod "setMember" o = DBusMessageSetMemberMethodInfo
    ResolveDBusMessageMethod "setMessageType" o = DBusMessageSetMessageTypeMethodInfo
    ResolveDBusMessageMethod "setNumUnixFds" o = DBusMessageSetNumUnixFdsMethodInfo
    ResolveDBusMessageMethod "setPath" o = DBusMessageSetPathMethodInfo
    ResolveDBusMessageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDBusMessageMethod "setReplySerial" o = DBusMessageSetReplySerialMethodInfo
    ResolveDBusMessageMethod "setSender" o = DBusMessageSetSenderMethodInfo
    ResolveDBusMessageMethod "setSerial" o = DBusMessageSetSerialMethodInfo
    ResolveDBusMessageMethod "setSignature" o = DBusMessageSetSignatureMethodInfo
    ResolveDBusMessageMethod "setUnixFdList" o = DBusMessageSetUnixFdListMethodInfo
    ResolveDBusMessageMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDBusMessageMethod t DBusMessage, O.MethodInfo info DBusMessage p) => OL.IsLabel t (DBusMessage -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- VVV Prop "locked"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@locked@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' dBusMessage #locked
@
-}
getDBusMessageLocked :: (MonadIO m, IsDBusMessage o) => o -> m Bool
getDBusMessageLocked obj = liftIO $ B.Properties.getObjectPropertyBool obj "locked"

#if ENABLE_OVERLOADING
data DBusMessageLockedPropertyInfo
instance AttrInfo DBusMessageLockedPropertyInfo where
    type AttrAllowedOps DBusMessageLockedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DBusMessageLockedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DBusMessageLockedPropertyInfo = IsDBusMessage
    type AttrGetType DBusMessageLockedPropertyInfo = Bool
    type AttrLabel DBusMessageLockedPropertyInfo = "locked"
    type AttrOrigin DBusMessageLockedPropertyInfo = DBusMessage
    attrGet _ = getDBusMessageLocked
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList DBusMessage
type instance O.AttributeList DBusMessage = DBusMessageAttributeList
type DBusMessageAttributeList = ('[ '("locked", DBusMessageLockedPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
dBusMessageLocked :: AttrLabelProxy "locked"
dBusMessageLocked = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
type instance O.SignalList DBusMessage = DBusMessageSignalList
type DBusMessageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DBusMessage::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_new" g_dbus_message_new :: 
    IO (Ptr DBusMessage)

{- |
Creates a new empty 'GI.Gio.Objects.DBusMessage.DBusMessage'.

/Since: 2.26/
-}
dBusMessageNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m DBusMessage
    {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -}
dBusMessageNew  = liftIO $ do
    result <- g_dbus_message_new
    checkUnexpectedReturnNULL "dBusMessageNew" result
    result' <- (wrapObject DBusMessage) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method DBusMessage::new_from_blob
-- method type : Constructor
-- Args : [Arg {argCName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A blob representing a binary D-Bus message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "capabilities", argType = TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusCapabilityFlags describing what protocol features are supported.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_message_new_from_blob" g_dbus_message_new_from_blob :: 
    Ptr Word8 ->                            -- blob : TCArray False (-1) 1 (TBasicType TUInt8)
    Word64 ->                               -- blob_len : TBasicType TUInt64
    CUInt ->                                -- capabilities : TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr DBusMessage)

{- |
Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' from the data stored at /@blob@/. The byte
order that the message was in can be retrieved using
'GI.Gio.Objects.DBusMessage.dBusMessageGetByteOrder'.

If the /@blob@/ cannot be parsed, contains invalid fields, or contains invalid
headers, 'GI.Gio.Enums.IOErrorEnumInvalidArgument' will be returned.

/Since: 2.26/
-}
dBusMessageNewFromBlob ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ByteString
    {- ^ /@blob@/: A blob representing a binary D-Bus message. -}
    -> [Gio.Flags.DBusCapabilityFlags]
    {- ^ /@capabilities@/: A 'GI.Gio.Flags.DBusCapabilityFlags' describing what protocol features are supported. -}
    -> m DBusMessage
    {- ^ __Returns:__ A new 'GI.Gio.Objects.DBusMessage.DBusMessage' or 'Nothing' if /@error@/ is set. Free with
'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusMessageNewFromBlob blob capabilities = liftIO $ do
    let blobLen = fromIntegral $ B.length blob
    blob' <- packByteString blob
    let capabilities' = gflagsToWord capabilities
    onException (do
        result <- propagateGError $ g_dbus_message_new_from_blob blob' blobLen capabilities'
        checkUnexpectedReturnNULL "dBusMessageNewFromBlob" result
        result' <- (wrapObject DBusMessage) result
        freeMem blob'
        return result'
     ) (do
        freeMem blob'
     )

#if ENABLE_OVERLOADING
#endif

-- method DBusMessage::new_method_call
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A valid D-Bus name or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid object path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A valid D-Bus interface name or %NULL.", 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 "A valid method name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_new_method_call" g_dbus_message_new_method_call :: 
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- path : TBasicType TUTF8
    CString ->                              -- interface_ : TBasicType TUTF8
    CString ->                              -- method : TBasicType TUTF8
    IO (Ptr DBusMessage)

{- |
Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' for a method call.

/Since: 2.26/
-}
dBusMessageNewMethodCall ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    {- ^ /@name@/: A valid D-Bus name or 'Nothing'. -}
    -> T.Text
    {- ^ /@path@/: A valid object path. -}
    -> Maybe (T.Text)
    {- ^ /@interface_@/: A valid D-Bus interface name or 'Nothing'. -}
    -> T.Text
    {- ^ /@method@/: A valid method name. -}
    -> m DBusMessage
    {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -}
dBusMessageNewMethodCall name path interface_ method = liftIO $ do
    maybeName <- case name of
        Nothing -> return nullPtr
        Just jName -> do
            jName' <- textToCString jName
            return jName'
    path' <- textToCString path
    maybeInterface_ <- case interface_ of
        Nothing -> return nullPtr
        Just jInterface_ -> do
            jInterface_' <- textToCString jInterface_
            return jInterface_'
    method' <- textToCString method
    result <- g_dbus_message_new_method_call maybeName path' maybeInterface_ method'
    checkUnexpectedReturnNULL "dBusMessageNewMethodCall" result
    result' <- (wrapObject DBusMessage) result
    freeMem maybeName
    freeMem path'
    freeMem maybeInterface_
    freeMem method'
    return result'

#if ENABLE_OVERLOADING
#endif

-- method DBusMessage::new_signal
-- method type : Constructor
-- Args : [Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid object path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid D-Bus interface name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signal", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid signal name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_new_signal" g_dbus_message_new_signal :: 
    CString ->                              -- path : TBasicType TUTF8
    CString ->                              -- interface_ : TBasicType TUTF8
    CString ->                              -- signal : TBasicType TUTF8
    IO (Ptr DBusMessage)

{- |
Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' for a signal emission.

/Since: 2.26/
-}
dBusMessageNewSignal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@path@/: A valid object path. -}
    -> T.Text
    {- ^ /@interface_@/: A valid D-Bus interface name. -}
    -> T.Text
    {- ^ /@signal@/: A valid signal name. -}
    -> m DBusMessage
    {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -}
dBusMessageNewSignal path interface_ signal = liftIO $ do
    path' <- textToCString path
    interface_' <- textToCString interface_
    signal' <- textToCString signal
    result <- g_dbus_message_new_signal path' interface_' signal'
    checkUnexpectedReturnNULL "dBusMessageNewSignal" result
    result' <- (wrapObject DBusMessage) result
    freeMem path'
    freeMem interface_'
    freeMem signal'
    return result'

#if ENABLE_OVERLOADING
#endif

-- method DBusMessage::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_message_copy" g_dbus_message_copy :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr DBusMessage)

{- |
Copies /@message@/. The copy is a deep copy and the returned
'GI.Gio.Objects.DBusMessage.DBusMessage' is completely identical except that it is guaranteed
to not be locked.

This operation can fail if e.g. /@message@/ contains file descriptors
and the per-process or system-wide open files limit is reached.

/Since: 2.26/
-}
dBusMessageCopy ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m DBusMessage
    {- ^ __Returns:__ A new 'GI.Gio.Objects.DBusMessage.DBusMessage' or 'Nothing' if /@error@/ is set.
    Free with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusMessageCopy message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    onException (do
        result <- propagateGError $ g_dbus_message_copy message'
        checkUnexpectedReturnNULL "dBusMessageCopy" result
        result' <- (wrapObject DBusMessage) result
        touchManagedPtr message
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusMessageCopyMethodInfo
instance (signature ~ (m DBusMessage), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageCopyMethodInfo a signature where
    overloadedMethod _ = dBusMessageCopy

#endif

-- method DBusMessage::get_arg0
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_arg0" g_dbus_message_get_arg0 :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience to get the first item in the body of /@message@/.

/Since: 2.26/
-}
dBusMessageGetArg0 ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The string item or 'Nothing' if the first item in the body of
/@message@/ is not a string. -}
dBusMessageGetArg0 message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_arg0 message'
    checkUnexpectedReturnNULL "dBusMessageGetArg0" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetArg0MethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetArg0MethodInfo a signature where
    overloadedMethod _ = dBusMessageGetArg0

#endif

-- method DBusMessage::get_body
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_body" g_dbus_message_get_body :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO (Ptr GVariant)

{- |
Gets the body of a message.

/Since: 2.26/
-}
dBusMessageGetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m GVariant
    {- ^ __Returns:__ A 'GVariant' or 'Nothing' if the body is
empty. Do not free, it is owned by /@message@/. -}
dBusMessageGetBody message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_body message'
    checkUnexpectedReturnNULL "dBusMessageGetBody" result
    result' <- B.GVariant.newGVariantFromPtr result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetBodyMethodInfo
instance (signature ~ (m GVariant), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetBodyMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetBody

#endif

-- method DBusMessage::get_byte_order
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessageByteOrder"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_byte_order" g_dbus_message_get_byte_order :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CUInt

{- |
Gets the byte order of /@message@/.
-}
dBusMessageGetByteOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m Gio.Enums.DBusMessageByteOrder
    {- ^ __Returns:__ The byte order. -}
dBusMessageGetByteOrder message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_byte_order message'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetByteOrderMethodInfo
instance (signature ~ (m Gio.Enums.DBusMessageByteOrder), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetByteOrderMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetByteOrder

#endif

-- method DBusMessage::get_destination
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_destination" g_dbus_message_get_destination :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldDestination' header field.

/Since: 2.26/
-}
dBusMessageGetDestination ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The value. -}
dBusMessageGetDestination message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_destination message'
    checkUnexpectedReturnNULL "dBusMessageGetDestination" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetDestinationMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetDestinationMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetDestination

#endif

-- method DBusMessage::get_error_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_error_name" g_dbus_message_get_error_name :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldErrorName' header field.

/Since: 2.26/
-}
dBusMessageGetErrorName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The value. -}
dBusMessageGetErrorName message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_error_name message'
    checkUnexpectedReturnNULL "dBusMessageGetErrorName" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetErrorNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetErrorNameMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetErrorName

#endif

-- method DBusMessage::get_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessageFlags"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_flags" g_dbus_message_get_flags :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CUInt

{- |
Gets the flags for /@message@/.

/Since: 2.26/
-}
dBusMessageGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m [Gio.Flags.DBusMessageFlags]
    {- ^ __Returns:__ Flags that are set (typically values from the 'GI.Gio.Flags.DBusMessageFlags' enumeration bitwise ORed together). -}
dBusMessageGetFlags message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_flags message'
    let result' = wordToGFlags result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetFlagsMethodInfo
instance (signature ~ (m [Gio.Flags.DBusMessageFlags]), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetFlagsMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetFlags

#endif

-- method DBusMessage::get_header
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header_field", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_header" g_dbus_message_get_header :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- header_field : TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"})
    IO (Ptr GVariant)

{- |
Gets a header field on /@message@/.

The caller is responsible for checking the type of the returned 'GVariant'
matches what is expected.

/Since: 2.26/
-}
dBusMessageGetHeader ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Gio.Enums.DBusMessageHeaderField
    {- ^ /@headerField@/: A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageHeaderField' enumeration) -}
    -> m (Maybe GVariant)
    {- ^ __Returns:__ A 'GVariant' with the value if the header was found, 'Nothing'
otherwise. Do not free, it is owned by /@message@/. -}
dBusMessageGetHeader message headerField = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    let headerField' = (fromIntegral . fromEnum) headerField
    result <- g_dbus_message_get_header message' headerField'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- B.GVariant.newGVariantFromPtr result'
        return result''
    touchManagedPtr message
    return maybeResult

#if ENABLE_OVERLOADING
data DBusMessageGetHeaderMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageHeaderField -> m (Maybe GVariant)), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetHeaderMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetHeader

#endif

-- method DBusMessage::get_header_fields
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUInt8))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_header_fields" g_dbus_message_get_header_fields :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO (Ptr Word8)

{- |
Gets an array of all header fields on /@message@/ that are set.

/Since: 2.26/
-}
dBusMessageGetHeaderFields ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m ByteString
    {- ^ __Returns:__ An array of header fields
terminated by 'GI.Gio.Enums.DBusMessageHeaderFieldInvalid'.  Each element
is a @/guchar/@. Free with 'GI.GLib.Functions.free'. -}
dBusMessageGetHeaderFields message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_header_fields message'
    checkUnexpectedReturnNULL "dBusMessageGetHeaderFields" result
    result' <- unpackZeroTerminatedByteString result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetHeaderFieldsMethodInfo
instance (signature ~ (m ByteString), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetHeaderFieldsMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetHeaderFields

#endif

-- method DBusMessage::get_interface
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_interface" g_dbus_message_get_interface :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldInterface' header field.

/Since: 2.26/
-}
dBusMessageGetInterface ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The value. -}
dBusMessageGetInterface message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_interface message'
    checkUnexpectedReturnNULL "dBusMessageGetInterface" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetInterfaceMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetInterfaceMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetInterface

#endif

-- method DBusMessage::get_locked
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_locked" g_dbus_message_get_locked :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CInt

{- |
Checks whether /@message@/ is locked. To monitor changes to this
value, conncet to the 'GI.GObject.Objects.Object.Object'::@/notify/@ signal to listen for changes
on the 'GI.Gio.Objects.DBusMessage.DBusMessage':@/locked/@ property.

/Since: 2.26/
-}
dBusMessageGetLocked ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@message@/ is locked, 'False' otherwise. -}
dBusMessageGetLocked message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_locked message'
    let result' = (/= 0) result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetLockedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetLockedMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetLocked

#endif

-- method DBusMessage::get_member
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_member" g_dbus_message_get_member :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldMember' header field.

/Since: 2.26/
-}
dBusMessageGetMember ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The value. -}
dBusMessageGetMember message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_member message'
    checkUnexpectedReturnNULL "dBusMessageGetMember" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetMemberMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetMemberMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetMember

#endif

-- method DBusMessage::get_message_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessageType"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_message_type" g_dbus_message_get_message_type :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CUInt

{- |
Gets the type of /@message@/.

/Since: 2.26/
-}
dBusMessageGetMessageType ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m Gio.Enums.DBusMessageType
    {- ^ __Returns:__ A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageType' enumeration). -}
dBusMessageGetMessageType message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_message_type message'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetMessageTypeMethodInfo
instance (signature ~ (m Gio.Enums.DBusMessageType), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetMessageTypeMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetMessageType

#endif

-- method DBusMessage::get_num_unix_fds
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_num_unix_fds" g_dbus_message_get_num_unix_fds :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO Word32

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldNumUnixFds' header field.

/Since: 2.26/
-}
dBusMessageGetNumUnixFds ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m Word32
    {- ^ __Returns:__ The value. -}
dBusMessageGetNumUnixFds message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_num_unix_fds message'
    touchManagedPtr message
    return result

#if ENABLE_OVERLOADING
data DBusMessageGetNumUnixFdsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetNumUnixFdsMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetNumUnixFds

#endif

-- method DBusMessage::get_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_path" g_dbus_message_get_path :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldPath' header field.

/Since: 2.26/
-}
dBusMessageGetPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The value. -}
dBusMessageGetPath message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_path message'
    checkUnexpectedReturnNULL "dBusMessageGetPath" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetPathMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetPathMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetPath

#endif

-- method DBusMessage::get_reply_serial
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_reply_serial" g_dbus_message_get_reply_serial :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO Word32

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldReplySerial' header field.

/Since: 2.26/
-}
dBusMessageGetReplySerial ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m Word32
    {- ^ __Returns:__ The value. -}
dBusMessageGetReplySerial message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_reply_serial message'
    touchManagedPtr message
    return result

#if ENABLE_OVERLOADING
data DBusMessageGetReplySerialMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetReplySerialMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetReplySerial

#endif

-- method DBusMessage::get_sender
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_sender" g_dbus_message_get_sender :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSender' header field.

/Since: 2.26/
-}
dBusMessageGetSender ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The value. -}
dBusMessageGetSender message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_sender message'
    checkUnexpectedReturnNULL "dBusMessageGetSender" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetSenderMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetSenderMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetSender

#endif

-- method DBusMessage::get_serial
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt32)
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_serial" g_dbus_message_get_serial :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO Word32

{- |
Gets the serial for /@message@/.

/Since: 2.26/
-}
dBusMessageGetSerial ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m Word32
    {- ^ __Returns:__ A @/guint32/@. -}
dBusMessageGetSerial message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_serial message'
    touchManagedPtr message
    return result

#if ENABLE_OVERLOADING
data DBusMessageGetSerialMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetSerialMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetSerial

#endif

-- method DBusMessage::get_signature
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", 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 "g_dbus_message_get_signature" g_dbus_message_get_signature :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO CString

{- |
Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSignature' header field.

/Since: 2.26/
-}
dBusMessageGetSignature ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m T.Text
    {- ^ __Returns:__ The value. -}
dBusMessageGetSignature message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_signature message'
    checkUnexpectedReturnNULL "dBusMessageGetSignature" result
    result' <- cstringToText result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetSignatureMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetSignatureMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetSignature

#endif

-- method DBusMessage::get_unix_fd_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixFDList"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_get_unix_fd_list" g_dbus_message_get_unix_fd_list :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO (Ptr Gio.UnixFDList.UnixFDList)

{- |
Gets the UNIX file descriptors associated with /@message@/, if any.

This method is only available on UNIX.

/Since: 2.26/
-}
dBusMessageGetUnixFdList ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m Gio.UnixFDList.UnixFDList
    {- ^ __Returns:__ A 'GI.Gio.Objects.UnixFDList.UnixFDList' or 'Nothing' if no file descriptors are
associated. Do not free, this object is owned by /@message@/. -}
dBusMessageGetUnixFdList message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_get_unix_fd_list message'
    checkUnexpectedReturnNULL "dBusMessageGetUnixFdList" result
    result' <- (newObject Gio.UnixFDList.UnixFDList) result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessageGetUnixFdListMethodInfo
instance (signature ~ (m Gio.UnixFDList.UnixFDList), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetUnixFdListMethodInfo a signature where
    overloadedMethod _ = dBusMessageGetUnixFdList

#endif

-- method DBusMessage::lock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_lock" g_dbus_message_lock :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO ()

{- |
If /@message@/ is locked, does nothing. Otherwise locks the message.

/Since: 2.26/
-}
dBusMessageLock ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m ()
dBusMessageLock message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    g_dbus_message_lock message'
    touchManagedPtr message
    return ()

#if ENABLE_OVERLOADING
data DBusMessageLockMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageLockMethodInfo a signature where
    overloadedMethod _ = dBusMessageLock

#endif

-- method DBusMessage::new_method_error_literal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "method_call_message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to\ncreate a reply message to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid D-Bus error name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The D-Bus error message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_new_method_error_literal" g_dbus_message_new_method_error_literal :: 
    Ptr DBusMessage ->                      -- method_call_message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- error_name : TBasicType TUTF8
    CString ->                              -- error_message : TBasicType TUTF8
    IO (Ptr DBusMessage)

{- |
Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' that is an error reply to /@methodCallMessage@/.

/Since: 2.26/
-}
dBusMessageNewMethodErrorLiteral ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@methodCallMessage@/: A message of type 'GI.Gio.Enums.DBusMessageTypeMethodCall' to
create a reply message to. -}
    -> T.Text
    {- ^ /@errorName@/: A valid D-Bus error name. -}
    -> T.Text
    {- ^ /@errorMessage@/: The D-Bus error message. -}
    -> m DBusMessage
    {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -}
dBusMessageNewMethodErrorLiteral methodCallMessage errorName errorMessage = liftIO $ do
    methodCallMessage' <- unsafeManagedPtrCastPtr methodCallMessage
    errorName' <- textToCString errorName
    errorMessage' <- textToCString errorMessage
    result <- g_dbus_message_new_method_error_literal methodCallMessage' errorName' errorMessage'
    checkUnexpectedReturnNULL "dBusMessageNewMethodErrorLiteral" result
    result' <- (wrapObject DBusMessage) result
    touchManagedPtr methodCallMessage
    freeMem errorName'
    freeMem errorMessage'
    return result'

#if ENABLE_OVERLOADING
data DBusMessageNewMethodErrorLiteralMethodInfo
instance (signature ~ (T.Text -> T.Text -> m DBusMessage), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageNewMethodErrorLiteralMethodInfo a signature where
    overloadedMethod _ = dBusMessageNewMethodErrorLiteral

#endif

-- method DBusMessage::new_method_reply
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "method_call_message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to\ncreate a reply message to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_new_method_reply" g_dbus_message_new_method_reply :: 
    Ptr DBusMessage ->                      -- method_call_message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    IO (Ptr DBusMessage)

{- |
Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' that is a reply to /@methodCallMessage@/.

/Since: 2.26/
-}
dBusMessageNewMethodReply ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@methodCallMessage@/: A message of type 'GI.Gio.Enums.DBusMessageTypeMethodCall' to
create a reply message to. -}
    -> m DBusMessage
    {- ^ __Returns:__ 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -}
dBusMessageNewMethodReply methodCallMessage = liftIO $ do
    methodCallMessage' <- unsafeManagedPtrCastPtr methodCallMessage
    result <- g_dbus_message_new_method_reply methodCallMessage'
    checkUnexpectedReturnNULL "dBusMessageNewMethodReply" result
    result' <- (wrapObject DBusMessage) result
    touchManagedPtr methodCallMessage
    return result'

#if ENABLE_OVERLOADING
data DBusMessageNewMethodReplyMethodInfo
instance (signature ~ (m DBusMessage), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageNewMethodReplyMethodInfo a signature where
    overloadedMethod _ = dBusMessageNewMethodReply

#endif

-- method DBusMessage::print
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "indent", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Indentation level.", 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 "g_dbus_message_print" g_dbus_message_print :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Word32 ->                               -- indent : TBasicType TUInt
    IO CString

{- |
Produces a human-readable multi-line description of /@message@/.

The contents of the description has no ABI guarantees, the contents
and formatting is subject to change at any time. Typical output
looks something like this:
>
>Flags:   none
>Version: 0
>Serial:  4
>Headers:
>  path -> objectpath '/org/gtk/GDBus/TestObject'
>  interface -> 'org.gtk.GDBus.TestInterface'
>  member -> 'GimmeStdout'
>  destination -> ':1.146'
>Body: ()
>UNIX File Descriptors:
>  (none)

or
>
>Flags:   no-reply-expected
>Version: 0
>Serial:  477
>Headers:
>  reply-serial -> uint32 4
>  destination -> ':1.159'
>  sender -> ':1.146'
>  num-unix-fds -> uint32 1
>Body: ()
>UNIX File Descriptors:
>  fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635


/Since: 2.26/
-}
dBusMessagePrint ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Word32
    {- ^ /@indent@/: Indentation level. -}
    -> m T.Text
    {- ^ __Returns:__ A string that should be freed with 'GI.GLib.Functions.free'. -}
dBusMessagePrint message indent = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    result <- g_dbus_message_print message' indent
    checkUnexpectedReturnNULL "dBusMessagePrint" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr message
    return result'

#if ENABLE_OVERLOADING
data DBusMessagePrintMethodInfo
instance (signature ~ (Word32 -> m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessagePrintMethodInfo a signature where
    overloadedMethod _ = dBusMessagePrint

#endif

-- method DBusMessage::set_body
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "body", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Either %NULL or a #GVariant that is a tuple.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_set_body" g_dbus_message_set_body :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Ptr GVariant ->                         -- body : TVariant
    IO ()

{- |
Sets the body /@message@/. As a side-effect the
'GI.Gio.Enums.DBusMessageHeaderFieldSignature' header field is set to the
type string of /@body@/ (or cleared if /@body@/ is 'Nothing').

If /@body@/ is floating, /@message@/ assumes ownership of /@body@/.

/Since: 2.26/
-}
dBusMessageSetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> GVariant
    {- ^ /@body@/: Either 'Nothing' or a 'GVariant' that is a tuple. -}
    -> m ()
dBusMessageSetBody message body = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    body' <- unsafeManagedPtrGetPtr body
    g_dbus_message_set_body message' body'
    touchManagedPtr message
    touchManagedPtr body
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetBodyMethodInfo
instance (signature ~ (GVariant -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetBodyMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetBody

#endif

-- method DBusMessage::set_byte_order
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "byte_order", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageByteOrder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The byte order.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_set_byte_order" g_dbus_message_set_byte_order :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- byte_order : TInterface (Name {namespace = "Gio", name = "DBusMessageByteOrder"})
    IO ()

{- |
Sets the byte order of /@message@/.
-}
dBusMessageSetByteOrder ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Gio.Enums.DBusMessageByteOrder
    {- ^ /@byteOrder@/: The byte order. -}
    -> m ()
dBusMessageSetByteOrder message byteOrder = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    let byteOrder' = (fromIntegral . fromEnum) byteOrder
    g_dbus_message_set_byte_order message' byteOrder'
    touchManagedPtr message
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetByteOrderMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageByteOrder -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetByteOrderMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetByteOrder

#endif

-- method DBusMessage::set_destination
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The 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 "g_dbus_message_set_destination" g_dbus_message_set_destination :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldDestination' header field.

/Since: 2.26/
-}
dBusMessageSetDestination ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> T.Text
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetDestination message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    value' <- textToCString value
    g_dbus_message_set_destination message' value'
    touchManagedPtr message
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetDestinationMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetDestinationMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetDestination

#endif

-- method DBusMessage::set_error_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The 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 "g_dbus_message_set_error_name" g_dbus_message_set_error_name :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldErrorName' header field.

/Since: 2.26/
-}
dBusMessageSetErrorName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> T.Text
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetErrorName message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    value' <- textToCString value
    g_dbus_message_set_error_name message' value'
    touchManagedPtr message
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetErrorNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetErrorNameMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetErrorName

#endif

-- method DBusMessage::set_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags for @message that are set (typically values from the #GDBusMessageFlags\nenumeration bitwise ORed together).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_set_flags" g_dbus_message_set_flags :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusMessageFlags"})
    IO ()

{- |
Sets the flags to set on /@message@/.

/Since: 2.26/
-}
dBusMessageSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> [Gio.Flags.DBusMessageFlags]
    {- ^ /@flags@/: Flags for /@message@/ that are set (typically values from the 'GI.Gio.Flags.DBusMessageFlags'
enumeration bitwise ORed together). -}
    -> m ()
dBusMessageSetFlags message flags = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    let flags' = gflagsToWord flags
    g_dbus_message_set_flags message' flags'
    touchManagedPtr message
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetFlagsMethodInfo
instance (signature ~ ([Gio.Flags.DBusMessageFlags] -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetFlagsMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetFlags

#endif

-- method DBusMessage::set_header
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header_field", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GVariant to set the header field or %NULL to clear the header field.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_set_header" g_dbus_message_set_header :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- header_field : TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"})
    Ptr GVariant ->                         -- value : TVariant
    IO ()

{- |
Sets a header field on /@message@/.

If /@value@/ is floating, /@message@/ assumes ownership of /@value@/.

/Since: 2.26/
-}
dBusMessageSetHeader ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Gio.Enums.DBusMessageHeaderField
    {- ^ /@headerField@/: A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageHeaderField' enumeration) -}
    -> Maybe (GVariant)
    {- ^ /@value@/: A 'GVariant' to set the header field or 'Nothing' to clear the header field. -}
    -> m ()
dBusMessageSetHeader message headerField value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    let headerField' = (fromIntegral . fromEnum) headerField
    maybeValue <- case value of
        Nothing -> return nullPtr
        Just jValue -> do
            jValue' <- unsafeManagedPtrGetPtr jValue
            return jValue'
    g_dbus_message_set_header message' headerField' maybeValue
    touchManagedPtr message
    whenJust value touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetHeaderMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageHeaderField -> Maybe (GVariant) -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetHeaderMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetHeader

#endif

-- method DBusMessage::set_interface
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The 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 "g_dbus_message_set_interface" g_dbus_message_set_interface :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldInterface' header field.

/Since: 2.26/
-}
dBusMessageSetInterface ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> T.Text
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetInterface message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    value' <- textToCString value
    g_dbus_message_set_interface message' value'
    touchManagedPtr message
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetInterfaceMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetInterfaceMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetInterface

#endif

-- method DBusMessage::set_member
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The 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 "g_dbus_message_set_member" g_dbus_message_set_member :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldMember' header field.

/Since: 2.26/
-}
dBusMessageSetMember ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> T.Text
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetMember message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    value' <- textToCString value
    g_dbus_message_set_member message' value'
    touchManagedPtr message
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetMemberMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetMemberMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetMember

#endif

-- method DBusMessage::set_message_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_set_message_type" g_dbus_message_set_message_type :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- type : TInterface (Name {namespace = "Gio", name = "DBusMessageType"})
    IO ()

{- |
Sets /@message@/ to be of /@type@/.

/Since: 2.26/
-}
dBusMessageSetMessageType ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Gio.Enums.DBusMessageType
    {- ^ /@type@/: A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageType' enumeration). -}
    -> m ()
dBusMessageSetMessageType message type_ = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    let type_' = (fromIntegral . fromEnum) type_
    g_dbus_message_set_message_type message' type_'
    touchManagedPtr message
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetMessageTypeMethodInfo
instance (signature ~ (Gio.Enums.DBusMessageType -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetMessageTypeMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetMessageType

#endif

-- method DBusMessage::set_num_unix_fds
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, 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 "g_dbus_message_set_num_unix_fds" g_dbus_message_set_num_unix_fds :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Word32 ->                               -- value : TBasicType TUInt32
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldNumUnixFds' header field.

/Since: 2.26/
-}
dBusMessageSetNumUnixFds ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Word32
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetNumUnixFds message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    g_dbus_message_set_num_unix_fds message' value
    touchManagedPtr message
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetNumUnixFdsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetNumUnixFdsMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetNumUnixFds

#endif

-- method DBusMessage::set_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The 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 "g_dbus_message_set_path" g_dbus_message_set_path :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldPath' header field.

/Since: 2.26/
-}
dBusMessageSetPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> T.Text
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetPath message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    value' <- textToCString value
    g_dbus_message_set_path message' value'
    touchManagedPtr message
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetPathMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetPathMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetPath

#endif

-- method DBusMessage::set_reply_serial
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, 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 "g_dbus_message_set_reply_serial" g_dbus_message_set_reply_serial :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Word32 ->                               -- value : TBasicType TUInt32
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldReplySerial' header field.

/Since: 2.26/
-}
dBusMessageSetReplySerial ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Word32
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetReplySerial message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    g_dbus_message_set_reply_serial message' value
    touchManagedPtr message
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetReplySerialMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetReplySerialMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetReplySerial

#endif

-- method DBusMessage::set_sender
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The 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 "g_dbus_message_set_sender" g_dbus_message_set_sender :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSender' header field.

/Since: 2.26/
-}
dBusMessageSetSender ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> T.Text
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetSender message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    value' <- textToCString value
    g_dbus_message_set_sender message' value'
    touchManagedPtr message
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetSenderMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetSenderMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetSender

#endif

-- method DBusMessage::set_serial
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "serial", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #guint32.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_message_set_serial" g_dbus_message_set_serial :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Word32 ->                               -- serial : TBasicType TUInt32
    IO ()

{- |
Sets the serial for /@message@/.

/Since: 2.26/
-}
dBusMessageSetSerial ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Word32
    {- ^ /@serial@/: A @/guint32/@. -}
    -> m ()
dBusMessageSetSerial message serial = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    g_dbus_message_set_serial message' serial
    touchManagedPtr message
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetSerialMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetSerialMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetSerial

#endif

-- method DBusMessage::set_signature
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The 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 "g_dbus_message_set_signature" g_dbus_message_set_signature :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSignature' header field.

/Since: 2.26/
-}
dBusMessageSetSignature ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> T.Text
    {- ^ /@value@/: The value to set. -}
    -> m ()
dBusMessageSetSignature message value = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    value' <- textToCString value
    g_dbus_message_set_signature message' value'
    touchManagedPtr message
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetSignatureMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetSignatureMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetSignature

#endif

-- method DBusMessage::set_unix_fd_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd_list", argType = TInterface (Name {namespace = "Gio", name = "UnixFDList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GUnixFDList 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 "g_dbus_message_set_unix_fd_list" g_dbus_message_set_unix_fd_list :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Ptr Gio.UnixFDList.UnixFDList ->        -- fd_list : TInterface (Name {namespace = "Gio", name = "UnixFDList"})
    IO ()

{- |
Sets the UNIX file descriptors associated with /@message@/. As a
side-effect the 'GI.Gio.Enums.DBusMessageHeaderFieldNumUnixFds' header
field is set to the number of fds in /@fdList@/ (or cleared if
/@fdList@/ is 'Nothing').

This method is only available on UNIX.

/Since: 2.26/
-}
dBusMessageSetUnixFdList ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a, Gio.UnixFDList.IsUnixFDList b) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> Maybe (b)
    {- ^ /@fdList@/: A 'GI.Gio.Objects.UnixFDList.UnixFDList' or 'Nothing'. -}
    -> m ()
dBusMessageSetUnixFdList message fdList = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    maybeFdList <- case fdList of
        Nothing -> return nullPtr
        Just jFdList -> do
            jFdList' <- unsafeManagedPtrCastPtr jFdList
            return jFdList'
    g_dbus_message_set_unix_fd_list message' maybeFdList
    touchManagedPtr message
    whenJust fdList touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data DBusMessageSetUnixFdListMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDBusMessage a, Gio.UnixFDList.IsUnixFDList b) => O.MethodInfo DBusMessageSetUnixFdListMethodInfo a signature where
    overloadedMethod _ = dBusMessageSetUnixFdList

#endif

-- method DBusMessage::to_blob
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for size of generated blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "capabilities", argType = TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusCapabilityFlags describing what protocol features are supported.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for size of generated blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Just (TCArray False (-1) 1 (TBasicType TUInt8))
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_message_to_blob" g_dbus_message_to_blob :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Ptr Word64 ->                           -- out_size : TBasicType TUInt64
    CUInt ->                                -- capabilities : TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Word8)

{- |
Serializes /@message@/ to a blob. The byte order returned by
'GI.Gio.Objects.DBusMessage.dBusMessageGetByteOrder' will be used.

/Since: 2.26/
-}
dBusMessageToBlob ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> [Gio.Flags.DBusCapabilityFlags]
    {- ^ /@capabilities@/: A 'GI.Gio.Flags.DBusCapabilityFlags' describing what protocol features are supported. -}
    -> m ByteString
    {- ^ __Returns:__ A pointer to a
valid binary D-Bus message of /@outSize@/ bytes generated by /@message@/
or 'Nothing' if /@error@/ is set. Free with 'GI.GLib.Functions.free'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusMessageToBlob message capabilities = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    outSize <- allocMem :: IO (Ptr Word64)
    let capabilities' = gflagsToWord capabilities
    onException (do
        result <- propagateGError $ g_dbus_message_to_blob message' outSize capabilities'
        outSize' <- peek outSize
        checkUnexpectedReturnNULL "dBusMessageToBlob" result
        result' <- (unpackByteStringWithLength outSize') result
        freeMem result
        touchManagedPtr message
        freeMem outSize
        return result'
     ) (do
        freeMem outSize
     )

#if ENABLE_OVERLOADING
data DBusMessageToBlobMethodInfo
instance (signature ~ ([Gio.Flags.DBusCapabilityFlags] -> m ByteString), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageToBlobMethodInfo a signature where
    overloadedMethod _ = dBusMessageToBlob

#endif

-- method DBusMessage::to_gerror
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_message_to_gerror" g_dbus_message_to_gerror :: 
    Ptr DBusMessage ->                      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
If /@message@/ is not of type 'GI.Gio.Enums.DBusMessageTypeError' does
nothing and returns 'False'.

Otherwise this method encodes the error in /@message@/ as a 'GError'
using @/g_dbus_error_set_dbus_error()/@ using the information in the
'GI.Gio.Enums.DBusMessageHeaderFieldErrorName' header field of /@message@/ as
well as the first string item in /@message@/\'s body.

/Since: 2.26/
-}
dBusMessageToGerror ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) =>
    a
    {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusMessageToGerror message = liftIO $ do
    message' <- unsafeManagedPtrCastPtr message
    onException (do
        _ <- propagateGError $ g_dbus_message_to_gerror message'
        touchManagedPtr message
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusMessageToGerrorMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageToGerrorMethodInfo a signature where
    overloadedMethod _ = dBusMessageToGerror

#endif

-- method DBusMessage::bytes_needed
-- method type : MemberFunction
-- Args : [Arg {argCName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A blob representing a binary D-Bus message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob (must be at least 16).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob (must be at least 16).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Just (TBasicType TInt64)
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_message_bytes_needed" g_dbus_message_bytes_needed :: 
    Ptr Word8 ->                            -- blob : TCArray False (-1) 1 (TBasicType TUInt8)
    Word64 ->                               -- blob_len : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO Int64

{- |
Utility function to calculate how many bytes are needed to
completely deserialize the D-Bus message stored at /@blob@/.

/Since: 2.26/
-}
dBusMessageBytesNeeded ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ByteString
    {- ^ /@blob@/: A blob representing a binary D-Bus message. -}
    -> m Int64
    {- ^ __Returns:__ Number of bytes needed or -1 if /@error@/ is set (e.g. if
/@blob@/ contains invalid data or not enough data is available to
determine the size). /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusMessageBytesNeeded blob = liftIO $ do
    let blobLen = fromIntegral $ B.length blob
    blob' <- packByteString blob
    onException (do
        result <- propagateGError $ g_dbus_message_bytes_needed blob' blobLen
        freeMem blob'
        return result
     ) (do
        freeMem blob'
     )

#if ENABLE_OVERLOADING
#endif