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

    The '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 \
           (!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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.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 => IsDBusConnection o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DBusConnection a) =>
        IsDBusConnection a
    #endif
    instance IsDBusConnection DBusConnection
    instance GObject.Object.IsObject DBusConnection
    instance Gio.AsyncInitable.IsAsyncInitable DBusConnection
    instance Gio.Initable.IsInitable DBusConnection

    -- | 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) => O.IsLabelProxy t (DBusConnection -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveDBusConnectionMethod t DBusConnection, O.MethodInfo info DBusConnection p) => O.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

    #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 `Closure`.
    genClosure_DBusConnectionClosed :: DBusConnectionClosedCallback -> IO Closure
    genClosure_DBusConnectionClosed cb = do
        let cb' = wrap_DBusConnectionClosedCallback cb
        mk_DBusConnectionClosedCallback cb' >>= newCClosure

    -- | 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 = 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 = 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 $ 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 $ 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 $ 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 $ 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 = 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 $ 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 = 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" $ 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 = 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" $ 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 = 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 $ 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 = TInterface (Name {namespace = "GObject", name = "Closure"}), 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 = TInterface (Name {namespace = "GObject", name = "Closure"}), 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 = TInterface (Name {namespace = "GObject", name = "Closure"}), 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 Closure ->                          -- method_call_closure : TInterface (Name {namespace = "GObject", name = "Closure"})
        Ptr Closure ->                          -- get_property_closure : TInterface (Name {namespace = "GObject", name = "Closure"})
        Ptr Closure ->                          -- set_property_closure : TInterface (Name {namespace = "GObject", name = "Closure"})
        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 (Closure)
        {- ^ /@methodCallClosure@/: 'GI.GObject.Structs.Closure.Closure' for handling incoming method calls. -}
        -> Maybe (Closure)
        {- ^ /@getPropertyClosure@/: 'GI.GObject.Structs.Closure.Closure' for getting a property. -}
        -> Maybe (Closure)
        {- ^ /@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' <- unsafeManagedPtrGetPtr jMethodCallClosure
                return jMethodCallClosure'
        maybeGetPropertyClosure <- case getPropertyClosure of
            Nothing -> return nullPtr
            Just jGetPropertyClosure -> do
                jGetPropertyClosure' <- unsafeManagedPtrGetPtr jGetPropertyClosure
                return jGetPropertyClosure'
        maybeSetPropertyClosure <- case setPropertyClosure of
            Nothing -> return nullPtr
            Just jSetPropertyClosure -> do
                jSetPropertyClosure' <- unsafeManagedPtrGetPtr 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 (Closure) -> Maybe (Closure) -> Maybe (Closure) -> 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