gi-gio-2.0.20: GI/Gio/Objects/DBusConnection.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)

The 'GI.Gio.Objects.DBusConnection.DBusConnection' type is used for D-Bus connections to remote
peers such as a message buses. It is a low-level API that offers a
lot of flexibility. For instance, it lets you establish a connection
over any transport that can by represented as an 'GI.Gio.Objects.IOStream.IOStream'.

This class is rarely used directly in D-Bus clients. If you are writing
a D-Bus client, it is often easier to use the @/g_bus_own_name()/@,
@/g_bus_watch_name()/@ or 'GI.Gio.Objects.DBusProxy.dBusProxyNewForBus' APIs.

As an exception to the usual GLib rule that a particular object must not
be used by two threads at the same time, 'GI.Gio.Objects.DBusConnection.DBusConnection'\'s methods may be
called from any thread. This is so that 'GI.Gio.Functions.busGet' and 'GI.Gio.Functions.busGetSync'
can safely return the same 'GI.Gio.Objects.DBusConnection.DBusConnection' when called from any thread.

Most of the ways to obtain a 'GI.Gio.Objects.DBusConnection.DBusConnection' automatically initialize it
(i.e. connect to D-Bus): for instance, 'GI.Gio.Objects.DBusConnection.dBusConnectionNew' and
'GI.Gio.Functions.busGet', and the synchronous versions of those methods, give you an
initialized connection. Language bindings for GIO should use
@/g_initable_new()/@ or @/g_async_initable_new_async()/@, which also initialize the
connection.

If you construct an uninitialized 'GI.Gio.Objects.DBusConnection.DBusConnection', such as via
@/g_object_new()/@, you must initialize it via 'GI.Gio.Interfaces.Initable.initableInit' or
'GI.Gio.Interfaces.AsyncInitable.asyncInitableInitAsync' before using its methods or properties.
Calling methods or accessing properties on a 'GI.Gio.Objects.DBusConnection.DBusConnection' that has not
completed initialization successfully is considered to be invalid, and leads
to undefined behaviour. In particular, if initialization fails with a
'GError', the only valid thing you can do with that 'GI.Gio.Objects.DBusConnection.DBusConnection' is to
free it with 'GI.GObject.Objects.Object.objectUnref'.

## An example D-Bus server # {@/gdbus/@-server}

Here is an example for a D-Bus server:
<https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-server.c gdbus-example-server.c>

## An example for exporting a subtree # {@/gdbus/@-subtree-server}

Here is an example for exporting a subtree:
<https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-subtree.c gdbus-example-subtree.c>

## An example for file descriptor passing # {@/gdbus/@-unix-fd-client}

Here is an example for passing UNIX file descriptors:
<https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-unix-fd-client.c gdbus-unix-fd-client.c>

## An example for exporting a GObject # {@/gdbus/@-export}

Here is an example for exporting a 'GI.GObject.Objects.Object.Object':
<https://git.gnome.org/browse/glib/tree/gio/tests/gdbus-example-export.c gdbus-example-export.c>

/Since: 2.26/
-}

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

module GI.Gio.Objects.DBusConnection
    ( 

-- * Exported types
    DBusConnection(..)                      ,
    IsDBusConnection                        ,
    toDBusConnection                        ,
    noDBusConnection                        ,


 -- * Methods
-- ** addFilter #method:addFilter#

#if ENABLE_OVERLOADING
    DBusConnectionAddFilterMethodInfo       ,
#endif
    dBusConnectionAddFilter                 ,


-- ** call #method:call#

#if ENABLE_OVERLOADING
    DBusConnectionCallMethodInfo            ,
#endif
    dBusConnectionCall                      ,


-- ** callFinish #method:callFinish#

#if ENABLE_OVERLOADING
    DBusConnectionCallFinishMethodInfo      ,
#endif
    dBusConnectionCallFinish                ,


-- ** callSync #method:callSync#

#if ENABLE_OVERLOADING
    DBusConnectionCallSyncMethodInfo        ,
#endif
    dBusConnectionCallSync                  ,


-- ** callWithUnixFdList #method:callWithUnixFdList#

#if ENABLE_OVERLOADING
    DBusConnectionCallWithUnixFdListMethodInfo,
#endif
    dBusConnectionCallWithUnixFdList        ,


-- ** callWithUnixFdListFinish #method:callWithUnixFdListFinish#

#if ENABLE_OVERLOADING
    DBusConnectionCallWithUnixFdListFinishMethodInfo,
#endif
    dBusConnectionCallWithUnixFdListFinish  ,


-- ** callWithUnixFdListSync #method:callWithUnixFdListSync#

#if ENABLE_OVERLOADING
    DBusConnectionCallWithUnixFdListSyncMethodInfo,
#endif
    dBusConnectionCallWithUnixFdListSync    ,


-- ** close #method:close#

#if ENABLE_OVERLOADING
    DBusConnectionCloseMethodInfo           ,
#endif
    dBusConnectionClose                     ,


-- ** closeFinish #method:closeFinish#

#if ENABLE_OVERLOADING
    DBusConnectionCloseFinishMethodInfo     ,
#endif
    dBusConnectionCloseFinish               ,


-- ** closeSync #method:closeSync#

#if ENABLE_OVERLOADING
    DBusConnectionCloseSyncMethodInfo       ,
#endif
    dBusConnectionCloseSync                 ,


-- ** emitSignal #method:emitSignal#

#if ENABLE_OVERLOADING
    DBusConnectionEmitSignalMethodInfo      ,
#endif
    dBusConnectionEmitSignal                ,


-- ** exportActionGroup #method:exportActionGroup#

#if ENABLE_OVERLOADING
    DBusConnectionExportActionGroupMethodInfo,
#endif
    dBusConnectionExportActionGroup         ,


-- ** exportMenuModel #method:exportMenuModel#

#if ENABLE_OVERLOADING
    DBusConnectionExportMenuModelMethodInfo ,
#endif
    dBusConnectionExportMenuModel           ,


-- ** flush #method:flush#

#if ENABLE_OVERLOADING
    DBusConnectionFlushMethodInfo           ,
#endif
    dBusConnectionFlush                     ,


-- ** flushFinish #method:flushFinish#

#if ENABLE_OVERLOADING
    DBusConnectionFlushFinishMethodInfo     ,
#endif
    dBusConnectionFlushFinish               ,


-- ** flushSync #method:flushSync#

#if ENABLE_OVERLOADING
    DBusConnectionFlushSyncMethodInfo       ,
#endif
    dBusConnectionFlushSync                 ,


-- ** getCapabilities #method:getCapabilities#

#if ENABLE_OVERLOADING
    DBusConnectionGetCapabilitiesMethodInfo ,
#endif
    dBusConnectionGetCapabilities           ,


-- ** getExitOnClose #method:getExitOnClose#

#if ENABLE_OVERLOADING
    DBusConnectionGetExitOnCloseMethodInfo  ,
#endif
    dBusConnectionGetExitOnClose            ,


-- ** getFlags #method:getFlags#

#if ENABLE_OVERLOADING
    DBusConnectionGetFlagsMethodInfo        ,
#endif
    dBusConnectionGetFlags                  ,


-- ** getGuid #method:getGuid#

#if ENABLE_OVERLOADING
    DBusConnectionGetGuidMethodInfo         ,
#endif
    dBusConnectionGetGuid                   ,


-- ** getLastSerial #method:getLastSerial#

#if ENABLE_OVERLOADING
    DBusConnectionGetLastSerialMethodInfo   ,
#endif
    dBusConnectionGetLastSerial             ,


-- ** getPeerCredentials #method:getPeerCredentials#

#if ENABLE_OVERLOADING
    DBusConnectionGetPeerCredentialsMethodInfo,
#endif
    dBusConnectionGetPeerCredentials        ,


-- ** getStream #method:getStream#

#if ENABLE_OVERLOADING
    DBusConnectionGetStreamMethodInfo       ,
#endif
    dBusConnectionGetStream                 ,


-- ** getUniqueName #method:getUniqueName#

#if ENABLE_OVERLOADING
    DBusConnectionGetUniqueNameMethodInfo   ,
#endif
    dBusConnectionGetUniqueName             ,


-- ** isClosed #method:isClosed#

#if ENABLE_OVERLOADING
    DBusConnectionIsClosedMethodInfo        ,
#endif
    dBusConnectionIsClosed                  ,


-- ** new #method:new#

    dBusConnectionNew                       ,


-- ** newFinish #method:newFinish#

    dBusConnectionNewFinish                 ,


-- ** newForAddress #method:newForAddress#

    dBusConnectionNewForAddress             ,


-- ** newForAddressFinish #method:newForAddressFinish#

    dBusConnectionNewForAddressFinish       ,


-- ** newForAddressSync #method:newForAddressSync#

    dBusConnectionNewForAddressSync         ,


-- ** newSync #method:newSync#

    dBusConnectionNewSync                   ,


-- ** registerObject #method:registerObject#

#if ENABLE_OVERLOADING
    DBusConnectionRegisterObjectMethodInfo  ,
#endif
    dBusConnectionRegisterObject            ,


-- ** registerSubtree #method:registerSubtree#

#if ENABLE_OVERLOADING
    DBusConnectionRegisterSubtreeMethodInfo ,
#endif
    dBusConnectionRegisterSubtree           ,


-- ** removeFilter #method:removeFilter#

#if ENABLE_OVERLOADING
    DBusConnectionRemoveFilterMethodInfo    ,
#endif
    dBusConnectionRemoveFilter              ,


-- ** sendMessage #method:sendMessage#

#if ENABLE_OVERLOADING
    DBusConnectionSendMessageMethodInfo     ,
#endif
    dBusConnectionSendMessage               ,


-- ** sendMessageWithReply #method:sendMessageWithReply#

#if ENABLE_OVERLOADING
    DBusConnectionSendMessageWithReplyMethodInfo,
#endif
    dBusConnectionSendMessageWithReply      ,


-- ** sendMessageWithReplyFinish #method:sendMessageWithReplyFinish#

#if ENABLE_OVERLOADING
    DBusConnectionSendMessageWithReplyFinishMethodInfo,
#endif
    dBusConnectionSendMessageWithReplyFinish,


-- ** sendMessageWithReplySync #method:sendMessageWithReplySync#

#if ENABLE_OVERLOADING
    DBusConnectionSendMessageWithReplySyncMethodInfo,
#endif
    dBusConnectionSendMessageWithReplySync  ,


-- ** setExitOnClose #method:setExitOnClose#

#if ENABLE_OVERLOADING
    DBusConnectionSetExitOnCloseMethodInfo  ,
#endif
    dBusConnectionSetExitOnClose            ,


-- ** signalSubscribe #method:signalSubscribe#

#if ENABLE_OVERLOADING
    DBusConnectionSignalSubscribeMethodInfo ,
#endif
    dBusConnectionSignalSubscribe           ,


-- ** signalUnsubscribe #method:signalUnsubscribe#

#if ENABLE_OVERLOADING
    DBusConnectionSignalUnsubscribeMethodInfo,
#endif
    dBusConnectionSignalUnsubscribe         ,


-- ** startMessageProcessing #method:startMessageProcessing#

#if ENABLE_OVERLOADING
    DBusConnectionStartMessageProcessingMethodInfo,
#endif
    dBusConnectionStartMessageProcessing    ,


-- ** unexportActionGroup #method:unexportActionGroup#

#if ENABLE_OVERLOADING
    DBusConnectionUnexportActionGroupMethodInfo,
#endif
    dBusConnectionUnexportActionGroup       ,


-- ** unexportMenuModel #method:unexportMenuModel#

#if ENABLE_OVERLOADING
    DBusConnectionUnexportMenuModelMethodInfo,
#endif
    dBusConnectionUnexportMenuModel         ,


-- ** unregisterObject #method:unregisterObject#

#if ENABLE_OVERLOADING
    DBusConnectionUnregisterObjectMethodInfo,
#endif
    dBusConnectionUnregisterObject          ,


-- ** unregisterSubtree #method:unregisterSubtree#

#if ENABLE_OVERLOADING
    DBusConnectionUnregisterSubtreeMethodInfo,
#endif
    dBusConnectionUnregisterSubtree         ,




 -- * Properties
-- ** address #attr:address#
{- | A D-Bus address specifying potential endpoints that can be used
when establishing the connection.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionAddressPropertyInfo       ,
#endif
    constructDBusConnectionAddress          ,
#if ENABLE_OVERLOADING
    dBusConnectionAddress                   ,
#endif


-- ** authenticationObserver #attr:authenticationObserver#
{- | A 'GI.Gio.Objects.DBusAuthObserver.DBusAuthObserver' object to assist in the authentication process or 'Nothing'.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionAuthenticationObserverPropertyInfo,
#endif
    constructDBusConnectionAuthenticationObserver,
#if ENABLE_OVERLOADING
    dBusConnectionAuthenticationObserver    ,
#endif


-- ** capabilities #attr:capabilities#
{- | Flags from the 'GI.Gio.Flags.DBusCapabilityFlags' enumeration
representing connection features negotiated with the other peer.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionCapabilitiesPropertyInfo  ,
#endif
#if ENABLE_OVERLOADING
    dBusConnectionCapabilities              ,
#endif
    getDBusConnectionCapabilities           ,


-- ** closed #attr:closed#
{- | A boolean specifying whether the connection has been closed.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionClosedPropertyInfo        ,
#endif
#if ENABLE_OVERLOADING
    dBusConnectionClosed                    ,
#endif
    getDBusConnectionClosed                 ,


-- ** exitOnClose #attr:exitOnClose#
{- | A boolean specifying whether the process will be terminated (by
calling @raise(SIGTERM)@) if the connection is closed by the
remote peer.

Note that 'GI.Gio.Objects.DBusConnection.DBusConnection' objects returned by 'GI.Gio.Functions.busGetFinish'
and 'GI.Gio.Functions.busGetSync' will (usually) have this property set to 'True'.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionExitOnClosePropertyInfo   ,
#endif
    constructDBusConnectionExitOnClose      ,
#if ENABLE_OVERLOADING
    dBusConnectionExitOnClose               ,
#endif
    getDBusConnectionExitOnClose            ,
    setDBusConnectionExitOnClose            ,


-- ** flags #attr:flags#
{- | Flags from the 'GI.Gio.Flags.DBusConnectionFlags' enumeration.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionFlagsPropertyInfo         ,
#endif
    constructDBusConnectionFlags            ,
#if ENABLE_OVERLOADING
    dBusConnectionFlags                     ,
#endif
    getDBusConnectionFlags                  ,


-- ** guid #attr:guid#
{- | The GUID of the peer performing the role of server when
authenticating.

If you are constructing a 'GI.Gio.Objects.DBusConnection.DBusConnection' and pass
'GI.Gio.Flags.DBusConnectionFlagsAuthenticationServer' in the
'GI.Gio.Objects.DBusConnection.DBusConnection':@/flags/@ property then you MUST also set this
property to a valid guid.

If you are constructing a 'GI.Gio.Objects.DBusConnection.DBusConnection' and pass
'GI.Gio.Flags.DBusConnectionFlagsAuthenticationClient' in the
'GI.Gio.Objects.DBusConnection.DBusConnection':@/flags/@ property you will be able to read the GUID
of the other peer here after the connection has been successfully
initialized.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionGuidPropertyInfo          ,
#endif
    constructDBusConnectionGuid             ,
#if ENABLE_OVERLOADING
    dBusConnectionGuid                      ,
#endif
    getDBusConnectionGuid                   ,


-- ** stream #attr:stream#
{- | The underlying 'GI.Gio.Objects.IOStream.IOStream' used for I\/O.

If this is passed on construction and is a 'GI.Gio.Objects.SocketConnection.SocketConnection',
then the corresponding 'GI.Gio.Objects.Socket.Socket' will be put into non-blocking mode.

While the 'GI.Gio.Objects.DBusConnection.DBusConnection' is active, it will interact with this
stream from a worker thread, so it is not safe to interact with
the stream directly.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionStreamPropertyInfo        ,
#endif
    constructDBusConnectionStream           ,
#if ENABLE_OVERLOADING
    dBusConnectionStream                    ,
#endif
    getDBusConnectionStream                 ,


-- ** uniqueName #attr:uniqueName#
{- | The unique name as assigned by the message bus or 'Nothing' if the
connection is not open or not a message bus connection.

/Since: 2.26/
-}
#if ENABLE_OVERLOADING
    DBusConnectionUniqueNamePropertyInfo    ,
#endif
#if ENABLE_OVERLOADING
    dBusConnectionUniqueName                ,
#endif
    getDBusConnectionUniqueName             ,




 -- * Signals
-- ** closed #signal:closed#

    C_DBusConnectionClosedCallback          ,
    DBusConnectionClosedCallback            ,
#if ENABLE_OVERLOADING
    DBusConnectionClosedSignalInfo          ,
#endif
    afterDBusConnectionClosed               ,
    genClosure_DBusConnectionClosed         ,
    mk_DBusConnectionClosedCallback         ,
    noDBusConnectionClosedCallback          ,
    onDBusConnectionClosed                  ,
    wrap_DBusConnectionClosedCallback       ,




    ) 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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Initable as Gio.Initable
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.Credentials as Gio.Credentials
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusAuthObserver as Gio.DBusAuthObserver
import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMessage as Gio.DBusMessage
import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream
import {-# SOURCE #-} qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceInfo as Gio.DBusInterfaceInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusSubtreeVTable as Gio.DBusSubtreeVTable

-- | Memory-managed wrapper type.
newtype DBusConnection = DBusConnection (ManagedPtr DBusConnection)
foreign import ccall "g_dbus_connection_get_type"
    c_g_dbus_connection_get_type :: IO GType

instance GObject DBusConnection where
    gobjectType = c_g_dbus_connection_get_type
    

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

instance O.HasParentTypes DBusConnection
type instance O.ParentTypes DBusConnection = '[GObject.Object.Object, Gio.AsyncInitable.AsyncInitable, Gio.Initable.Initable]

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

-- | A convenience alias for `Nothing` :: `Maybe` `DBusConnection`.
noDBusConnection :: Maybe DBusConnection
noDBusConnection = Nothing

#if ENABLE_OVERLOADING
type family ResolveDBusConnectionMethod (t :: Symbol) (o :: *) :: * where
    ResolveDBusConnectionMethod "addFilter" o = DBusConnectionAddFilterMethodInfo
    ResolveDBusConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDBusConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDBusConnectionMethod "call" o = DBusConnectionCallMethodInfo
    ResolveDBusConnectionMethod "callFinish" o = DBusConnectionCallFinishMethodInfo
    ResolveDBusConnectionMethod "callSync" o = DBusConnectionCallSyncMethodInfo
    ResolveDBusConnectionMethod "callWithUnixFdList" o = DBusConnectionCallWithUnixFdListMethodInfo
    ResolveDBusConnectionMethod "callWithUnixFdListFinish" o = DBusConnectionCallWithUnixFdListFinishMethodInfo
    ResolveDBusConnectionMethod "callWithUnixFdListSync" o = DBusConnectionCallWithUnixFdListSyncMethodInfo
    ResolveDBusConnectionMethod "close" o = DBusConnectionCloseMethodInfo
    ResolveDBusConnectionMethod "closeFinish" o = DBusConnectionCloseFinishMethodInfo
    ResolveDBusConnectionMethod "closeSync" o = DBusConnectionCloseSyncMethodInfo
    ResolveDBusConnectionMethod "emitSignal" o = DBusConnectionEmitSignalMethodInfo
    ResolveDBusConnectionMethod "exportActionGroup" o = DBusConnectionExportActionGroupMethodInfo
    ResolveDBusConnectionMethod "exportMenuModel" o = DBusConnectionExportMenuModelMethodInfo
    ResolveDBusConnectionMethod "flush" o = DBusConnectionFlushMethodInfo
    ResolveDBusConnectionMethod "flushFinish" o = DBusConnectionFlushFinishMethodInfo
    ResolveDBusConnectionMethod "flushSync" o = DBusConnectionFlushSyncMethodInfo
    ResolveDBusConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDBusConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDBusConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDBusConnectionMethod "init" o = Gio.Initable.InitableInitMethodInfo
    ResolveDBusConnectionMethod "initAsync" o = Gio.AsyncInitable.AsyncInitableInitAsyncMethodInfo
    ResolveDBusConnectionMethod "initFinish" o = Gio.AsyncInitable.AsyncInitableInitFinishMethodInfo
    ResolveDBusConnectionMethod "isClosed" o = DBusConnectionIsClosedMethodInfo
    ResolveDBusConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDBusConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDBusConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDBusConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDBusConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDBusConnectionMethod "registerObject" o = DBusConnectionRegisterObjectMethodInfo
    ResolveDBusConnectionMethod "registerSubtree" o = DBusConnectionRegisterSubtreeMethodInfo
    ResolveDBusConnectionMethod "removeFilter" o = DBusConnectionRemoveFilterMethodInfo
    ResolveDBusConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDBusConnectionMethod "sendMessage" o = DBusConnectionSendMessageMethodInfo
    ResolveDBusConnectionMethod "sendMessageWithReply" o = DBusConnectionSendMessageWithReplyMethodInfo
    ResolveDBusConnectionMethod "sendMessageWithReplyFinish" o = DBusConnectionSendMessageWithReplyFinishMethodInfo
    ResolveDBusConnectionMethod "sendMessageWithReplySync" o = DBusConnectionSendMessageWithReplySyncMethodInfo
    ResolveDBusConnectionMethod "signalSubscribe" o = DBusConnectionSignalSubscribeMethodInfo
    ResolveDBusConnectionMethod "signalUnsubscribe" o = DBusConnectionSignalUnsubscribeMethodInfo
    ResolveDBusConnectionMethod "startMessageProcessing" o = DBusConnectionStartMessageProcessingMethodInfo
    ResolveDBusConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDBusConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDBusConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDBusConnectionMethod "unexportActionGroup" o = DBusConnectionUnexportActionGroupMethodInfo
    ResolveDBusConnectionMethod "unexportMenuModel" o = DBusConnectionUnexportMenuModelMethodInfo
    ResolveDBusConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDBusConnectionMethod "unregisterObject" o = DBusConnectionUnregisterObjectMethodInfo
    ResolveDBusConnectionMethod "unregisterSubtree" o = DBusConnectionUnregisterSubtreeMethodInfo
    ResolveDBusConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDBusConnectionMethod "getCapabilities" o = DBusConnectionGetCapabilitiesMethodInfo
    ResolveDBusConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDBusConnectionMethod "getExitOnClose" o = DBusConnectionGetExitOnCloseMethodInfo
    ResolveDBusConnectionMethod "getFlags" o = DBusConnectionGetFlagsMethodInfo
    ResolveDBusConnectionMethod "getGuid" o = DBusConnectionGetGuidMethodInfo
    ResolveDBusConnectionMethod "getLastSerial" o = DBusConnectionGetLastSerialMethodInfo
    ResolveDBusConnectionMethod "getPeerCredentials" o = DBusConnectionGetPeerCredentialsMethodInfo
    ResolveDBusConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDBusConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDBusConnectionMethod "getStream" o = DBusConnectionGetStreamMethodInfo
    ResolveDBusConnectionMethod "getUniqueName" o = DBusConnectionGetUniqueNameMethodInfo
    ResolveDBusConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDBusConnectionMethod "setExitOnClose" o = DBusConnectionSetExitOnCloseMethodInfo
    ResolveDBusConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDBusConnectionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDBusConnectionMethod t DBusConnection, O.MethodInfo info DBusConnection p) => OL.IsLabel t (DBusConnection -> 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

-- signal DBusConnection::closed
{- |
Emitted when the connection is closed.

The cause of this event can be

* If 'GI.Gio.Objects.DBusConnection.dBusConnectionClose' is called. In this case
/@remotePeerVanished@/ is set to 'False' and /@error@/ is 'Nothing'.
* If the remote peer closes the connection. In this case
/@remotePeerVanished@/ is set to 'True' and /@error@/ is set.
* If the remote peer sends invalid or malformed data. In this
case /@remotePeerVanished@/ is set to 'False' and /@error@/ is set.


Upon receiving this signal, you should give up your reference to
/@connection@/. You are guaranteed that this signal is emitted only
once.

/Since: 2.26/
-}
type DBusConnectionClosedCallback =
    Bool
    {- ^ /@remotePeerVanished@/: 'True' if /@connection@/ is closed because the
    remote peer closed its end of the connection -}
    -> Maybe GError
    {- ^ /@error@/: a 'GError' with more details about the event or 'Nothing' -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DBusConnectionClosedCallback`@.
noDBusConnectionClosedCallback :: Maybe DBusConnectionClosedCallback
noDBusConnectionClosedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DBusConnectionClosedCallback =
    Ptr () ->                               -- object
    CInt ->
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_DBusConnectionClosed :: MonadIO m => DBusConnectionClosedCallback -> m (GClosure C_DBusConnectionClosedCallback)
genClosure_DBusConnectionClosed cb = liftIO $ do
    let cb' = wrap_DBusConnectionClosedCallback cb
    mk_DBusConnectionClosedCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `DBusConnectionClosedCallback` into a `C_DBusConnectionClosedCallback`.
wrap_DBusConnectionClosedCallback ::
    DBusConnectionClosedCallback ->
    C_DBusConnectionClosedCallback
wrap_DBusConnectionClosedCallback _cb _ remotePeerVanished error_ _ = do
    let remotePeerVanished' = (/= 0) remotePeerVanished
    maybeError_ <-
        if error_ == nullPtr
        then return Nothing
        else do
            error_' <- (newBoxed GError) error_
            return $ Just error_'
    _cb  remotePeerVanished' maybeError_


{- |
Connect a signal handler for the “@closed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' dBusConnection #closed callback
@
-}
onDBusConnectionClosed :: (IsDBusConnection a, MonadIO m) => a -> DBusConnectionClosedCallback -> m SignalHandlerId
onDBusConnectionClosed obj cb = liftIO $ do
    let cb' = wrap_DBusConnectionClosedCallback cb
    cb'' <- mk_DBusConnectionClosedCallback cb'
    connectSignalFunPtr obj "closed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@closed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' dBusConnection #closed callback
@
-}
afterDBusConnectionClosed :: (IsDBusConnection a, MonadIO m) => a -> DBusConnectionClosedCallback -> m SignalHandlerId
afterDBusConnectionClosed obj cb = liftIO $ do
    let cb' = wrap_DBusConnectionClosedCallback cb
    cb'' <- mk_DBusConnectionClosedCallback cb'
    connectSignalFunPtr obj "closed" cb'' SignalConnectAfter


-- VVV Prop "address"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Construct a `GValueConstruct` with valid value for the “@address@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDBusConnectionAddress :: (IsDBusConnection o) => T.Text -> IO (GValueConstruct o)
constructDBusConnectionAddress val = B.Properties.constructObjectPropertyString "address" (Just val)

#if ENABLE_OVERLOADING
data DBusConnectionAddressPropertyInfo
instance AttrInfo DBusConnectionAddressPropertyInfo where
    type AttrAllowedOps DBusConnectionAddressPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
    type AttrSetTypeConstraint DBusConnectionAddressPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DBusConnectionAddressPropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionAddressPropertyInfo = ()
    type AttrLabel DBusConnectionAddressPropertyInfo = "address"
    type AttrOrigin DBusConnectionAddressPropertyInfo = DBusConnection
    attrGet _ = undefined
    attrSet _ = undefined
    attrConstruct _ = constructDBusConnectionAddress
    attrClear _ = undefined
#endif

-- VVV Prop "authentication-observer"
   -- Type: TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"})
   -- Flags: [PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

{- |
Construct a `GValueConstruct` with valid value for the “@authentication-observer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDBusConnectionAuthenticationObserver :: (IsDBusConnection o, Gio.DBusAuthObserver.IsDBusAuthObserver a) => a -> IO (GValueConstruct o)
constructDBusConnectionAuthenticationObserver val = B.Properties.constructObjectPropertyObject "authentication-observer" (Just val)

#if ENABLE_OVERLOADING
data DBusConnectionAuthenticationObserverPropertyInfo
instance AttrInfo DBusConnectionAuthenticationObserverPropertyInfo where
    type AttrAllowedOps DBusConnectionAuthenticationObserverPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
    type AttrSetTypeConstraint DBusConnectionAuthenticationObserverPropertyInfo = Gio.DBusAuthObserver.IsDBusAuthObserver
    type AttrBaseTypeConstraint DBusConnectionAuthenticationObserverPropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionAuthenticationObserverPropertyInfo = ()
    type AttrLabel DBusConnectionAuthenticationObserverPropertyInfo = "authentication-observer"
    type AttrOrigin DBusConnectionAuthenticationObserverPropertyInfo = DBusConnection
    attrGet _ = undefined
    attrSet _ = undefined
    attrConstruct _ = constructDBusConnectionAuthenticationObserver
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' dBusConnection #capabilities
@
-}
getDBusConnectionCapabilities :: (MonadIO m, IsDBusConnection o) => o -> m [Gio.Flags.DBusCapabilityFlags]
getDBusConnectionCapabilities obj = liftIO $ B.Properties.getObjectPropertyFlags obj "capabilities"

#if ENABLE_OVERLOADING
data DBusConnectionCapabilitiesPropertyInfo
instance AttrInfo DBusConnectionCapabilitiesPropertyInfo where
    type AttrAllowedOps DBusConnectionCapabilitiesPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DBusConnectionCapabilitiesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DBusConnectionCapabilitiesPropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionCapabilitiesPropertyInfo = [Gio.Flags.DBusCapabilityFlags]
    type AttrLabel DBusConnectionCapabilitiesPropertyInfo = "capabilities"
    type AttrOrigin DBusConnectionCapabilitiesPropertyInfo = DBusConnection
    attrGet _ = getDBusConnectionCapabilities
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' dBusConnection #closed
@
-}
getDBusConnectionClosed :: (MonadIO m, IsDBusConnection o) => o -> m Bool
getDBusConnectionClosed obj = liftIO $ B.Properties.getObjectPropertyBool obj "closed"

#if ENABLE_OVERLOADING
data DBusConnectionClosedPropertyInfo
instance AttrInfo DBusConnectionClosedPropertyInfo where
    type AttrAllowedOps DBusConnectionClosedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DBusConnectionClosedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DBusConnectionClosedPropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionClosedPropertyInfo = Bool
    type AttrLabel DBusConnectionClosedPropertyInfo = "closed"
    type AttrOrigin DBusConnectionClosedPropertyInfo = DBusConnection
    attrGet _ = getDBusConnectionClosed
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "exit-on-close"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

@
'Data.GI.Base.Attributes.get' dBusConnection #exitOnClose
@
-}
getDBusConnectionExitOnClose :: (MonadIO m, IsDBusConnection o) => o -> m Bool
getDBusConnectionExitOnClose obj = liftIO $ B.Properties.getObjectPropertyBool obj "exit-on-close"

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

@
'Data.GI.Base.Attributes.set' dBusConnection [ #exitOnClose 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDBusConnectionExitOnClose :: (MonadIO m, IsDBusConnection o) => o -> Bool -> m ()
setDBusConnectionExitOnClose obj val = liftIO $ B.Properties.setObjectPropertyBool obj "exit-on-close" val

{- |
Construct a `GValueConstruct` with valid value for the “@exit-on-close@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDBusConnectionExitOnClose :: (IsDBusConnection o) => Bool -> IO (GValueConstruct o)
constructDBusConnectionExitOnClose val = B.Properties.constructObjectPropertyBool "exit-on-close" val

#if ENABLE_OVERLOADING
data DBusConnectionExitOnClosePropertyInfo
instance AttrInfo DBusConnectionExitOnClosePropertyInfo where
    type AttrAllowedOps DBusConnectionExitOnClosePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DBusConnectionExitOnClosePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DBusConnectionExitOnClosePropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionExitOnClosePropertyInfo = Bool
    type AttrLabel DBusConnectionExitOnClosePropertyInfo = "exit-on-close"
    type AttrOrigin DBusConnectionExitOnClosePropertyInfo = DBusConnection
    attrGet _ = getDBusConnectionExitOnClose
    attrSet _ = setDBusConnectionExitOnClose
    attrConstruct _ = constructDBusConnectionExitOnClose
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' dBusConnection #flags
@
-}
getDBusConnectionFlags :: (MonadIO m, IsDBusConnection o) => o -> m [Gio.Flags.DBusConnectionFlags]
getDBusConnectionFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags"

{- |
Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDBusConnectionFlags :: (IsDBusConnection o) => [Gio.Flags.DBusConnectionFlags] -> IO (GValueConstruct o)
constructDBusConnectionFlags val = B.Properties.constructObjectPropertyFlags "flags" val

#if ENABLE_OVERLOADING
data DBusConnectionFlagsPropertyInfo
instance AttrInfo DBusConnectionFlagsPropertyInfo where
    type AttrAllowedOps DBusConnectionFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DBusConnectionFlagsPropertyInfo = (~) [Gio.Flags.DBusConnectionFlags]
    type AttrBaseTypeConstraint DBusConnectionFlagsPropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionFlagsPropertyInfo = [Gio.Flags.DBusConnectionFlags]
    type AttrLabel DBusConnectionFlagsPropertyInfo = "flags"
    type AttrOrigin DBusConnectionFlagsPropertyInfo = DBusConnection
    attrGet _ = getDBusConnectionFlags
    attrSet _ = undefined
    attrConstruct _ = constructDBusConnectionFlags
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' dBusConnection #guid
@
-}
getDBusConnectionGuid :: (MonadIO m, IsDBusConnection o) => o -> m T.Text
getDBusConnectionGuid obj = liftIO $ checkUnexpectedNothing "getDBusConnectionGuid" $ B.Properties.getObjectPropertyString obj "guid"

{- |
Construct a `GValueConstruct` with valid value for the “@guid@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDBusConnectionGuid :: (IsDBusConnection o) => T.Text -> IO (GValueConstruct o)
constructDBusConnectionGuid val = B.Properties.constructObjectPropertyString "guid" (Just val)

#if ENABLE_OVERLOADING
data DBusConnectionGuidPropertyInfo
instance AttrInfo DBusConnectionGuidPropertyInfo where
    type AttrAllowedOps DBusConnectionGuidPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DBusConnectionGuidPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DBusConnectionGuidPropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionGuidPropertyInfo = T.Text
    type AttrLabel DBusConnectionGuidPropertyInfo = "guid"
    type AttrOrigin DBusConnectionGuidPropertyInfo = DBusConnection
    attrGet _ = getDBusConnectionGuid
    attrSet _ = undefined
    attrConstruct _ = constructDBusConnectionGuid
    attrClear _ = undefined
#endif

-- VVV Prop "stream"
   -- Type: TInterface (Name {namespace = "Gio", name = "IOStream"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' dBusConnection #stream
@
-}
getDBusConnectionStream :: (MonadIO m, IsDBusConnection o) => o -> m Gio.IOStream.IOStream
getDBusConnectionStream obj = liftIO $ checkUnexpectedNothing "getDBusConnectionStream" $ B.Properties.getObjectPropertyObject obj "stream" Gio.IOStream.IOStream

{- |
Construct a `GValueConstruct` with valid value for the “@stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDBusConnectionStream :: (IsDBusConnection o, Gio.IOStream.IsIOStream a) => a -> IO (GValueConstruct o)
constructDBusConnectionStream val = B.Properties.constructObjectPropertyObject "stream" (Just val)

#if ENABLE_OVERLOADING
data DBusConnectionStreamPropertyInfo
instance AttrInfo DBusConnectionStreamPropertyInfo where
    type AttrAllowedOps DBusConnectionStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DBusConnectionStreamPropertyInfo = Gio.IOStream.IsIOStream
    type AttrBaseTypeConstraint DBusConnectionStreamPropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionStreamPropertyInfo = Gio.IOStream.IOStream
    type AttrLabel DBusConnectionStreamPropertyInfo = "stream"
    type AttrOrigin DBusConnectionStreamPropertyInfo = DBusConnection
    attrGet _ = getDBusConnectionStream
    attrSet _ = undefined
    attrConstruct _ = constructDBusConnectionStream
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' dBusConnection #uniqueName
@
-}
getDBusConnectionUniqueName :: (MonadIO m, IsDBusConnection o) => o -> m (Maybe T.Text)
getDBusConnectionUniqueName obj = liftIO $ B.Properties.getObjectPropertyString obj "unique-name"

#if ENABLE_OVERLOADING
data DBusConnectionUniqueNamePropertyInfo
instance AttrInfo DBusConnectionUniqueNamePropertyInfo where
    type AttrAllowedOps DBusConnectionUniqueNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DBusConnectionUniqueNamePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DBusConnectionUniqueNamePropertyInfo = IsDBusConnection
    type AttrGetType DBusConnectionUniqueNamePropertyInfo = (Maybe T.Text)
    type AttrLabel DBusConnectionUniqueNamePropertyInfo = "unique-name"
    type AttrOrigin DBusConnectionUniqueNamePropertyInfo = DBusConnection
    attrGet _ = getDBusConnectionUniqueName
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList DBusConnection
type instance O.AttributeList DBusConnection = DBusConnectionAttributeList
type DBusConnectionAttributeList = ('[ '("address", DBusConnectionAddressPropertyInfo), '("authenticationObserver", DBusConnectionAuthenticationObserverPropertyInfo), '("capabilities", DBusConnectionCapabilitiesPropertyInfo), '("closed", DBusConnectionClosedPropertyInfo), '("exitOnClose", DBusConnectionExitOnClosePropertyInfo), '("flags", DBusConnectionFlagsPropertyInfo), '("guid", DBusConnectionGuidPropertyInfo), '("stream", DBusConnectionStreamPropertyInfo), '("uniqueName", DBusConnectionUniqueNamePropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
dBusConnectionAddress :: AttrLabelProxy "address"
dBusConnectionAddress = AttrLabelProxy

dBusConnectionAuthenticationObserver :: AttrLabelProxy "authenticationObserver"
dBusConnectionAuthenticationObserver = AttrLabelProxy

dBusConnectionCapabilities :: AttrLabelProxy "capabilities"
dBusConnectionCapabilities = AttrLabelProxy

dBusConnectionClosed :: AttrLabelProxy "closed"
dBusConnectionClosed = AttrLabelProxy

dBusConnectionExitOnClose :: AttrLabelProxy "exitOnClose"
dBusConnectionExitOnClose = AttrLabelProxy

dBusConnectionFlags :: AttrLabelProxy "flags"
dBusConnectionFlags = AttrLabelProxy

dBusConnectionGuid :: AttrLabelProxy "guid"
dBusConnectionGuid = AttrLabelProxy

dBusConnectionStream :: AttrLabelProxy "stream"
dBusConnectionStream = AttrLabelProxy

dBusConnectionUniqueName :: AttrLabelProxy "uniqueName"
dBusConnectionUniqueName = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data DBusConnectionClosedSignalInfo
instance SignalInfo DBusConnectionClosedSignalInfo where
    type HaskellCallbackType DBusConnectionClosedSignalInfo = DBusConnectionClosedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_DBusConnectionClosedCallback cb
        cb'' <- mk_DBusConnectionClosedCallback cb'
        connectSignalFunPtr obj "closed" cb'' connectMode

type instance O.SignalList DBusConnection = DBusConnectionSignalList
type DBusConnectionSignalList = ('[ '("closed", DBusConnectionClosedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DBusConnection::new_finish
-- method type : Constructor
-- Args : [Arg {argCName = "res", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult obtained from the #GAsyncReadyCallback\n    passed to g_dbus_connection_new().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusConnection"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_new_finish" g_dbus_connection_new_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr DBusConnection)

{- |
Finishes an operation started with 'GI.Gio.Objects.DBusConnection.dBusConnectionNew'.

/Since: 2.26/
-}
dBusConnectionNewFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    {- ^ /@res@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback'
    passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionNew'. -}
    -> m DBusConnection
    {- ^ __Returns:__ a 'GI.Gio.Objects.DBusConnection.DBusConnection' or 'Nothing' if /@error@/ is set. Free
    with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionNewFinish res = liftIO $ do
    res' <- unsafeManagedPtrCastPtr res
    onException (do
        result <- propagateGError $ g_dbus_connection_new_finish res'
        checkUnexpectedReturnNULL "dBusConnectionNewFinish" result
        result' <- (wrapObject DBusConnection) result
        touchManagedPtr res
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
#endif

-- method DBusConnection::new_for_address_finish
-- method type : Constructor
-- Args : [Arg {argCName = "res", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult obtained from the #GAsyncReadyCallback passed\n    to g_dbus_connection_new()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusConnection"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_new_for_address_finish" g_dbus_connection_new_for_address_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr DBusConnection)

{- |
Finishes an operation started with 'GI.Gio.Objects.DBusConnection.dBusConnectionNewForAddress'.

/Since: 2.26/
-}
dBusConnectionNewForAddressFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    {- ^ /@res@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback' passed
    to 'GI.Gio.Objects.DBusConnection.dBusConnectionNew' -}
    -> m DBusConnection
    {- ^ __Returns:__ a 'GI.Gio.Objects.DBusConnection.DBusConnection' or 'Nothing' if /@error@/ is set. Free with
    'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionNewForAddressFinish res = liftIO $ do
    res' <- unsafeManagedPtrCastPtr res
    onException (do
        result <- propagateGError $ g_dbus_connection_new_for_address_finish res'
        checkUnexpectedReturnNULL "dBusConnectionNewForAddressFinish" result
        result' <- (wrapObject DBusConnection) result
        touchManagedPtr res
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
#endif

-- method DBusConnection::new_for_address_sync
-- method type : Constructor
-- Args : [Arg {argCName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a D-Bus address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags describing how to make the connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "observer", argType = TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GDBusAuthObserver or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusConnection"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_new_for_address_sync" g_dbus_connection_new_for_address_sync :: 
    CString ->                              -- address : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"})
    Ptr Gio.DBusAuthObserver.DBusAuthObserver -> -- observer : TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr DBusConnection)

{- |
Synchronously connects and sets up a D-Bus client connection for
exchanging D-Bus messages with an endpoint specified by /@address@/
which must be in the
<https://dbus.freedesktop.org/doc/dbus-specification.html#addresses D-Bus address format>.

This constructor can only be used to initiate client-side
connections - use 'GI.Gio.Objects.DBusConnection.dBusConnectionNewSync' if you need to act
as the server. In particular, /@flags@/ cannot contain the
'GI.Gio.Flags.DBusConnectionFlagsAuthenticationServer' or
'GI.Gio.Flags.DBusConnectionFlagsAuthenticationAllowAnonymous' flags.

This is a synchronous failable constructor. See
'GI.Gio.Objects.DBusConnection.dBusConnectionNewForAddress' for the asynchronous version.

If /@observer@/ is not 'Nothing' it may be used to control the
authentication process.

/Since: 2.26/
-}
dBusConnectionNewForAddressSync ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusAuthObserver.IsDBusAuthObserver a, Gio.Cancellable.IsCancellable b) =>
    T.Text
    {- ^ /@address@/: a D-Bus address -}
    -> [Gio.Flags.DBusConnectionFlags]
    {- ^ /@flags@/: flags describing how to make the connection -}
    -> Maybe (a)
    {- ^ /@observer@/: a 'GI.Gio.Objects.DBusAuthObserver.DBusAuthObserver' or 'Nothing' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m DBusConnection
    {- ^ __Returns:__ a 'GI.Gio.Objects.DBusConnection.DBusConnection' or 'Nothing' if /@error@/ is set. Free with
    'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionNewForAddressSync address flags observer cancellable = liftIO $ do
    address' <- textToCString address
    let flags' = gflagsToWord flags
    maybeObserver <- case observer of
        Nothing -> return nullPtr
        Just jObserver -> do
            jObserver' <- unsafeManagedPtrCastPtr jObserver
            return jObserver'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ g_dbus_connection_new_for_address_sync address' flags' maybeObserver maybeCancellable
        checkUnexpectedReturnNULL "dBusConnectionNewForAddressSync" result
        result' <- (wrapObject DBusConnection) result
        whenJust observer touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem address'
        return result'
     ) (do
        freeMem address'
     )

#if ENABLE_OVERLOADING
#endif

-- method DBusConnection::new_sync
-- method type : Constructor
-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the GUID to use if a authenticating as a server or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags describing how to make the connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "observer", argType = TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GDBusAuthObserver or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusConnection"}))
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_new_sync" g_dbus_connection_new_sync :: 
    Ptr Gio.IOStream.IOStream ->            -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
    CString ->                              -- guid : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"})
    Ptr Gio.DBusAuthObserver.DBusAuthObserver -> -- observer : TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr DBusConnection)

{- |
Synchronously sets up a D-Bus connection for exchanging D-Bus messages
with the end represented by /@stream@/.

If /@stream@/ is a 'GI.Gio.Objects.SocketConnection.SocketConnection', then the corresponding 'GI.Gio.Objects.Socket.Socket'
will be put into non-blocking mode.

The D-Bus connection will interact with /@stream@/ from a worker thread.
As a result, the caller should not interact with /@stream@/ after this
method has been called, except by calling 'GI.GObject.Objects.Object.objectUnref' on it.

If /@observer@/ is not 'Nothing' it may be used to control the
authentication process.

This is a synchronous failable constructor. See
'GI.Gio.Objects.DBusConnection.dBusConnectionNew' for the asynchronous version.

/Since: 2.26/
-}
dBusConnectionNewSync ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.IOStream.IsIOStream a, Gio.DBusAuthObserver.IsDBusAuthObserver b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
    -> Maybe (T.Text)
    {- ^ /@guid@/: the GUID to use if a authenticating as a server or 'Nothing' -}
    -> [Gio.Flags.DBusConnectionFlags]
    {- ^ /@flags@/: flags describing how to make the connection -}
    -> Maybe (b)
    {- ^ /@observer@/: a 'GI.Gio.Objects.DBusAuthObserver.DBusAuthObserver' or 'Nothing' -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m DBusConnection
    {- ^ __Returns:__ a 'GI.Gio.Objects.DBusConnection.DBusConnection' or 'Nothing' if /@error@/ is set. Free with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionNewSync stream guid flags observer cancellable = liftIO $ do
    stream' <- unsafeManagedPtrCastPtr stream
    maybeGuid <- case guid of
        Nothing -> return nullPtr
        Just jGuid -> do
            jGuid' <- textToCString jGuid
            return jGuid'
    let flags' = gflagsToWord flags
    maybeObserver <- case observer of
        Nothing -> return nullPtr
        Just jObserver -> do
            jObserver' <- unsafeManagedPtrCastPtr jObserver
            return jObserver'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ g_dbus_connection_new_sync stream' maybeGuid flags' maybeObserver maybeCancellable
        checkUnexpectedReturnNULL "dBusConnectionNewSync" result
        result' <- (wrapObject DBusConnection) result
        touchManagedPtr stream
        whenJust observer touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem maybeGuid
        return result'
     ) (do
        freeMem maybeGuid
     )

#if ENABLE_OVERLOADING
#endif

-- method DBusConnection::add_filter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_function", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageFilterFunction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a filter function", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @filter_function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to free @user_data with when filter\n    is removed or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_connection_add_filter" g_dbus_connection_add_filter :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    FunPtr Gio.Callbacks.C_DBusMessageFilterFunction -> -- filter_function : TInterface (Name {namespace = "Gio", name = "DBusMessageFilterFunction"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO Word32

{- |
Adds a message filter. Filters are handlers that are run on all
incoming and outgoing messages, prior to standard dispatch. Filters
are run in the order that they were added.  The same handler can be
added as a filter more than once, in which case it will be run more
than once.  Filters added during a filter callback won\'t be run on
the message being processed. Filter functions are allowed to modify
and even drop messages.

Note that filters are run in a dedicated message handling thread so
they can\'t block and, generally, can\'t do anything but signal a
worker thread. Also note that filters are rarely needed - use API
such as 'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessageWithReply',
'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe' or 'GI.Gio.Objects.DBusConnection.dBusConnectionCall' instead.

If a filter consumes an incoming message the message is not
dispatched anywhere else - not even the standard dispatch machinery
(that API such as 'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe' and
'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessageWithReply' relies on) will see the
message. Similarly, if a filter consumes an outgoing message, the
message will not be sent to the other peer.

If /@userDataFreeFunc@/ is non-'Nothing', it will be called (in the
thread-default main context of the thread you are calling this
method from) at some point after /@userData@/ is no longer
needed. (It is not guaranteed to be called synchronously when the
filter is removed, and may be called after /@connection@/ has been
destroyed.)

/Since: 2.26/
-}
dBusConnectionAddFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Gio.Callbacks.DBusMessageFilterFunction
    {- ^ /@filterFunction@/: a filter function -}
    -> m Word32
    {- ^ __Returns:__ a filter identifier that can be used with
    'GI.Gio.Objects.DBusConnection.dBusConnectionRemoveFilter' -}
dBusConnectionAddFilter connection filterFunction = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    filterFunction' <- Gio.Callbacks.mk_DBusMessageFilterFunction (Gio.Callbacks.wrap_DBusMessageFilterFunction Nothing (Gio.Callbacks.drop_closures_DBusMessageFilterFunction filterFunction))
    let userData = castFunPtrToPtr filterFunction'
    let userDataFreeFunc = safeFreeFunPtrPtr
    result <- g_dbus_connection_add_filter connection' filterFunction' userData userDataFreeFunc
    touchManagedPtr connection
    return result

#if ENABLE_OVERLOADING
data DBusConnectionAddFilterMethodInfo
instance (signature ~ (Gio.Callbacks.DBusMessageFilterFunction -> m Word32), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionAddFilterMethodInfo a signature where
    overloadedMethod _ = dBusConnectionAddFilter

#endif

-- method DBusConnection::call
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a unique or well-known bus name or %NULL if\n    @connection is not a message bus connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path of remote object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "D-Bus interface to invoke method on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the method to invoke", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant tuple with parameters for the method\n    or %NULL if not passing parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reply_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the expected type of the reply (which will be a\n    tuple), or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusCallFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from the #GDBusCallFlags enumeration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout_msec", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timeout in milliseconds, -1 to use the default\n    timeout or %G_MAXINT for no timeout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request\n    is satisfied or %NULL if you don't care about the result of the\n    method invocation", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 11, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to @callback", 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_connection_call" g_dbus_connection_call :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- bus_name : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    CString ->                              -- interface_name : TBasicType TUTF8
    CString ->                              -- method_name : TBasicType TUTF8
    Ptr GVariant ->                         -- parameters : TVariant
    Ptr GLib.VariantType.VariantType ->     -- reply_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusCallFlags"})
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously invokes the /@methodName@/ method on the
/@interfaceName@/ D-Bus interface on the remote object at
/@objectPath@/ owned by /@busName@/.

If /@connection@/ is closed then the operation will fail with
'GI.Gio.Enums.IOErrorEnumClosed'. If /@cancellable@/ is canceled, the operation will
fail with 'GI.Gio.Enums.IOErrorEnumCancelled'. If /@parameters@/ contains a value
not compatible with the D-Bus protocol, the operation fails with
'GI.Gio.Enums.IOErrorEnumInvalidArgument'.

If /@replyType@/ is non-'Nothing' then the reply will be checked for having this type and an
error will be raised if it does not match.  Said another way, if you give a /@replyType@/
then any non-'Nothing' return value will be of this type. Unless it’s
@/G_VARIANT_TYPE_UNIT/@, the /@replyType@/ will be a tuple containing one or more
values.

If the /@parameters@/ 'GVariant' is floating, it is consumed. This allows
convenient \'inline\' use of @/g_variant_new()/@, e.g.:

=== /C code/
>
> g_dbus_connection_call (connection,
>                         "org.freedesktop.StringThings",
>                         "/org/freedesktop/StringThings",
>                         "org.freedesktop.StringThings",
>                         "TwoStrings",
>                         g_variant_new ("(ss)",
>                                        "Thing One",
>                                        "Thing Two"),
>                         NULL,
>                         G_DBUS_CALL_FLAGS_NONE,
>                         -1,
>                         NULL,
>                         (GAsyncReadyCallback) two_strings_done,
>                         NULL);


This is an asynchronous method. When the operation is finished,
/@callback@/ will be invoked in the
[thread-default main context][g-main-context-push-thread-default]
of the thread you are calling this method from. You can then call
'GI.Gio.Objects.DBusConnection.dBusConnectionCallFinish' to get the result of the operation.
See 'GI.Gio.Objects.DBusConnection.dBusConnectionCallSync' for the synchronous version of this
function.

If /@callback@/ is 'Nothing' then the D-Bus method call message will be sent with
the 'GI.Gio.Flags.DBusMessageFlagsNoReplyExpected' flag set.

/Since: 2.26/
-}
dBusConnectionCall ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (T.Text)
    {- ^ /@busName@/: a unique or well-known bus name or 'Nothing' if
    /@connection@/ is not a message bus connection -}
    -> T.Text
    {- ^ /@objectPath@/: path of remote object -}
    -> T.Text
    {- ^ /@interfaceName@/: D-Bus interface to invoke method on -}
    -> T.Text
    {- ^ /@methodName@/: the name of the method to invoke -}
    -> Maybe (GVariant)
    {- ^ /@parameters@/: a 'GVariant' tuple with parameters for the method
    or 'Nothing' if not passing parameters -}
    -> Maybe (GLib.VariantType.VariantType)
    {- ^ /@replyType@/: the expected type of the reply (which will be a
    tuple), or 'Nothing' -}
    -> [Gio.Flags.DBusCallFlags]
    {- ^ /@flags@/: flags from the 'GI.Gio.Flags.DBusCallFlags' enumeration -}
    -> Int32
    {- ^ /@timeoutMsec@/: the timeout in milliseconds, -1 to use the default
    timeout or @/G_MAXINT/@ for no timeout -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request
    is satisfied or 'Nothing' if you don\'t care about the result of the
    method invocation -}
    -> m ()
dBusConnectionCall connection busName objectPath interfaceName methodName parameters replyType flags timeoutMsec cancellable callback = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeBusName <- case busName of
        Nothing -> return nullPtr
        Just jBusName -> do
            jBusName' <- textToCString jBusName
            return jBusName'
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    methodName' <- textToCString methodName
    maybeParameters <- case parameters of
        Nothing -> return nullPtr
        Just jParameters -> do
            jParameters' <- unsafeManagedPtrGetPtr jParameters
            return jParameters'
    maybeReplyType <- case replyType of
        Nothing -> return nullPtr
        Just jReplyType -> do
            jReplyType' <- unsafeManagedPtrGetPtr jReplyType
            return jReplyType'
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_dbus_connection_call connection' maybeBusName objectPath' interfaceName' methodName' maybeParameters maybeReplyType flags' timeoutMsec maybeCancellable maybeCallback userData
    touchManagedPtr connection
    whenJust parameters touchManagedPtr
    whenJust replyType touchManagedPtr
    whenJust cancellable touchManagedPtr
    freeMem maybeBusName
    freeMem objectPath'
    freeMem interfaceName'
    freeMem methodName'
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionCallMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> T.Text -> T.Text -> Maybe (GVariant) -> Maybe (GLib.VariantType.VariantType) -> [Gio.Flags.DBusCallFlags] -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DBusConnectionCallMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCall

#endif

-- method DBusConnection::call_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_call_finish" g_dbus_connection_call_finish :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GVariant)

{- |
Finishes an operation started with 'GI.Gio.Objects.DBusConnection.dBusConnectionCall'.

/Since: 2.26/
-}
dBusConnectionCallFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@res@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback' passed to 'GI.Gio.Objects.DBusConnection.dBusConnectionCall' -}
    -> m GVariant
    {- ^ __Returns:__ 'Nothing' if /@error@/ is set. Otherwise a 'GVariant' tuple with
    return values. Free with 'GI.GLib.Structs.Variant.variantUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionCallFinish connection res = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    res' <- unsafeManagedPtrCastPtr res
    onException (do
        result <- propagateGError $ g_dbus_connection_call_finish connection' res'
        checkUnexpectedReturnNULL "dBusConnectionCallFinish" result
        result' <- B.GVariant.wrapGVariantPtr result
        touchManagedPtr connection
        touchManagedPtr res
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusConnectionCallFinishMethodInfo
instance (signature ~ (b -> m GVariant), MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DBusConnectionCallFinishMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCallFinish

#endif

-- method DBusConnection::call_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a unique or well-known bus name or %NULL if\n    @connection is not a message bus connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path of remote object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "D-Bus interface to invoke method on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the method to invoke", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant tuple with parameters for the method\n    or %NULL if not passing parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reply_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the expected type of the reply, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusCallFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from the #GDBusCallFlags enumeration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout_msec", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timeout in milliseconds, -1 to use the default\n    timeout or %G_MAXINT for no timeout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_call_sync" g_dbus_connection_call_sync :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- bus_name : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    CString ->                              -- interface_name : TBasicType TUTF8
    CString ->                              -- method_name : TBasicType TUTF8
    Ptr GVariant ->                         -- parameters : TVariant
    Ptr GLib.VariantType.VariantType ->     -- reply_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusCallFlags"})
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GVariant)

{- |
Synchronously invokes the /@methodName@/ method on the
/@interfaceName@/ D-Bus interface on the remote object at
/@objectPath@/ owned by /@busName@/.

If /@connection@/ is closed then the operation will fail with
'GI.Gio.Enums.IOErrorEnumClosed'. If /@cancellable@/ is canceled, the
operation will fail with 'GI.Gio.Enums.IOErrorEnumCancelled'. If /@parameters@/
contains a value not compatible with the D-Bus protocol, the operation
fails with 'GI.Gio.Enums.IOErrorEnumInvalidArgument'.

If /@replyType@/ is non-'Nothing' then the reply will be checked for having
this type and an error will be raised if it does not match.  Said
another way, if you give a /@replyType@/ then any non-'Nothing' return
value will be of this type.

If the /@parameters@/ 'GVariant' is floating, it is consumed.
This allows convenient \'inline\' use of @/g_variant_new()/@, e.g.:

=== /C code/
>
> g_dbus_connection_call_sync (connection,
>                              "org.freedesktop.StringThings",
>                              "/org/freedesktop/StringThings",
>                              "org.freedesktop.StringThings",
>                              "TwoStrings",
>                              g_variant_new ("(ss)",
>                                             "Thing One",
>                                             "Thing Two"),
>                              NULL,
>                              G_DBUS_CALL_FLAGS_NONE,
>                              -1,
>                              NULL,
>                              &error);


The calling thread is blocked until a reply is received. See
'GI.Gio.Objects.DBusConnection.dBusConnectionCall' for the asynchronous version of
this method.

/Since: 2.26/
-}
dBusConnectionCallSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (T.Text)
    {- ^ /@busName@/: a unique or well-known bus name or 'Nothing' if
    /@connection@/ is not a message bus connection -}
    -> T.Text
    {- ^ /@objectPath@/: path of remote object -}
    -> T.Text
    {- ^ /@interfaceName@/: D-Bus interface to invoke method on -}
    -> T.Text
    {- ^ /@methodName@/: the name of the method to invoke -}
    -> Maybe (GVariant)
    {- ^ /@parameters@/: a 'GVariant' tuple with parameters for the method
    or 'Nothing' if not passing parameters -}
    -> Maybe (GLib.VariantType.VariantType)
    {- ^ /@replyType@/: the expected type of the reply, or 'Nothing' -}
    -> [Gio.Flags.DBusCallFlags]
    {- ^ /@flags@/: flags from the 'GI.Gio.Flags.DBusCallFlags' enumeration -}
    -> Int32
    {- ^ /@timeoutMsec@/: the timeout in milliseconds, -1 to use the default
    timeout or @/G_MAXINT/@ for no timeout -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m GVariant
    {- ^ __Returns:__ 'Nothing' if /@error@/ is set. Otherwise a 'GVariant' tuple with
    return values. Free with 'GI.GLib.Structs.Variant.variantUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionCallSync connection busName objectPath interfaceName methodName parameters replyType flags timeoutMsec cancellable = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeBusName <- case busName of
        Nothing -> return nullPtr
        Just jBusName -> do
            jBusName' <- textToCString jBusName
            return jBusName'
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    methodName' <- textToCString methodName
    maybeParameters <- case parameters of
        Nothing -> return nullPtr
        Just jParameters -> do
            jParameters' <- unsafeManagedPtrGetPtr jParameters
            return jParameters'
    maybeReplyType <- case replyType of
        Nothing -> return nullPtr
        Just jReplyType -> do
            jReplyType' <- unsafeManagedPtrGetPtr jReplyType
            return jReplyType'
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ g_dbus_connection_call_sync connection' maybeBusName objectPath' interfaceName' methodName' maybeParameters maybeReplyType flags' timeoutMsec maybeCancellable
        checkUnexpectedReturnNULL "dBusConnectionCallSync" result
        result' <- B.GVariant.wrapGVariantPtr result
        touchManagedPtr connection
        whenJust parameters touchManagedPtr
        whenJust replyType touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem maybeBusName
        freeMem objectPath'
        freeMem interfaceName'
        freeMem methodName'
        return result'
     ) (do
        freeMem maybeBusName
        freeMem objectPath'
        freeMem interfaceName'
        freeMem methodName'
     )

#if ENABLE_OVERLOADING
data DBusConnectionCallSyncMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> T.Text -> T.Text -> Maybe (GVariant) -> Maybe (GLib.VariantType.VariantType) -> [Gio.Flags.DBusCallFlags] -> Int32 -> Maybe (b) -> m GVariant), MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DBusConnectionCallSyncMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCallSync

#endif

-- method DBusConnection::call_with_unix_fd_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a unique or well-known bus name or %NULL if\n    @connection is not a message bus connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path of remote object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "D-Bus interface to invoke method on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the method to invoke", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant tuple with parameters for the method\n    or %NULL if not passing parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reply_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the expected type of the reply, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusCallFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from the #GDBusCallFlags enumeration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout_msec", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timeout in milliseconds, -1 to use the default\n    timeout or %G_MAXINT for no timeout", 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},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is\n    satisfied or %NULL if you don't * care about the result of the\n    method invocation", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 12, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The data to pass to @callback.", 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_connection_call_with_unix_fd_list" g_dbus_connection_call_with_unix_fd_list :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- bus_name : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    CString ->                              -- interface_name : TBasicType TUTF8
    CString ->                              -- method_name : TBasicType TUTF8
    Ptr GVariant ->                         -- parameters : TVariant
    Ptr GLib.VariantType.VariantType ->     -- reply_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusCallFlags"})
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Gio.UnixFDList.UnixFDList ->        -- fd_list : TInterface (Name {namespace = "Gio", name = "UnixFDList"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Like 'GI.Gio.Objects.DBusConnection.dBusConnectionCall' but also takes a 'GI.Gio.Objects.UnixFDList.UnixFDList' object.

This method is only available on UNIX.

/Since: 2.30/
-}
dBusConnectionCallWithUnixFdList ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.UnixFDList.IsUnixFDList b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (T.Text)
    {- ^ /@busName@/: a unique or well-known bus name or 'Nothing' if
    /@connection@/ is not a message bus connection -}
    -> T.Text
    {- ^ /@objectPath@/: path of remote object -}
    -> T.Text
    {- ^ /@interfaceName@/: D-Bus interface to invoke method on -}
    -> T.Text
    {- ^ /@methodName@/: the name of the method to invoke -}
    -> Maybe (GVariant)
    {- ^ /@parameters@/: a 'GVariant' tuple with parameters for the method
    or 'Nothing' if not passing parameters -}
    -> Maybe (GLib.VariantType.VariantType)
    {- ^ /@replyType@/: the expected type of the reply, or 'Nothing' -}
    -> [Gio.Flags.DBusCallFlags]
    {- ^ /@flags@/: flags from the 'GI.Gio.Flags.DBusCallFlags' enumeration -}
    -> Int32
    {- ^ /@timeoutMsec@/: the timeout in milliseconds, -1 to use the default
    timeout or @/G_MAXINT/@ for no timeout -}
    -> Maybe (b)
    {- ^ /@fdList@/: a 'GI.Gio.Objects.UnixFDList.UnixFDList' or 'Nothing' -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is
    satisfied or 'Nothing' if you don\'t * care about the result of the
    method invocation -}
    -> m ()
dBusConnectionCallWithUnixFdList connection busName objectPath interfaceName methodName parameters replyType flags timeoutMsec fdList cancellable callback = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeBusName <- case busName of
        Nothing -> return nullPtr
        Just jBusName -> do
            jBusName' <- textToCString jBusName
            return jBusName'
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    methodName' <- textToCString methodName
    maybeParameters <- case parameters of
        Nothing -> return nullPtr
        Just jParameters -> do
            jParameters' <- unsafeManagedPtrGetPtr jParameters
            return jParameters'
    maybeReplyType <- case replyType of
        Nothing -> return nullPtr
        Just jReplyType -> do
            jReplyType' <- unsafeManagedPtrGetPtr jReplyType
            return jReplyType'
    let flags' = gflagsToWord flags
    maybeFdList <- case fdList of
        Nothing -> return nullPtr
        Just jFdList -> do
            jFdList' <- unsafeManagedPtrCastPtr jFdList
            return jFdList'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_dbus_connection_call_with_unix_fd_list connection' maybeBusName objectPath' interfaceName' methodName' maybeParameters maybeReplyType flags' timeoutMsec maybeFdList maybeCancellable maybeCallback userData
    touchManagedPtr connection
    whenJust parameters touchManagedPtr
    whenJust replyType touchManagedPtr
    whenJust fdList touchManagedPtr
    whenJust cancellable touchManagedPtr
    freeMem maybeBusName
    freeMem objectPath'
    freeMem interfaceName'
    freeMem methodName'
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionCallWithUnixFdListMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> T.Text -> T.Text -> Maybe (GVariant) -> Maybe (GLib.VariantType.VariantType) -> [Gio.Flags.DBusCallFlags] -> Int32 -> Maybe (b) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDBusConnection a, Gio.UnixFDList.IsUnixFDList b, Gio.Cancellable.IsCancellable c) => O.MethodInfo DBusConnectionCallWithUnixFdListMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCallWithUnixFdList

#endif

-- method DBusConnection::call_with_unix_fd_list_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_fd_list", argType = TInterface (Name {namespace = "Gio", name = "UnixFDList"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #GUnixFDList or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "res", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult obtained from the #GAsyncReadyCallback passed to\n    g_dbus_connection_call_with_unix_fd_list()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_call_with_unix_fd_list_finish" g_dbus_connection_call_with_unix_fd_list_finish :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr (Ptr Gio.UnixFDList.UnixFDList) ->  -- out_fd_list : TInterface (Name {namespace = "Gio", name = "UnixFDList"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GVariant)

{- |
Finishes an operation started with 'GI.Gio.Objects.DBusConnection.dBusConnectionCallWithUnixFdList'.

/Since: 2.30/
-}
dBusConnectionCallWithUnixFdListFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@res@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback' passed to
    'GI.Gio.Objects.DBusConnection.dBusConnectionCallWithUnixFdList' -}
    -> m ((GVariant, Gio.UnixFDList.UnixFDList))
    {- ^ __Returns:__ 'Nothing' if /@error@/ is set. Otherwise a 'GVariant' tuple with
    return values. Free with 'GI.GLib.Structs.Variant.variantUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionCallWithUnixFdListFinish connection res = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    outFdList <- allocMem :: IO (Ptr (Ptr Gio.UnixFDList.UnixFDList))
    res' <- unsafeManagedPtrCastPtr res
    onException (do
        result <- propagateGError $ g_dbus_connection_call_with_unix_fd_list_finish connection' outFdList res'
        checkUnexpectedReturnNULL "dBusConnectionCallWithUnixFdListFinish" result
        result' <- B.GVariant.wrapGVariantPtr result
        outFdList' <- peek outFdList
        outFdList'' <- (wrapObject Gio.UnixFDList.UnixFDList) outFdList'
        touchManagedPtr connection
        touchManagedPtr res
        freeMem outFdList
        return (result', outFdList'')
     ) (do
        freeMem outFdList
     )

#if ENABLE_OVERLOADING
data DBusConnectionCallWithUnixFdListFinishMethodInfo
instance (signature ~ (b -> m ((GVariant, Gio.UnixFDList.UnixFDList))), MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DBusConnectionCallWithUnixFdListFinishMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCallWithUnixFdListFinish

#endif

-- method DBusConnection::call_with_unix_fd_list_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a unique or well-known bus name or %NULL\n    if @connection is not a message bus connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path of remote object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "D-Bus interface to invoke method on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the method to invoke", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant tuple with parameters for\n    the method or %NULL if not passing parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reply_type", argType = TInterface (Name {namespace = "GLib", name = "VariantType"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the expected type of the reply, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusCallFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from the #GDBusCallFlags enumeration", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout_msec", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timeout in milliseconds, -1 to use the default\n    timeout or %G_MAXINT for no timeout", 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},Arg {argCName = "out_fd_list", argType = TInterface (Name {namespace = "Gio", name = "UnixFDList"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #GUnixFDList or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_call_with_unix_fd_list_sync" g_dbus_connection_call_with_unix_fd_list_sync :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- bus_name : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    CString ->                              -- interface_name : TBasicType TUTF8
    CString ->                              -- method_name : TBasicType TUTF8
    Ptr GVariant ->                         -- parameters : TVariant
    Ptr GLib.VariantType.VariantType ->     -- reply_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusCallFlags"})
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Gio.UnixFDList.UnixFDList ->        -- fd_list : TInterface (Name {namespace = "Gio", name = "UnixFDList"})
    Ptr (Ptr Gio.UnixFDList.UnixFDList) ->  -- out_fd_list : TInterface (Name {namespace = "Gio", name = "UnixFDList"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr GVariant)

{- |
Like 'GI.Gio.Objects.DBusConnection.dBusConnectionCallSync' but also takes and returns 'GI.Gio.Objects.UnixFDList.UnixFDList' objects.

This method is only available on UNIX.

/Since: 2.30/
-}
dBusConnectionCallWithUnixFdListSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.UnixFDList.IsUnixFDList b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (T.Text)
    {- ^ /@busName@/: a unique or well-known bus name or 'Nothing'
    if /@connection@/ is not a message bus connection -}
    -> T.Text
    {- ^ /@objectPath@/: path of remote object -}
    -> T.Text
    {- ^ /@interfaceName@/: D-Bus interface to invoke method on -}
    -> T.Text
    {- ^ /@methodName@/: the name of the method to invoke -}
    -> Maybe (GVariant)
    {- ^ /@parameters@/: a 'GVariant' tuple with parameters for
    the method or 'Nothing' if not passing parameters -}
    -> Maybe (GLib.VariantType.VariantType)
    {- ^ /@replyType@/: the expected type of the reply, or 'Nothing' -}
    -> [Gio.Flags.DBusCallFlags]
    {- ^ /@flags@/: flags from the 'GI.Gio.Flags.DBusCallFlags' enumeration -}
    -> Int32
    {- ^ /@timeoutMsec@/: the timeout in milliseconds, -1 to use the default
    timeout or @/G_MAXINT/@ for no timeout -}
    -> Maybe (b)
    {- ^ /@fdList@/: a 'GI.Gio.Objects.UnixFDList.UnixFDList' or 'Nothing' -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m ((GVariant, Gio.UnixFDList.UnixFDList))
    {- ^ __Returns:__ 'Nothing' if /@error@/ is set. Otherwise a 'GVariant' tuple with
    return values. Free with 'GI.GLib.Structs.Variant.variantUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionCallWithUnixFdListSync connection busName objectPath interfaceName methodName parameters replyType flags timeoutMsec fdList cancellable = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeBusName <- case busName of
        Nothing -> return nullPtr
        Just jBusName -> do
            jBusName' <- textToCString jBusName
            return jBusName'
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    methodName' <- textToCString methodName
    maybeParameters <- case parameters of
        Nothing -> return nullPtr
        Just jParameters -> do
            jParameters' <- unsafeManagedPtrGetPtr jParameters
            return jParameters'
    maybeReplyType <- case replyType of
        Nothing -> return nullPtr
        Just jReplyType -> do
            jReplyType' <- unsafeManagedPtrGetPtr jReplyType
            return jReplyType'
    let flags' = gflagsToWord flags
    maybeFdList <- case fdList of
        Nothing -> return nullPtr
        Just jFdList -> do
            jFdList' <- unsafeManagedPtrCastPtr jFdList
            return jFdList'
    outFdList <- allocMem :: IO (Ptr (Ptr Gio.UnixFDList.UnixFDList))
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ g_dbus_connection_call_with_unix_fd_list_sync connection' maybeBusName objectPath' interfaceName' methodName' maybeParameters maybeReplyType flags' timeoutMsec maybeFdList outFdList maybeCancellable
        checkUnexpectedReturnNULL "dBusConnectionCallWithUnixFdListSync" result
        result' <- B.GVariant.wrapGVariantPtr result
        outFdList' <- peek outFdList
        outFdList'' <- (wrapObject Gio.UnixFDList.UnixFDList) outFdList'
        touchManagedPtr connection
        whenJust parameters touchManagedPtr
        whenJust replyType touchManagedPtr
        whenJust fdList touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem maybeBusName
        freeMem objectPath'
        freeMem interfaceName'
        freeMem methodName'
        freeMem outFdList
        return (result', outFdList'')
     ) (do
        freeMem maybeBusName
        freeMem objectPath'
        freeMem interfaceName'
        freeMem methodName'
        freeMem outFdList
     )

#if ENABLE_OVERLOADING
data DBusConnectionCallWithUnixFdListSyncMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> T.Text -> T.Text -> Maybe (GVariant) -> Maybe (GLib.VariantType.VariantType) -> [Gio.Flags.DBusCallFlags] -> Int32 -> Maybe (b) -> Maybe (c) -> m ((GVariant, Gio.UnixFDList.UnixFDList))), MonadIO m, IsDBusConnection a, Gio.UnixFDList.IsUnixFDList b, Gio.Cancellable.IsCancellable c) => O.MethodInfo DBusConnectionCallWithUnixFdListSyncMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCallWithUnixFdListSync

#endif

-- method DBusConnection::close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is\n    satisfied or %NULL if you don't care about the result", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The data to pass to @callback", 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_connection_close" g_dbus_connection_close :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Closes /@connection@/. Note that this never causes the process to
exit (this might only happen if the other end of a shared message
bus connection disconnects, see 'GI.Gio.Objects.DBusConnection.DBusConnection':@/exit-on-close/@).

Once the connection is closed, operations such as sending a message
will return with the error 'GI.Gio.Enums.IOErrorEnumClosed'. Closing a connection
will not automatically flush the connection so queued messages may
be lost. Use 'GI.Gio.Objects.DBusConnection.dBusConnectionFlush' if you need such guarantees.

If /@connection@/ is already closed, this method fails with
'GI.Gio.Enums.IOErrorEnumClosed'.

When /@connection@/ has been closed, the 'GI.Gio.Objects.DBusConnection.DBusConnection'::@/closed/@
signal is emitted in the
[thread-default main context][g-main-context-push-thread-default]
of the thread that /@connection@/ was constructed in.

This is an asynchronous method. When the operation is finished,
/@callback@/ will be invoked in the
[thread-default main context][g-main-context-push-thread-default]
of the thread you are calling this method from. You can
then call 'GI.Gio.Objects.DBusConnection.dBusConnectionCloseFinish' to get the result of the
operation. See 'GI.Gio.Objects.DBusConnection.dBusConnectionCloseSync' for the synchronous
version.

/Since: 2.26/
-}
dBusConnectionClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is
    satisfied or 'Nothing' if you don\'t care about the result -}
    -> m ()
dBusConnectionClose connection cancellable callback = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_dbus_connection_close connection' maybeCancellable maybeCallback userData
    touchManagedPtr connection
    whenJust cancellable touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionCloseMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DBusConnectionCloseMethodInfo a signature where
    overloadedMethod _ = dBusConnectionClose

#endif

-- method DBusConnection::close_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult obtained from the #GAsyncReadyCallback passed\n    to g_dbus_connection_close()", 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_connection_close_finish" g_dbus_connection_close_finish :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Finishes an operation started with 'GI.Gio.Objects.DBusConnection.dBusConnectionClose'.

/Since: 2.26/
-}
dBusConnectionCloseFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@res@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback' passed
    to 'GI.Gio.Objects.DBusConnection.dBusConnectionClose' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionCloseFinish connection res = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    res' <- unsafeManagedPtrCastPtr res
    onException (do
        _ <- propagateGError $ g_dbus_connection_close_finish connection' res'
        touchManagedPtr connection
        touchManagedPtr res
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusConnectionCloseFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DBusConnectionCloseFinishMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCloseFinish

#endif

-- method DBusConnection::close_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", 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_connection_close_sync" g_dbus_connection_close_sync :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Synchronously closes /@connection@/. The calling thread is blocked
until this is done. See 'GI.Gio.Objects.DBusConnection.dBusConnectionClose' for the
asynchronous version of this method and more details about what it
does.

/Since: 2.26/
-}
dBusConnectionCloseSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionCloseSync connection cancellable = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ g_dbus_connection_close_sync connection' maybeCancellable
        touchManagedPtr connection
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusConnectionCloseSyncMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DBusConnectionCloseSyncMethodInfo a signature where
    overloadedMethod _ = dBusConnectionCloseSync

#endif

-- method DBusConnection::emit_signal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destination_bus_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the unique bus name for the destination\n    for the signal or %NULL to emit to all listeners", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "path of remote object", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "D-Bus interface to emit a signal on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signal_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the signal to emit", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GVariant tuple with parameters for the signal\n             or %NULL if not passing parameters", 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_connection_emit_signal" g_dbus_connection_emit_signal :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- destination_bus_name : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    CString ->                              -- interface_name : TBasicType TUTF8
    CString ->                              -- signal_name : TBasicType TUTF8
    Ptr GVariant ->                         -- parameters : TVariant
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Emits a signal.

If the parameters GVariant is floating, it is consumed.

This can only fail if /@parameters@/ is not compatible with the D-Bus protocol
('GI.Gio.Enums.IOErrorEnumInvalidArgument'), or if /@connection@/ has been closed
('GI.Gio.Enums.IOErrorEnumClosed').

/Since: 2.26/
-}
dBusConnectionEmitSignal ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (T.Text)
    {- ^ /@destinationBusName@/: the unique bus name for the destination
    for the signal or 'Nothing' to emit to all listeners -}
    -> T.Text
    {- ^ /@objectPath@/: path of remote object -}
    -> T.Text
    {- ^ /@interfaceName@/: D-Bus interface to emit a signal on -}
    -> T.Text
    {- ^ /@signalName@/: the name of the signal to emit -}
    -> Maybe (GVariant)
    {- ^ /@parameters@/: a 'GVariant' tuple with parameters for the signal
             or 'Nothing' if not passing parameters -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionEmitSignal connection destinationBusName objectPath interfaceName signalName parameters = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeDestinationBusName <- case destinationBusName of
        Nothing -> return nullPtr
        Just jDestinationBusName -> do
            jDestinationBusName' <- textToCString jDestinationBusName
            return jDestinationBusName'
    objectPath' <- textToCString objectPath
    interfaceName' <- textToCString interfaceName
    signalName' <- textToCString signalName
    maybeParameters <- case parameters of
        Nothing -> return nullPtr
        Just jParameters -> do
            jParameters' <- unsafeManagedPtrGetPtr jParameters
            return jParameters'
    onException (do
        _ <- propagateGError $ g_dbus_connection_emit_signal connection' maybeDestinationBusName objectPath' interfaceName' signalName' maybeParameters
        touchManagedPtr connection
        whenJust parameters touchManagedPtr
        freeMem maybeDestinationBusName
        freeMem objectPath'
        freeMem interfaceName'
        freeMem signalName'
        return ()
     ) (do
        freeMem maybeDestinationBusName
        freeMem objectPath'
        freeMem interfaceName'
        freeMem signalName'
     )

#if ENABLE_OVERLOADING
data DBusConnectionEmitSignalMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> T.Text -> T.Text -> Maybe (GVariant) -> m ()), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionEmitSignalMethodInfo a signature where
    overloadedMethod _ = dBusConnectionEmitSignal

#endif

-- method DBusConnection::export_action_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a D-Bus object path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "action_group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GActionGroup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_export_action_group" g_dbus_connection_export_action_group :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- object_path : TBasicType TUTF8
    Ptr Gio.ActionGroup.ActionGroup ->      -- action_group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
    Ptr (Ptr GError) ->                     -- error
    IO Word32

{- |
Exports /@actionGroup@/ on /@connection@/ at /@objectPath@/.

The implemented D-Bus API should be considered private.  It is
subject to change in the future.

A given object path can only have one action group exported on it.
If this constraint is violated, the export will fail and 0 will be
returned (with /@error@/ set accordingly).

You can unexport the action group using
'GI.Gio.Objects.DBusConnection.dBusConnectionUnexportActionGroup' with the return value of
this function.

The thread default main context is taken at the time of this call.
All incoming action activations and state change requests are
reported from this context.  Any changes on the action group that
cause it to emit signals must also come from this same context.
Since incoming action activations and state change requests are
rather likely to cause changes on the action group, this effectively
limits a given action group to being exported from only one main
context.

/Since: 2.32/
-}
dBusConnectionExportActionGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.ActionGroup.IsActionGroup b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> T.Text
    {- ^ /@objectPath@/: a D-Bus object path -}
    -> b
    {- ^ /@actionGroup@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup' -}
    -> m Word32
    {- ^ __Returns:__ the ID of the export (never zero), or 0 in case of failure /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionExportActionGroup connection objectPath actionGroup = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    objectPath' <- textToCString objectPath
    actionGroup' <- unsafeManagedPtrCastPtr actionGroup
    onException (do
        result <- propagateGError $ g_dbus_connection_export_action_group connection' objectPath' actionGroup'
        touchManagedPtr connection
        touchManagedPtr actionGroup
        freeMem objectPath'
        return result
     ) (do
        freeMem objectPath'
     )

#if ENABLE_OVERLOADING
data DBusConnectionExportActionGroupMethodInfo
instance (signature ~ (T.Text -> b -> m Word32), MonadIO m, IsDBusConnection a, Gio.ActionGroup.IsActionGroup b) => O.MethodInfo DBusConnectionExportActionGroupMethodInfo a signature where
    overloadedMethod _ = dBusConnectionExportActionGroup

#endif

-- method DBusConnection::export_menu_model
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a D-Bus object path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "menu", argType = TInterface (Name {namespace = "Gio", name = "MenuModel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMenuModel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_export_menu_model" g_dbus_connection_export_menu_model :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- object_path : TBasicType TUTF8
    Ptr Gio.MenuModel.MenuModel ->          -- menu : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    Ptr (Ptr GError) ->                     -- error
    IO Word32

{- |
Exports /@menu@/ on /@connection@/ at /@objectPath@/.

The implemented D-Bus API should be considered private.
It is subject to change in the future.

An object path can only have one menu model exported on it. If this
constraint is violated, the export will fail and 0 will be
returned (with /@error@/ set accordingly).

You can unexport the menu model using
'GI.Gio.Objects.DBusConnection.dBusConnectionUnexportMenuModel' with the return value of
this function.

/Since: 2.32/
-}
dBusConnectionExportMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.MenuModel.IsMenuModel b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> T.Text
    {- ^ /@objectPath@/: a D-Bus object path -}
    -> b
    {- ^ /@menu@/: a 'GI.Gio.Objects.MenuModel.MenuModel' -}
    -> m Word32
    {- ^ __Returns:__ the ID of the export (never zero), or 0 in case of failure /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionExportMenuModel connection objectPath menu = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    objectPath' <- textToCString objectPath
    menu' <- unsafeManagedPtrCastPtr menu
    onException (do
        result <- propagateGError $ g_dbus_connection_export_menu_model connection' objectPath' menu'
        touchManagedPtr connection
        touchManagedPtr menu
        freeMem objectPath'
        return result
     ) (do
        freeMem objectPath'
     )

#if ENABLE_OVERLOADING
data DBusConnectionExportMenuModelMethodInfo
instance (signature ~ (T.Text -> b -> m Word32), MonadIO m, IsDBusConnection a, Gio.MenuModel.IsMenuModel b) => O.MethodInfo DBusConnectionExportMenuModelMethodInfo a signature where
    overloadedMethod _ = dBusConnectionExportMenuModel

#endif

-- method DBusConnection::flush
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the\n    request is satisfied or %NULL if you don't care about the result", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The data to pass to @callback", 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_connection_flush" g_dbus_connection_flush :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously flushes /@connection@/, that is, writes all queued
outgoing message to the transport and then flushes the transport
(using 'GI.Gio.Objects.OutputStream.outputStreamFlushAsync'). This is useful in programs
that wants to emit a D-Bus signal and then exit immediately. Without
flushing the connection, there is no guaranteed that the message has
been sent to the networking buffers in the OS kernel.

This is an asynchronous method. When the operation is finished,
/@callback@/ will be invoked in the
[thread-default main context][g-main-context-push-thread-default]
of the thread you are calling this method from. You can
then call 'GI.Gio.Objects.DBusConnection.dBusConnectionFlushFinish' to get the result of the
operation. See 'GI.Gio.Objects.DBusConnection.dBusConnectionFlushSync' for the synchronous
version.

/Since: 2.26/
-}
dBusConnectionFlush ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the
    request is satisfied or 'Nothing' if you don\'t care about the result -}
    -> m ()
dBusConnectionFlush connection cancellable callback = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_dbus_connection_flush connection' maybeCancellable maybeCallback userData
    touchManagedPtr connection
    whenJust cancellable touchManagedPtr
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionFlushMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DBusConnectionFlushMethodInfo a signature where
    overloadedMethod _ = dBusConnectionFlush

#endif

-- method DBusConnection::flush_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult obtained from the #GAsyncReadyCallback passed\n    to g_dbus_connection_flush()", 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_connection_flush_finish" g_dbus_connection_flush_finish :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Finishes an operation started with 'GI.Gio.Objects.DBusConnection.dBusConnectionFlush'.

/Since: 2.26/
-}
dBusConnectionFlushFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@res@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback' passed
    to 'GI.Gio.Objects.DBusConnection.dBusConnectionFlush' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionFlushFinish connection res = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    res' <- unsafeManagedPtrCastPtr res
    onException (do
        _ <- propagateGError $ g_dbus_connection_flush_finish connection' res'
        touchManagedPtr connection
        touchManagedPtr res
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusConnectionFlushFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DBusConnectionFlushFinishMethodInfo a signature where
    overloadedMethod _ = dBusConnectionFlushFinish

#endif

-- method DBusConnection::flush_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", 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_connection_flush_sync" g_dbus_connection_flush_sync :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Synchronously flushes /@connection@/. The calling thread is blocked
until this is done. See 'GI.Gio.Objects.DBusConnection.dBusConnectionFlush' for the
asynchronous version of this method and more details about what it
does.

/Since: 2.26/
-}
dBusConnectionFlushSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionFlushSync connection cancellable = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ g_dbus_connection_flush_sync connection' maybeCancellable
        touchManagedPtr connection
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusConnectionFlushSyncMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDBusConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DBusConnectionFlushSyncMethodInfo a signature where
    overloadedMethod _ = dBusConnectionFlushSync

#endif

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

foreign import ccall "g_dbus_connection_get_capabilities" g_dbus_connection_get_capabilities :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO CUInt

{- |
Gets the capabilities negotiated with the remote peer

/Since: 2.26/
-}
dBusConnectionGetCapabilities ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m [Gio.Flags.DBusCapabilityFlags]
    {- ^ __Returns:__ zero or more flags from the 'GI.Gio.Flags.DBusCapabilityFlags' enumeration -}
dBusConnectionGetCapabilities connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_capabilities connection'
    let result' = wordToGFlags result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionGetCapabilitiesMethodInfo
instance (signature ~ (m [Gio.Flags.DBusCapabilityFlags]), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetCapabilitiesMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetCapabilities

#endif

-- method DBusConnection::get_exit_on_close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", 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_connection_get_exit_on_close" g_dbus_connection_get_exit_on_close :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO CInt

{- |
Gets whether the process is terminated when /@connection@/ is
closed by the remote peer. See
'GI.Gio.Objects.DBusConnection.DBusConnection':@/exit-on-close/@ for more details.

/Since: 2.26/
-}
dBusConnectionGetExitOnClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m Bool
    {- ^ __Returns:__ whether the process is terminated when /@connection@/ is
    closed by the remote peer -}
dBusConnectionGetExitOnClose connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_exit_on_close connection'
    let result' = (/= 0) result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionGetExitOnCloseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetExitOnCloseMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetExitOnClose

#endif

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

foreign import ccall "g_dbus_connection_get_flags" g_dbus_connection_get_flags :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO CUInt

{- |
Gets the flags used to construct this connection

/Since: 2.60/
-}
dBusConnectionGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m [Gio.Flags.DBusConnectionFlags]
    {- ^ __Returns:__ zero or more flags from the 'GI.Gio.Flags.DBusConnectionFlags' enumeration -}
dBusConnectionGetFlags connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_flags connection'
    let result' = wordToGFlags result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionGetFlagsMethodInfo
instance (signature ~ (m [Gio.Flags.DBusConnectionFlags]), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetFlagsMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetFlags

#endif

-- method DBusConnection::get_guid
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", 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_connection_get_guid" g_dbus_connection_get_guid :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO CString

{- |
The GUID of the peer performing the role of server when
authenticating. See 'GI.Gio.Objects.DBusConnection.DBusConnection':@/guid/@ for more details.

/Since: 2.26/
-}
dBusConnectionGetGuid ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m T.Text
    {- ^ __Returns:__ The GUID. Do not free this string, it is owned by
    /@connection@/. -}
dBusConnectionGetGuid connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_guid connection'
    checkUnexpectedReturnNULL "dBusConnectionGetGuid" result
    result' <- cstringToText result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionGetGuidMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetGuidMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetGuid

#endif

-- method DBusConnection::get_last_serial
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", 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_connection_get_last_serial" g_dbus_connection_get_last_serial :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO Word32

{- |
Retrieves the last serial number assigned to a 'GI.Gio.Objects.DBusMessage.DBusMessage' on
the current thread. This includes messages sent via both low-level
API such as 'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessage' as well as
high-level API such as 'GI.Gio.Objects.DBusConnection.dBusConnectionEmitSignal',
'GI.Gio.Objects.DBusConnection.dBusConnectionCall' or 'GI.Gio.Objects.DBusProxy.dBusProxyCall'.

/Since: 2.34/
-}
dBusConnectionGetLastSerial ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m Word32
    {- ^ __Returns:__ the last used serial or zero when no message has been sent
    within the current thread -}
dBusConnectionGetLastSerial connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_last_serial connection'
    touchManagedPtr connection
    return result

#if ENABLE_OVERLOADING
data DBusConnectionGetLastSerialMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetLastSerialMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetLastSerial

#endif

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

foreign import ccall "g_dbus_connection_get_peer_credentials" g_dbus_connection_get_peer_credentials :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO (Ptr Gio.Credentials.Credentials)

{- |
Gets the credentials of the authenticated peer. This will always
return 'Nothing' unless /@connection@/ acted as a server
(e.g. 'GI.Gio.Flags.DBusConnectionFlagsAuthenticationServer' was passed)
when set up and the client passed credentials as part of the
authentication process.

In a message bus setup, the message bus is always the server and
each application is a client. So this method will always return
'Nothing' for message bus clients.

/Since: 2.26/
-}
dBusConnectionGetPeerCredentials ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m (Maybe Gio.Credentials.Credentials)
    {- ^ __Returns:__ a 'GI.Gio.Objects.Credentials.Credentials' or 'Nothing' if not
    available. Do not free this object, it is owned by /@connection@/. -}
dBusConnectionGetPeerCredentials connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_peer_credentials connection'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gio.Credentials.Credentials) result'
        return result''
    touchManagedPtr connection
    return maybeResult

#if ENABLE_OVERLOADING
data DBusConnectionGetPeerCredentialsMethodInfo
instance (signature ~ (m (Maybe Gio.Credentials.Credentials)), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetPeerCredentialsMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetPeerCredentials

#endif

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

foreign import ccall "g_dbus_connection_get_stream" g_dbus_connection_get_stream :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO (Ptr Gio.IOStream.IOStream)

{- |
Gets the underlying stream used for IO.

While the 'GI.Gio.Objects.DBusConnection.DBusConnection' is active, it will interact with this
stream from a worker thread, so it is not safe to interact with
the stream directly.

/Since: 2.26/
-}
dBusConnectionGetStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m Gio.IOStream.IOStream
    {- ^ __Returns:__ the stream used for IO -}
dBusConnectionGetStream connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_stream connection'
    checkUnexpectedReturnNULL "dBusConnectionGetStream" result
    result' <- (newObject Gio.IOStream.IOStream) result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionGetStreamMethodInfo
instance (signature ~ (m Gio.IOStream.IOStream), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetStreamMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetStream

#endif

-- method DBusConnection::get_unique_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", 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_connection_get_unique_name" g_dbus_connection_get_unique_name :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO CString

{- |
Gets the unique name of /@connection@/ as assigned by the message
bus. This can also be used to figure out if /@connection@/ is a
message bus connection.

/Since: 2.26/
-}
dBusConnectionGetUniqueName ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the unique name or 'Nothing' if /@connection@/ is not a message
    bus connection. Do not free this string, it is owned by
    /@connection@/. -}
dBusConnectionGetUniqueName connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_get_unique_name connection'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr connection
    return maybeResult

#if ENABLE_OVERLOADING
data DBusConnectionGetUniqueNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionGetUniqueNameMethodInfo a signature where
    overloadedMethod _ = dBusConnectionGetUniqueName

#endif

-- method DBusConnection::is_closed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", 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_connection_is_closed" g_dbus_connection_is_closed :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO CInt

{- |
Gets whether /@connection@/ is closed.

/Since: 2.26/
-}
dBusConnectionIsClosed ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the connection is closed, 'False' otherwise -}
dBusConnectionIsClosed connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_is_closed connection'
    let result' = (/= 0) result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionIsClosedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionIsClosedMethodInfo a signature where
    overloadedMethod _ = dBusConnectionIsClosed

#endif

-- method DBusConnection::register_object
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusConnection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The object path to register at.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_info", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Introspection data for the interface.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method_call_closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GClosure for handling incoming method calls.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "get_property_closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GClosure for getting a property.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "set_property_closure", argType = TGClosure Nothing, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "#GClosure for setting a property.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_register_object_with_closures" g_dbus_connection_register_object_with_closures :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- object_path : TBasicType TUTF8
    Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo -> -- interface_info : TInterface (Name {namespace = "Gio", name = "DBusInterfaceInfo"})
    Ptr (GClosure ()) ->                    -- method_call_closure : TGClosure Nothing
    Ptr (GClosure ()) ->                    -- get_property_closure : TGClosure Nothing
    Ptr (GClosure ()) ->                    -- set_property_closure : TGClosure Nothing
    Ptr (Ptr GError) ->                     -- error
    IO Word32

{- |
Version of @/g_dbus_connection_register_object()/@ using closures instead of a
'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable' for easier binding in other languages.

/Since: 2.46/
-}
dBusConnectionRegisterObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection'. -}
    -> T.Text
    {- ^ /@objectPath@/: The object path to register at. -}
    -> Gio.DBusInterfaceInfo.DBusInterfaceInfo
    {- ^ /@interfaceInfo@/: Introspection data for the interface. -}
    -> Maybe (GClosure b)
    {- ^ /@methodCallClosure@/: 'GI.GObject.Structs.Closure.Closure' for handling incoming method calls. -}
    -> Maybe (GClosure c)
    {- ^ /@getPropertyClosure@/: 'GI.GObject.Structs.Closure.Closure' for getting a property. -}
    -> Maybe (GClosure d)
    {- ^ /@setPropertyClosure@/: 'GI.GObject.Structs.Closure.Closure' for setting a property. -}
    -> m Word32
    {- ^ __Returns:__ 0 if /@error@/ is set, otherwise a registration id (never 0)
that can be used with 'GI.Gio.Objects.DBusConnection.dBusConnectionUnregisterObject' . /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionRegisterObject connection objectPath interfaceInfo methodCallClosure getPropertyClosure setPropertyClosure = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    objectPath' <- textToCString objectPath
    interfaceInfo' <- unsafeManagedPtrGetPtr interfaceInfo
    maybeMethodCallClosure <- case methodCallClosure of
        Nothing -> return nullPtr
        Just jMethodCallClosure -> do
            jMethodCallClosure' <- unsafeManagedPtrCastPtr jMethodCallClosure
            return jMethodCallClosure'
    maybeGetPropertyClosure <- case getPropertyClosure of
        Nothing -> return nullPtr
        Just jGetPropertyClosure -> do
            jGetPropertyClosure' <- unsafeManagedPtrCastPtr jGetPropertyClosure
            return jGetPropertyClosure'
    maybeSetPropertyClosure <- case setPropertyClosure of
        Nothing -> return nullPtr
        Just jSetPropertyClosure -> do
            jSetPropertyClosure' <- unsafeManagedPtrCastPtr jSetPropertyClosure
            return jSetPropertyClosure'
    onException (do
        result <- propagateGError $ g_dbus_connection_register_object_with_closures connection' objectPath' interfaceInfo' maybeMethodCallClosure maybeGetPropertyClosure maybeSetPropertyClosure
        touchManagedPtr connection
        touchManagedPtr interfaceInfo
        whenJust methodCallClosure touchManagedPtr
        whenJust getPropertyClosure touchManagedPtr
        whenJust setPropertyClosure touchManagedPtr
        freeMem objectPath'
        return result
     ) (do
        freeMem objectPath'
     )

#if ENABLE_OVERLOADING
data DBusConnectionRegisterObjectMethodInfo
instance (signature ~ (T.Text -> Gio.DBusInterfaceInfo.DBusInterfaceInfo -> Maybe (GClosure b) -> Maybe (GClosure c) -> Maybe (GClosure d) -> m Word32), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionRegisterObjectMethodInfo a signature where
    overloadedMethod _ = dBusConnectionRegisterObject

#endif

-- method DBusConnection::register_subtree
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the object path to register the subtree at", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vtable", argType = TInterface (Name {namespace = "Gio", name = "DBusSubtreeVTable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusSubtreeVTable to enumerate, introspect and\n    dispatch nodes in the subtree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusSubtreeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags used to fine tune the behavior of the subtree", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to functions in @vtable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to call when the subtree is unregistered", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_register_subtree" g_dbus_connection_register_subtree :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- object_path : TBasicType TUTF8
    Ptr Gio.DBusSubtreeVTable.DBusSubtreeVTable -> -- vtable : TInterface (Name {namespace = "Gio", name = "DBusSubtreeVTable"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusSubtreeFlags"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    Ptr (Ptr GError) ->                     -- error
    IO Word32

{- |
Registers a whole subtree of dynamic objects.

The /@enumerate@/ and /@introspection@/ functions in /@vtable@/ are used to
convey, to remote callers, what nodes exist in the subtree rooted
by /@objectPath@/.

When handling remote calls into any node in the subtree, first the
/@enumerate@/ function is used to check if the node exists. If the node exists
or the @/G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES/@ flag is set
the /@introspection@/ function is used to check if the node supports the
requested method. If so, the /@dispatch@/ function is used to determine
where to dispatch the call. The collected 'GI.Gio.Structs.DBusInterfaceVTable.DBusInterfaceVTable' and
@/gpointer/@ will be used to call into the interface vtable for processing
the request.

All calls into user-provided code will be invoked in the
[thread-default main context][g-main-context-push-thread-default]
of the thread you are calling this method from.

If an existing subtree is already registered at /@objectPath@/ or
then /@error@/ is set to @/G_IO_ERROR_EXISTS/@.

Note that it is valid to register regular objects (using
@/g_dbus_connection_register_object()/@) in a subtree registered with
'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree' - if so, the subtree handler
is tried as the last resort. One way to think about a subtree
handler is to consider it a fallback handler for object paths not
registered via @/g_dbus_connection_register_object()/@ or other bindings.

Note that /@vtable@/ will be copied so you cannot change it after
registration.

See this [server][gdbus-subtree-server] for an example of how to use
this method.

/Since: 2.26/
-}
dBusConnectionRegisterSubtree ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> T.Text
    {- ^ /@objectPath@/: the object path to register the subtree at -}
    -> Gio.DBusSubtreeVTable.DBusSubtreeVTable
    {- ^ /@vtable@/: a 'GI.Gio.Structs.DBusSubtreeVTable.DBusSubtreeVTable' to enumerate, introspect and
    dispatch nodes in the subtree -}
    -> [Gio.Flags.DBusSubtreeFlags]
    {- ^ /@flags@/: flags used to fine tune the behavior of the subtree -}
    -> Ptr ()
    {- ^ /@userData@/: data to pass to functions in /@vtable@/ -}
    -> GLib.Callbacks.DestroyNotify
    {- ^ /@userDataFreeFunc@/: function to call when the subtree is unregistered -}
    -> m Word32
    {- ^ __Returns:__ 0 if /@error@/ is set, otherwise a subtree registration id (never 0)
that can be used with 'GI.Gio.Objects.DBusConnection.dBusConnectionUnregisterSubtree' . /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionRegisterSubtree connection objectPath vtable flags userData userDataFreeFunc = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    objectPath' <- textToCString objectPath
    vtable' <- unsafeManagedPtrGetPtr vtable
    let flags' = gflagsToWord flags
    ptruserDataFreeFunc <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))
    userDataFreeFunc' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptruserDataFreeFunc) userDataFreeFunc)
    poke ptruserDataFreeFunc userDataFreeFunc'
    onException (do
        result <- propagateGError $ g_dbus_connection_register_subtree connection' objectPath' vtable' flags' userData userDataFreeFunc'
        touchManagedPtr connection
        touchManagedPtr vtable
        freeMem objectPath'
        return result
     ) (do
        freeMem objectPath'
     )

#if ENABLE_OVERLOADING
data DBusConnectionRegisterSubtreeMethodInfo
instance (signature ~ (T.Text -> Gio.DBusSubtreeVTable.DBusSubtreeVTable -> [Gio.Flags.DBusSubtreeFlags] -> Ptr () -> GLib.Callbacks.DestroyNotify -> m Word32), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionRegisterSubtreeMethodInfo a signature where
    overloadedMethod _ = dBusConnectionRegisterSubtree

#endif

-- method DBusConnection::remove_filter
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an identifier obtained from g_dbus_connection_add_filter()", 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_connection_remove_filter" g_dbus_connection_remove_filter :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Word32 ->                               -- filter_id : TBasicType TUInt
    IO ()

{- |
Removes a filter.

Note that since filters run in a different thread, there is a race
condition where it is possible that the filter will be running even
after calling 'GI.Gio.Objects.DBusConnection.dBusConnectionRemoveFilter', so you cannot just
free data that the filter might be using. Instead, you should pass
a 'GI.GLib.Callbacks.DestroyNotify' to 'GI.Gio.Objects.DBusConnection.dBusConnectionAddFilter', which will be
called when it is guaranteed that the data is no longer needed.

/Since: 2.26/
-}
dBusConnectionRemoveFilter ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Word32
    {- ^ /@filterId@/: an identifier obtained from 'GI.Gio.Objects.DBusConnection.dBusConnectionAddFilter' -}
    -> m ()
dBusConnectionRemoveFilter connection filterId = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    g_dbus_connection_remove_filter connection' filterId
    touchManagedPtr connection
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionRemoveFilterMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionRemoveFilterMethodInfo a signature where
    overloadedMethod _ = dBusConnectionRemoveFilter

#endif

-- method DBusConnection::send_message
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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 = "DBusSendMessageFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags affecting how the message is sent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_serial", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for serial number assigned\n    to @message when sending it or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_dbus_connection_send_message" g_dbus_connection_send_message :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.DBusMessage.DBusMessage ->      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusSendMessageFlags"})
    Ptr Word32 ->                           -- out_serial : TBasicType TUInt32
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Asynchronously sends /@message@/ to the peer represented by /@connection@/.

Unless /@flags@/ contain the
'GI.Gio.Flags.DBusSendMessageFlagsPreserveSerial' flag, the serial number
will be assigned by /@connection@/ and set on /@message@/ via
'GI.Gio.Objects.DBusMessage.dBusMessageSetSerial'. If /@outSerial@/ is not 'Nothing', then the
serial number used will be written to this location prior to
submitting the message to the underlying transport.

If /@connection@/ is closed then the operation will fail with
'GI.Gio.Enums.IOErrorEnumClosed'. If /@message@/ is not well-formed,
the operation fails with 'GI.Gio.Enums.IOErrorEnumInvalidArgument'.

See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
for an example of how to use this low-level API to send and receive
UNIX file descriptors.

Note that /@message@/ must be unlocked, unless /@flags@/ contain the
'GI.Gio.Flags.DBusSendMessageFlagsPreserveSerial' flag.

/Since: 2.26/
-}
dBusConnectionSendMessage ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.DBusMessage.IsDBusMessage b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@message@/: a 'GI.Gio.Objects.DBusMessage.DBusMessage' -}
    -> [Gio.Flags.DBusSendMessageFlags]
    {- ^ /@flags@/: flags affecting how the message is sent -}
    -> m (Word32)
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionSendMessage connection message flags = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    message' <- unsafeManagedPtrCastPtr message
    let flags' = gflagsToWord flags
    outSerial <- allocMem :: IO (Ptr Word32)
    onException (do
        _ <- propagateGError $ g_dbus_connection_send_message connection' message' flags' outSerial
        outSerial' <- peek outSerial
        touchManagedPtr connection
        touchManagedPtr message
        freeMem outSerial
        return outSerial'
     ) (do
        freeMem outSerial
     )

#if ENABLE_OVERLOADING
data DBusConnectionSendMessageMethodInfo
instance (signature ~ (b -> [Gio.Flags.DBusSendMessageFlags] -> m (Word32)), MonadIO m, IsDBusConnection a, Gio.DBusMessage.IsDBusMessage b) => O.MethodInfo DBusConnectionSendMessageMethodInfo a signature where
    overloadedMethod _ = dBusConnectionSendMessage

#endif

-- method DBusConnection::send_message_with_reply
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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 = "DBusSendMessageFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags affecting how the message is sent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout_msec", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timeout in milliseconds, -1 to use the default\n    timeout or %G_MAXINT for no timeout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_serial", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for serial number assigned\n    to @message when sending it or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request\n    is satisfied or %NULL if you don't care about the result", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The data to pass to @callback", 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_connection_send_message_with_reply" g_dbus_connection_send_message_with_reply :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.DBusMessage.DBusMessage ->      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusSendMessageFlags"})
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Word32 ->                           -- out_serial : TBasicType TUInt32
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously sends /@message@/ to the peer represented by /@connection@/.

Unless /@flags@/ contain the
'GI.Gio.Flags.DBusSendMessageFlagsPreserveSerial' flag, the serial number
will be assigned by /@connection@/ and set on /@message@/ via
'GI.Gio.Objects.DBusMessage.dBusMessageSetSerial'. If /@outSerial@/ is not 'Nothing', then the
serial number used will be written to this location prior to
submitting the message to the underlying transport.

If /@connection@/ is closed then the operation will fail with
'GI.Gio.Enums.IOErrorEnumClosed'. If /@cancellable@/ is canceled, the operation will
fail with 'GI.Gio.Enums.IOErrorEnumCancelled'. If /@message@/ is not well-formed,
the operation fails with 'GI.Gio.Enums.IOErrorEnumInvalidArgument'.

This is an asynchronous method. When the operation is finished, /@callback@/
will be invoked in the
[thread-default main context][g-main-context-push-thread-default]
of the thread you are calling this method from. You can then call
'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessageWithReplyFinish' to get the result of the operation.
See 'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessageWithReplySync' for the synchronous version.

Note that /@message@/ must be unlocked, unless /@flags@/ contain the
'GI.Gio.Flags.DBusSendMessageFlagsPreserveSerial' flag.

See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
for an example of how to use this low-level API to send and receive
UNIX file descriptors.

/Since: 2.26/
-}
dBusConnectionSendMessageWithReply ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.DBusMessage.IsDBusMessage b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@message@/: a 'GI.Gio.Objects.DBusMessage.DBusMessage' -}
    -> [Gio.Flags.DBusSendMessageFlags]
    {- ^ /@flags@/: flags affecting how the message is sent -}
    -> Int32
    {- ^ /@timeoutMsec@/: the timeout in milliseconds, -1 to use the default
    timeout or @/G_MAXINT/@ for no timeout -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request
    is satisfied or 'Nothing' if you don\'t care about the result -}
    -> m (Word32)
dBusConnectionSendMessageWithReply connection message flags timeoutMsec cancellable callback = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    message' <- unsafeManagedPtrCastPtr message
    let flags' = gflagsToWord flags
    outSerial <- allocMem :: IO (Ptr Word32)
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_dbus_connection_send_message_with_reply connection' message' flags' timeoutMsec outSerial maybeCancellable maybeCallback userData
    outSerial' <- peek outSerial
    touchManagedPtr connection
    touchManagedPtr message
    whenJust cancellable touchManagedPtr
    freeMem outSerial
    return outSerial'

#if ENABLE_OVERLOADING
data DBusConnectionSendMessageWithReplyMethodInfo
instance (signature ~ (b -> [Gio.Flags.DBusSendMessageFlags] -> Int32 -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m (Word32)), MonadIO m, IsDBusConnection a, Gio.DBusMessage.IsDBusMessage b, Gio.Cancellable.IsCancellable c) => O.MethodInfo DBusConnectionSendMessageWithReplyMethodInfo a signature where
    overloadedMethod _ = dBusConnectionSendMessageWithReply

#endif

-- method DBusConnection::send_message_with_reply_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult obtained from the #GAsyncReadyCallback passed to\n    g_dbus_connection_send_message_with_reply()", 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_connection_send_message_with_reply_finish" g_dbus_connection_send_message_with_reply_finish :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.DBusMessage.DBusMessage)

{- |
Finishes an operation started with 'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessageWithReply'.

Note that /@error@/ is only set if a local in-process error
occurred. That is to say that the returned 'GI.Gio.Objects.DBusMessage.DBusMessage' object may
be of type 'GI.Gio.Enums.DBusMessageTypeError'. Use
'GI.Gio.Objects.DBusMessage.dBusMessageToGerror' to transcode this to a 'GError'.

See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
for an example of how to use this low-level API to send and receive
UNIX file descriptors.

/Since: 2.26/
-}
dBusConnectionSendMessageWithReplyFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@res@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the 'GI.Gio.Callbacks.AsyncReadyCallback' passed to
    'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessageWithReply' -}
    -> m Gio.DBusMessage.DBusMessage
    {- ^ __Returns:__ a locked 'GI.Gio.Objects.DBusMessage.DBusMessage' or 'Nothing' if /@error@/ is set /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionSendMessageWithReplyFinish connection res = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    res' <- unsafeManagedPtrCastPtr res
    onException (do
        result <- propagateGError $ g_dbus_connection_send_message_with_reply_finish connection' res'
        checkUnexpectedReturnNULL "dBusConnectionSendMessageWithReplyFinish" result
        result' <- (wrapObject Gio.DBusMessage.DBusMessage) result
        touchManagedPtr connection
        touchManagedPtr res
        return result'
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data DBusConnectionSendMessageWithReplyFinishMethodInfo
instance (signature ~ (b -> m Gio.DBusMessage.DBusMessage), MonadIO m, IsDBusConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DBusConnectionSendMessageWithReplyFinishMethodInfo a signature where
    overloadedMethod _ = dBusConnectionSendMessageWithReplyFinish

#endif

-- method DBusConnection::send_message_with_reply_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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 = "DBusSendMessageFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags affecting how the message is sent.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout_msec", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timeout in milliseconds, -1 to use the default\n    timeout or %G_MAXINT for no timeout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_serial", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for serial number\n    assigned to @message when sending it or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", 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_connection_send_message_with_reply_sync" g_dbus_connection_send_message_with_reply_sync :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.DBusMessage.DBusMessage ->      -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusSendMessageFlags"})
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Word32 ->                           -- out_serial : TBasicType TUInt32
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.DBusMessage.DBusMessage)

{- |
Synchronously sends /@message@/ to the peer represented by /@connection@/
and blocks the calling thread until a reply is received or the
timeout is reached. See 'GI.Gio.Objects.DBusConnection.dBusConnectionSendMessageWithReply'
for the asynchronous version of this method.

Unless /@flags@/ contain the
'GI.Gio.Flags.DBusSendMessageFlagsPreserveSerial' flag, the serial number
will be assigned by /@connection@/ and set on /@message@/ via
'GI.Gio.Objects.DBusMessage.dBusMessageSetSerial'. If /@outSerial@/ is not 'Nothing', then the
serial number used will be written to this location prior to
submitting the message to the underlying transport.

If /@connection@/ is closed then the operation will fail with
'GI.Gio.Enums.IOErrorEnumClosed'. If /@cancellable@/ is canceled, the operation will
fail with 'GI.Gio.Enums.IOErrorEnumCancelled'. If /@message@/ is not well-formed,
the operation fails with 'GI.Gio.Enums.IOErrorEnumInvalidArgument'.

Note that /@error@/ is only set if a local in-process error
occurred. That is to say that the returned 'GI.Gio.Objects.DBusMessage.DBusMessage' object may
be of type 'GI.Gio.Enums.DBusMessageTypeError'. Use
'GI.Gio.Objects.DBusMessage.dBusMessageToGerror' to transcode this to a 'GError'.

See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
for an example of how to use this low-level API to send and receive
UNIX file descriptors.

Note that /@message@/ must be unlocked, unless /@flags@/ contain the
'GI.Gio.Flags.DBusSendMessageFlagsPreserveSerial' flag.

/Since: 2.26/
-}
dBusConnectionSendMessageWithReplySync ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a, Gio.DBusMessage.IsDBusMessage b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> b
    {- ^ /@message@/: a 'GI.Gio.Objects.DBusMessage.DBusMessage' -}
    -> [Gio.Flags.DBusSendMessageFlags]
    {- ^ /@flags@/: flags affecting how the message is sent. -}
    -> Int32
    {- ^ /@timeoutMsec@/: the timeout in milliseconds, -1 to use the default
    timeout or @/G_MAXINT/@ for no timeout -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m ((Gio.DBusMessage.DBusMessage, Word32))
    {- ^ __Returns:__ a locked 'GI.Gio.Objects.DBusMessage.DBusMessage' that is the reply
    to /@message@/ or 'Nothing' if /@error@/ is set /(Can throw 'Data.GI.Base.GError.GError')/ -}
dBusConnectionSendMessageWithReplySync connection message flags timeoutMsec cancellable = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    message' <- unsafeManagedPtrCastPtr message
    let flags' = gflagsToWord flags
    outSerial <- allocMem :: IO (Ptr Word32)
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ g_dbus_connection_send_message_with_reply_sync connection' message' flags' timeoutMsec outSerial maybeCancellable
        checkUnexpectedReturnNULL "dBusConnectionSendMessageWithReplySync" result
        result' <- (wrapObject Gio.DBusMessage.DBusMessage) result
        outSerial' <- peek outSerial
        touchManagedPtr connection
        touchManagedPtr message
        whenJust cancellable touchManagedPtr
        freeMem outSerial
        return (result', outSerial')
     ) (do
        freeMem outSerial
     )

#if ENABLE_OVERLOADING
data DBusConnectionSendMessageWithReplySyncMethodInfo
instance (signature ~ (b -> [Gio.Flags.DBusSendMessageFlags] -> Int32 -> Maybe (c) -> m ((Gio.DBusMessage.DBusMessage, Word32))), MonadIO m, IsDBusConnection a, Gio.DBusMessage.IsDBusMessage b, Gio.Cancellable.IsCancellable c) => O.MethodInfo DBusConnectionSendMessageWithReplySyncMethodInfo a signature where
    overloadedMethod _ = dBusConnectionSendMessageWithReplySync

#endif

-- method DBusConnection::set_exit_on_close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exit_on_close", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the process should be terminated\n    when @connection is closed by the remote peer", 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_connection_set_exit_on_close" g_dbus_connection_set_exit_on_close :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CInt ->                                 -- exit_on_close : TBasicType TBoolean
    IO ()

{- |
Sets whether the process should be terminated when /@connection@/ is
closed by the remote peer. See 'GI.Gio.Objects.DBusConnection.DBusConnection':@/exit-on-close/@ for
more details.

Note that this function should be used with care. Most modern UNIX
desktops tie the notion of a user session the session bus, and expect
all of a users applications to quit when their bus connection goes away.
If you are setting /@exitOnClose@/ to 'False' for the shared session
bus connection, you should make sure that your application exits
when the user session ends.

/Since: 2.26/
-}
dBusConnectionSetExitOnClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Bool
    {- ^ /@exitOnClose@/: whether the process should be terminated
    when /@connection@/ is closed by the remote peer -}
    -> m ()
dBusConnectionSetExitOnClose connection exitOnClose = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    let exitOnClose' = (fromIntegral . fromEnum) exitOnClose
    g_dbus_connection_set_exit_on_close connection' exitOnClose'
    touchManagedPtr connection
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionSetExitOnCloseMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionSetExitOnCloseMethodInfo a signature where
    overloadedMethod _ = dBusConnectionSetExitOnClose

#endif

-- method DBusConnection::signal_subscribe
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sender", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "sender name to match on (unique or well-known name)\n    or %NULL to listen from all senders", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "D-Bus interface name to match on or %NULL to\n    match on all interfaces", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "member", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "D-Bus signal name to match on or %NULL to match on\n    all signals", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "object path to match on or %NULL to match on\n    all object paths", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "arg0", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "contents of first string argument to match on or %NULL\n    to match on all kinds of arguments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusSignalFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GDBusSignalFlags describing how arg0 is used in subscribing to the\n    signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "DBusSignalCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "callback to invoke when there is a signal matching the requested data", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 8, argDestroy = 9, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data_free_func", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function to free @user_data with when\n    subscription is removed or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_dbus_connection_signal_subscribe" g_dbus_connection_signal_subscribe :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    CString ->                              -- sender : TBasicType TUTF8
    CString ->                              -- interface_name : TBasicType TUTF8
    CString ->                              -- member : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    CString ->                              -- arg0 : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusSignalFlags"})
    FunPtr Gio.Callbacks.C_DBusSignalCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "DBusSignalCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- user_data_free_func : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO Word32

{- |
Subscribes to signals on /@connection@/ and invokes /@callback@/ with a whenever
the signal is received. Note that /@callback@/ will be invoked in the
[thread-default main context][g-main-context-push-thread-default]
of the thread you are calling this method from.

If /@connection@/ is not a message bus connection, /@sender@/ must be
'Nothing'.

If /@sender@/ is a well-known name note that /@callback@/ is invoked with
the unique name for the owner of /@sender@/, not the well-known name
as one would expect. This is because the message bus rewrites the
name. As such, to avoid certain race conditions, users should be
tracking the name owner of the well-known name and use that when
processing the received signal.

If one of 'GI.Gio.Flags.DBusSignalFlagsMatchArg0Namespace' or
'GI.Gio.Flags.DBusSignalFlagsMatchArg0Path' are given, /@arg0@/ is
interpreted as part of a namespace or path.  The first argument
of a signal is matched against that part as specified by D-Bus.

If /@userDataFreeFunc@/ is non-'Nothing', it will be called (in the
thread-default main context of the thread you are calling this
method from) at some point after /@userData@/ is no longer
needed. (It is not guaranteed to be called synchronously when the
signal is unsubscribed from, and may be called after /@connection@/
has been destroyed.)

The returned subscription identifier is an opaque value which is guaranteed
to never be zero.

This function can never fail.

/Since: 2.26/
-}
dBusConnectionSignalSubscribe ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Maybe (T.Text)
    {- ^ /@sender@/: sender name to match on (unique or well-known name)
    or 'Nothing' to listen from all senders -}
    -> Maybe (T.Text)
    {- ^ /@interfaceName@/: D-Bus interface name to match on or 'Nothing' to
    match on all interfaces -}
    -> Maybe (T.Text)
    {- ^ /@member@/: D-Bus signal name to match on or 'Nothing' to match on
    all signals -}
    -> Maybe (T.Text)
    {- ^ /@objectPath@/: object path to match on or 'Nothing' to match on
    all object paths -}
    -> Maybe (T.Text)
    {- ^ /@arg0@/: contents of first string argument to match on or 'Nothing'
    to match on all kinds of arguments -}
    -> [Gio.Flags.DBusSignalFlags]
    {- ^ /@flags@/: 'GI.Gio.Flags.DBusSignalFlags' describing how arg0 is used in subscribing to the
    signal -}
    -> Gio.Callbacks.DBusSignalCallback
    {- ^ /@callback@/: callback to invoke when there is a signal matching the requested data -}
    -> m Word32
    {- ^ __Returns:__ a subscription identifier that can be used with 'GI.Gio.Objects.DBusConnection.dBusConnectionSignalUnsubscribe' -}
dBusConnectionSignalSubscribe connection sender interfaceName member objectPath arg0 flags callback = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    maybeSender <- case sender of
        Nothing -> return nullPtr
        Just jSender -> do
            jSender' <- textToCString jSender
            return jSender'
    maybeInterfaceName <- case interfaceName of
        Nothing -> return nullPtr
        Just jInterfaceName -> do
            jInterfaceName' <- textToCString jInterfaceName
            return jInterfaceName'
    maybeMember <- case member of
        Nothing -> return nullPtr
        Just jMember -> do
            jMember' <- textToCString jMember
            return jMember'
    maybeObjectPath <- case objectPath of
        Nothing -> return nullPtr
        Just jObjectPath -> do
            jObjectPath' <- textToCString jObjectPath
            return jObjectPath'
    maybeArg0 <- case arg0 of
        Nothing -> return nullPtr
        Just jArg0 -> do
            jArg0' <- textToCString jArg0
            return jArg0'
    let flags' = gflagsToWord flags
    callback' <- Gio.Callbacks.mk_DBusSignalCallback (Gio.Callbacks.wrap_DBusSignalCallback Nothing (Gio.Callbacks.drop_closures_DBusSignalCallback callback))
    let userData = castFunPtrToPtr callback'
    let userDataFreeFunc = safeFreeFunPtrPtr
    result <- g_dbus_connection_signal_subscribe connection' maybeSender maybeInterfaceName maybeMember maybeObjectPath maybeArg0 flags' callback' userData userDataFreeFunc
    touchManagedPtr connection
    freeMem maybeSender
    freeMem maybeInterfaceName
    freeMem maybeMember
    freeMem maybeObjectPath
    freeMem maybeArg0
    return result

#if ENABLE_OVERLOADING
data DBusConnectionSignalSubscribeMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> [Gio.Flags.DBusSignalFlags] -> Gio.Callbacks.DBusSignalCallback -> m Word32), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionSignalSubscribeMethodInfo a signature where
    overloadedMethod _ = dBusConnectionSignalSubscribe

#endif

-- method DBusConnection::signal_unsubscribe
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subscription_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a subscription id obtained from\n    g_dbus_connection_signal_subscribe()", 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_connection_signal_unsubscribe" g_dbus_connection_signal_unsubscribe :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Word32 ->                               -- subscription_id : TBasicType TUInt
    IO ()

{- |
Unsubscribes from signals.

/Since: 2.26/
-}
dBusConnectionSignalUnsubscribe ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Word32
    {- ^ /@subscriptionId@/: a subscription id obtained from
    'GI.Gio.Objects.DBusConnection.dBusConnectionSignalSubscribe' -}
    -> m ()
dBusConnectionSignalUnsubscribe connection subscriptionId = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    g_dbus_connection_signal_unsubscribe connection' subscriptionId
    touchManagedPtr connection
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionSignalUnsubscribeMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionSignalUnsubscribeMethodInfo a signature where
    overloadedMethod _ = dBusConnectionSignalUnsubscribe

#endif

-- method DBusConnection::start_message_processing
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", 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_connection_start_message_processing" g_dbus_connection_start_message_processing :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO ()

{- |
If /@connection@/ was created with
'GI.Gio.Flags.DBusConnectionFlagsDelayMessageProcessing', this method
starts processing messages. Does nothing on if /@connection@/ wasn\'t
created with this flag or if the method has already been called.

/Since: 2.26/
-}
dBusConnectionStartMessageProcessing ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> m ()
dBusConnectionStartMessageProcessing connection = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    g_dbus_connection_start_message_processing connection'
    touchManagedPtr connection
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionStartMessageProcessingMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionStartMessageProcessingMethodInfo a signature where
    overloadedMethod _ = dBusConnectionStartMessageProcessing

#endif

-- method DBusConnection::unexport_action_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "export_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the ID from g_dbus_connection_export_action_group()", 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_connection_unexport_action_group" g_dbus_connection_unexport_action_group :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Word32 ->                               -- export_id : TBasicType TUInt
    IO ()

{- |
Reverses the effect of a previous call to
'GI.Gio.Objects.DBusConnection.dBusConnectionExportActionGroup'.

It is an error to call this function with an ID that wasn\'t returned
from 'GI.Gio.Objects.DBusConnection.dBusConnectionExportActionGroup' or to call it with the
same ID more than once.

/Since: 2.32/
-}
dBusConnectionUnexportActionGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Word32
    {- ^ /@exportId@/: the ID from 'GI.Gio.Objects.DBusConnection.dBusConnectionExportActionGroup' -}
    -> m ()
dBusConnectionUnexportActionGroup connection exportId = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    g_dbus_connection_unexport_action_group connection' exportId
    touchManagedPtr connection
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionUnexportActionGroupMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionUnexportActionGroupMethodInfo a signature where
    overloadedMethod _ = dBusConnectionUnexportActionGroup

#endif

-- method DBusConnection::unexport_menu_model
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "export_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the ID from g_dbus_connection_export_menu_model()", 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_connection_unexport_menu_model" g_dbus_connection_unexport_menu_model :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Word32 ->                               -- export_id : TBasicType TUInt
    IO ()

{- |
Reverses the effect of a previous call to
'GI.Gio.Objects.DBusConnection.dBusConnectionExportMenuModel'.

It is an error to call this function with an ID that wasn\'t returned
from 'GI.Gio.Objects.DBusConnection.dBusConnectionExportMenuModel' or to call it with the
same ID more than once.

/Since: 2.32/
-}
dBusConnectionUnexportMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Word32
    {- ^ /@exportId@/: the ID from 'GI.Gio.Objects.DBusConnection.dBusConnectionExportMenuModel' -}
    -> m ()
dBusConnectionUnexportMenuModel connection exportId = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    g_dbus_connection_unexport_menu_model connection' exportId
    touchManagedPtr connection
    return ()

#if ENABLE_OVERLOADING
data DBusConnectionUnexportMenuModelMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionUnexportMenuModelMethodInfo a signature where
    overloadedMethod _ = dBusConnectionUnexportMenuModel

#endif

-- method DBusConnection::unregister_object
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "registration_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a registration id obtained from\n    g_dbus_connection_register_object()", 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_connection_unregister_object" g_dbus_connection_unregister_object :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Word32 ->                               -- registration_id : TBasicType TUInt
    IO CInt

{- |
Unregisters an object.

/Since: 2.26/
-}
dBusConnectionUnregisterObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Word32
    {- ^ /@registrationId@/: a registration id obtained from
    @/g_dbus_connection_register_object()/@ -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the object was unregistered, 'False' otherwise -}
dBusConnectionUnregisterObject connection registrationId = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_unregister_object connection' registrationId
    let result' = (/= 0) result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionUnregisterObjectMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionUnregisterObjectMethodInfo a signature where
    overloadedMethod _ = dBusConnectionUnregisterObject

#endif

-- method DBusConnection::unregister_subtree
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDBusConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "registration_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a subtree registration id obtained from\n    g_dbus_connection_register_subtree()", 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_connection_unregister_subtree" g_dbus_connection_unregister_subtree :: 
    Ptr DBusConnection ->                   -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Word32 ->                               -- registration_id : TBasicType TUInt
    IO CInt

{- |
Unregisters a subtree.

/Since: 2.26/
-}
dBusConnectionUnregisterSubtree ::
    (B.CallStack.HasCallStack, MonadIO m, IsDBusConnection a) =>
    a
    {- ^ /@connection@/: a 'GI.Gio.Objects.DBusConnection.DBusConnection' -}
    -> Word32
    {- ^ /@registrationId@/: a subtree registration id obtained from
    'GI.Gio.Objects.DBusConnection.dBusConnectionRegisterSubtree' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the subtree was unregistered, 'False' otherwise -}
dBusConnectionUnregisterSubtree connection registrationId = liftIO $ do
    connection' <- unsafeManagedPtrCastPtr connection
    result <- g_dbus_connection_unregister_subtree connection' registrationId
    let result' = (/= 0) result
    touchManagedPtr connection
    return result'

#if ENABLE_OVERLOADING
data DBusConnectionUnregisterSubtreeMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m, IsDBusConnection a) => O.MethodInfo DBusConnectionUnregisterSubtreeMethodInfo a signature where
    overloadedMethod _ = dBusConnectionUnregisterSubtree

#endif

-- method DBusConnection::new
-- method type : MemberFunction
-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "guid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the GUID to use if a authenticating as a server or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags describing how to make the connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "observer", argType = TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GDBusAuthObserver or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to @callback", 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_connection_new" g_dbus_connection_new :: 
    Ptr Gio.IOStream.IOStream ->            -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
    CString ->                              -- guid : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"})
    Ptr Gio.DBusAuthObserver.DBusAuthObserver -> -- observer : TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
with the end represented by /@stream@/.

If /@stream@/ is a 'GI.Gio.Objects.SocketConnection.SocketConnection', then the corresponding 'GI.Gio.Objects.Socket.Socket'
will be put into non-blocking mode.

The D-Bus connection will interact with /@stream@/ from a worker thread.
As a result, the caller should not interact with /@stream@/ after this
method has been called, except by calling 'GI.GObject.Objects.Object.objectUnref' on it.

If /@observer@/ is not 'Nothing' it may be used to control the
authentication process.

When the operation is finished, /@callback@/ will be invoked. You can
then call 'GI.Gio.Objects.DBusConnection.dBusConnectionNewFinish' to get the result of the
operation.

This is a asynchronous failable constructor. See
'GI.Gio.Objects.DBusConnection.dBusConnectionNewSync' for the synchronous
version.

/Since: 2.26/
-}
dBusConnectionNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.IOStream.IsIOStream a, Gio.DBusAuthObserver.IsDBusAuthObserver b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' -}
    -> Maybe (T.Text)
    {- ^ /@guid@/: the GUID to use if a authenticating as a server or 'Nothing' -}
    -> [Gio.Flags.DBusConnectionFlags]
    {- ^ /@flags@/: flags describing how to make the connection -}
    -> Maybe (b)
    {- ^ /@observer@/: a 'GI.Gio.Objects.DBusAuthObserver.DBusAuthObserver' or 'Nothing' -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
    -> m ()
dBusConnectionNew stream guid flags observer cancellable callback = liftIO $ do
    stream' <- unsafeManagedPtrCastPtr stream
    maybeGuid <- case guid of
        Nothing -> return nullPtr
        Just jGuid -> do
            jGuid' <- textToCString jGuid
            return jGuid'
    let flags' = gflagsToWord flags
    maybeObserver <- case observer of
        Nothing -> return nullPtr
        Just jObserver -> do
            jObserver' <- unsafeManagedPtrCastPtr jObserver
            return jObserver'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_dbus_connection_new stream' maybeGuid flags' maybeObserver maybeCancellable maybeCallback userData
    touchManagedPtr stream
    whenJust observer touchManagedPtr
    whenJust cancellable touchManagedPtr
    freeMem maybeGuid
    return ()

#if ENABLE_OVERLOADING
#endif

-- method DBusConnection::new_for_address
-- method type : MemberFunction
-- Args : [Arg {argCName = "address", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a D-Bus address", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags describing how to make the connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "observer", argType = TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GDBusAuthObserver or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to @callback", 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_connection_new_for_address" g_dbus_connection_new_for_address :: 
    CString ->                              -- address : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusConnectionFlags"})
    Ptr Gio.DBusAuthObserver.DBusAuthObserver -> -- observer : TInterface (Name {namespace = "Gio", name = "DBusAuthObserver"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously connects and sets up a D-Bus client connection for
exchanging D-Bus messages with an endpoint specified by /@address@/
which must be in the
<https://dbus.freedesktop.org/doc/dbus-specification.html#addresses D-Bus address format>.

This constructor can only be used to initiate client-side
connections - use 'GI.Gio.Objects.DBusConnection.dBusConnectionNew' if you need to act as the
server. In particular, /@flags@/ cannot contain the
'GI.Gio.Flags.DBusConnectionFlagsAuthenticationServer' or
'GI.Gio.Flags.DBusConnectionFlagsAuthenticationAllowAnonymous' flags.

When the operation is finished, /@callback@/ will be invoked. You can
then call 'GI.Gio.Objects.DBusConnection.dBusConnectionNewFinish' to get the result of the
operation.

If /@observer@/ is not 'Nothing' it may be used to control the
authentication process.

This is a asynchronous failable constructor. See
'GI.Gio.Objects.DBusConnection.dBusConnectionNewForAddressSync' for the synchronous
version.

/Since: 2.26/
-}
dBusConnectionNewForAddress ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusAuthObserver.IsDBusAuthObserver a, Gio.Cancellable.IsCancellable b) =>
    T.Text
    {- ^ /@address@/: a D-Bus address -}
    -> [Gio.Flags.DBusConnectionFlags]
    {- ^ /@flags@/: flags describing how to make the connection -}
    -> Maybe (a)
    {- ^ /@observer@/: a 'GI.Gio.Objects.DBusAuthObserver.DBusAuthObserver' or 'Nothing' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
    -> m ()
dBusConnectionNewForAddress address flags observer cancellable callback = liftIO $ do
    address' <- textToCString address
    let flags' = gflagsToWord flags
    maybeObserver <- case observer of
        Nothing -> return nullPtr
        Just jObserver -> do
            jObserver' <- unsafeManagedPtrCastPtr jObserver
            return jObserver'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    g_dbus_connection_new_for_address address' flags' maybeObserver maybeCancellable maybeCallback userData
    whenJust observer touchManagedPtr
    whenJust cancellable touchManagedPtr
    freeMem address'
    return ()

#if ENABLE_OVERLOADING
#endif