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

    Abstract base class for D-Bus interfaces on the service side.

    /Since: 2.30/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.DBusInterfaceSkeleton
        (

    -- * Exported types
        DBusInterfaceSkeleton(..)               ,
        IsDBusInterfaceSkeleton                 ,
        toDBusInterfaceSkeleton                 ,
        noDBusInterfaceSkeleton                 ,

     -- * Methods
    -- ** export #method:export#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonExportMethodInfo   ,
    #endif
        dBusInterfaceSkeletonExport             ,

    -- ** flush #method:flush#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonFlushMethodInfo    ,
    #endif
        dBusInterfaceSkeletonFlush              ,

    -- ** getConnection #method:getConnection#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGetConnectionMethodInfo,
    #endif
        dBusInterfaceSkeletonGetConnection      ,

    -- ** getConnections #method:getConnections#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGetConnectionsMethodInfo,
    #endif
        dBusInterfaceSkeletonGetConnections     ,

    -- ** getFlags #method:getFlags#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGetFlagsMethodInfo ,
    #endif
        dBusInterfaceSkeletonGetFlags           ,

    -- ** getInfo #method:getInfo#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGetInfoMethodInfo  ,
    #endif
        dBusInterfaceSkeletonGetInfo            ,

    -- ** getObjectPath #method:getObjectPath#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGetObjectPathMethodInfo,
    #endif
        dBusInterfaceSkeletonGetObjectPath      ,

    -- ** getProperties #method:getProperties#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGetPropertiesMethodInfo,
    #endif
        dBusInterfaceSkeletonGetProperties      ,

    -- ** hasConnection #method:hasConnection#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonHasConnectionMethodInfo,
    #endif
        dBusInterfaceSkeletonHasConnection      ,

    -- ** setFlags #method:setFlags#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonSetFlagsMethodInfo ,
    #endif
        dBusInterfaceSkeletonSetFlags           ,

    -- ** unexport #method:unexport#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonUnexportMethodInfo ,
    #endif
        dBusInterfaceSkeletonUnexport           ,

    -- ** unexportFromConnection #method:unexportFromConnection#

    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonUnexportFromConnectionMethodInfo,
    #endif
        dBusInterfaceSkeletonUnexportFromConnection,

     -- * Properties
    -- ** gFlags #attr:gFlags#
    {- | Flags from the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' enumeration.

    /Since: 2.30/
    -}
    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGFlagsPropertyInfo ,
    #endif
        constructDBusInterfaceSkeletonGFlags    ,
    #if ENABLE_OVERLOADING
        dBusInterfaceSkeletonGFlags             ,
    #endif
        getDBusInterfaceSkeletonGFlags          ,
        setDBusInterfaceSkeletonGFlags          ,

     -- * Signals
    -- ** gAuthorizeMethod #signal:gAuthorizeMethod#

        C_DBusInterfaceSkeletonGAuthorizeMethodCallback,
        DBusInterfaceSkeletonGAuthorizeMethodCallback,
    #if ENABLE_OVERLOADING
        DBusInterfaceSkeletonGAuthorizeMethodSignalInfo,
    #endif
        afterDBusInterfaceSkeletonGAuthorizeMethod,
        genClosure_DBusInterfaceSkeletonGAuthorizeMethod,
        mk_DBusInterfaceSkeletonGAuthorizeMethodCallback,
        noDBusInterfaceSkeletonGAuthorizeMethodCallback,
        onDBusInterfaceSkeletonGAuthorizeMethod ,
        wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback,

        ) 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.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.DBusInterface as Gio.DBusInterface
    import {-# SOURCE #-} qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
    import {-# SOURCE #-} qualified GI.Gio.Objects.DBusMethodInvocation as Gio.DBusMethodInvocation
    import {-# SOURCE #-} qualified GI.Gio.Structs.DBusInterfaceInfo as Gio.DBusInterfaceInfo

    -- | Memory-managed wrapper type.
    newtype DBusInterfaceSkeleton = DBusInterfaceSkeleton (ManagedPtr DBusInterfaceSkeleton)
    foreign import ccall "g_dbus_interface_skeleton_get_type"
        c_g_dbus_interface_skeleton_get_type :: IO GType

    instance GObject DBusInterfaceSkeleton where
        gobjectType _ = c_g_dbus_interface_skeleton_get_type

    -- | Type class for types which can be safely cast to `DBusInterfaceSkeleton`, for instance with `toDBusInterfaceSkeleton`.
    class GObject o => IsDBusInterfaceSkeleton o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DBusInterfaceSkeleton a) =>
        IsDBusInterfaceSkeleton a
    #endif
    instance IsDBusInterfaceSkeleton DBusInterfaceSkeleton
    instance GObject.Object.IsObject DBusInterfaceSkeleton
    instance Gio.DBusInterface.IsDBusInterface DBusInterfaceSkeleton

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

    -- | A convenience alias for `Nothing` :: `Maybe` `DBusInterfaceSkeleton`.
    noDBusInterfaceSkeleton :: Maybe DBusInterfaceSkeleton
    noDBusInterfaceSkeleton = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveDBusInterfaceSkeletonMethod (t :: Symbol) (o :: *) :: * where
        ResolveDBusInterfaceSkeletonMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveDBusInterfaceSkeletonMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveDBusInterfaceSkeletonMethod "export" o = DBusInterfaceSkeletonExportMethodInfo
        ResolveDBusInterfaceSkeletonMethod "flush" o = DBusInterfaceSkeletonFlushMethodInfo
        ResolveDBusInterfaceSkeletonMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveDBusInterfaceSkeletonMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveDBusInterfaceSkeletonMethod "hasConnection" o = DBusInterfaceSkeletonHasConnectionMethodInfo
        ResolveDBusInterfaceSkeletonMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveDBusInterfaceSkeletonMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveDBusInterfaceSkeletonMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveDBusInterfaceSkeletonMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveDBusInterfaceSkeletonMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveDBusInterfaceSkeletonMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveDBusInterfaceSkeletonMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveDBusInterfaceSkeletonMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveDBusInterfaceSkeletonMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveDBusInterfaceSkeletonMethod "unexport" o = DBusInterfaceSkeletonUnexportMethodInfo
        ResolveDBusInterfaceSkeletonMethod "unexportFromConnection" o = DBusInterfaceSkeletonUnexportFromConnectionMethodInfo
        ResolveDBusInterfaceSkeletonMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveDBusInterfaceSkeletonMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getConnection" o = DBusInterfaceSkeletonGetConnectionMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getConnections" o = DBusInterfaceSkeletonGetConnectionsMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getFlags" o = DBusInterfaceSkeletonGetFlagsMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getInfo" o = DBusInterfaceSkeletonGetInfoMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getObject" o = Gio.DBusInterface.DBusInterfaceGetObjectMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getObjectPath" o = DBusInterfaceSkeletonGetObjectPathMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getProperties" o = DBusInterfaceSkeletonGetPropertiesMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveDBusInterfaceSkeletonMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveDBusInterfaceSkeletonMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveDBusInterfaceSkeletonMethod "setFlags" o = DBusInterfaceSkeletonSetFlagsMethodInfo
        ResolveDBusInterfaceSkeletonMethod "setObject" o = Gio.DBusInterface.DBusInterfaceSetObjectMethodInfo
        ResolveDBusInterfaceSkeletonMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveDBusInterfaceSkeletonMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveDBusInterfaceSkeletonMethod t DBusInterfaceSkeleton, O.MethodInfo info DBusInterfaceSkeleton p) => O.IsLabel t (DBusInterfaceSkeleton -> 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 DBusInterfaceSkeleton::g-authorize-method
    {- |
    Emitted when a method is invoked by a remote caller and used to
    determine if the method call is authorized.

    Note that this signal is emitted in a thread dedicated to
    handling the method call so handlers are allowed to perform
    blocking IO. This means that it is appropriate to call e.g.
    <http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#polkit-authority-check-authorization-sync polkit_authority_check_authorization_sync()>
    with the
    <http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION>
    flag set.

    If 'False' is returned then no further handlers are run and the
    signal handler must take a reference to /@invocation@/ and finish
    handling the call (e.g. return an error via
    @/g_dbus_method_invocation_return_error()/@).

    Otherwise, if 'True' is returned, signal emission continues. If no
    handlers return 'False', then the method is dispatched. If
    /@interface@/ has an enclosing 'GI.Gio.Objects.DBusObjectSkeleton.DBusObjectSkeleton', then the
    'GI.Gio.Objects.DBusObjectSkeleton.DBusObjectSkeleton'::@/authorize-method/@ signal handlers run before
    the handlers for this signal.

    The default class handler just returns 'True'.

    Please note that the common case is optimized: if no signals
    handlers are connected and the default class handler isn\'t
    overridden (for both /@interface@/ and the enclosing
    'GI.Gio.Objects.DBusObjectSkeleton.DBusObjectSkeleton', if any) and 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton':@/g-flags/@ does
    not have the
    'GI.Gio.Flags.DBusInterfaceSkeletonFlagsHandleMethodInvocationsInThread'
    flags set, no dedicated thread is ever used and the call will be
    handled in the same thread as the object that /@interface@/ belongs
    to was exported in.

    /Since: 2.30/
    -}
    type DBusInterfaceSkeletonGAuthorizeMethodCallback =
        Gio.DBusMethodInvocation.DBusMethodInvocation
        {- ^ /@invocation@/: A 'GI.Gio.Objects.DBusMethodInvocation.DBusMethodInvocation'. -}
        -> IO Bool
        {- ^ __Returns:__ 'True' if the call is authorized, 'False' otherwise. -}

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DBusInterfaceSkeletonGAuthorizeMethodCallback`@.
    noDBusInterfaceSkeletonGAuthorizeMethodCallback :: Maybe DBusInterfaceSkeletonGAuthorizeMethodCallback
    noDBusInterfaceSkeletonGAuthorizeMethodCallback = Nothing

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

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

    -- | Wrap the callback into a `Closure`.
    genClosure_DBusInterfaceSkeletonGAuthorizeMethod :: DBusInterfaceSkeletonGAuthorizeMethodCallback -> IO Closure
    genClosure_DBusInterfaceSkeletonGAuthorizeMethod cb = do
        let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb
        mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb' >>= newCClosure

    -- | Wrap a `DBusInterfaceSkeletonGAuthorizeMethodCallback` into a `C_DBusInterfaceSkeletonGAuthorizeMethodCallback`.
    wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback ::
        DBusInterfaceSkeletonGAuthorizeMethodCallback ->
        C_DBusInterfaceSkeletonGAuthorizeMethodCallback
    wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback _cb _ invocation _ = do
        invocation' <- (newObject Gio.DBusMethodInvocation.DBusMethodInvocation) invocation
        result <- _cb  invocation'
        let result' = (fromIntegral . fromEnum) result
        return result'

    {- |
    Connect a signal handler for the “@g-authorize-method@” 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' dBusInterfaceSkeleton #gAuthorizeMethod callback
    @
    -}
    onDBusInterfaceSkeletonGAuthorizeMethod :: (IsDBusInterfaceSkeleton a, MonadIO m) => a -> DBusInterfaceSkeletonGAuthorizeMethodCallback -> m SignalHandlerId
    onDBusInterfaceSkeletonGAuthorizeMethod obj cb = liftIO $ do
        let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb
        cb'' <- mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb'
        connectSignalFunPtr obj "g-authorize-method" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@g-authorize-method@” 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' dBusInterfaceSkeleton #gAuthorizeMethod callback
    @
    -}
    afterDBusInterfaceSkeletonGAuthorizeMethod :: (IsDBusInterfaceSkeleton a, MonadIO m) => a -> DBusInterfaceSkeletonGAuthorizeMethodCallback -> m SignalHandlerId
    afterDBusInterfaceSkeletonGAuthorizeMethod obj cb = liftIO $ do
        let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb
        cb'' <- mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb'
        connectSignalFunPtr obj "g-authorize-method" cb'' SignalConnectAfter

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

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

    @
    'Data.GI.Base.Attributes.get' dBusInterfaceSkeleton #gFlags
    @
    -}
    getDBusInterfaceSkeletonGFlags :: (MonadIO m, IsDBusInterfaceSkeleton o) => o -> m [Gio.Flags.DBusInterfaceSkeletonFlags]
    getDBusInterfaceSkeletonGFlags obj = liftIO $ getObjectPropertyFlags obj "g-flags"

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

    @
    'Data.GI.Base.Attributes.set' dBusInterfaceSkeleton [ #gFlags 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDBusInterfaceSkeletonGFlags :: (MonadIO m, IsDBusInterfaceSkeleton o) => o -> [Gio.Flags.DBusInterfaceSkeletonFlags] -> m ()
    setDBusInterfaceSkeletonGFlags obj val = liftIO $ setObjectPropertyFlags obj "g-flags" val

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

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGFlagsPropertyInfo
    instance AttrInfo DBusInterfaceSkeletonGFlagsPropertyInfo where
        type AttrAllowedOps DBusInterfaceSkeletonGFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = (~) [Gio.Flags.DBusInterfaceSkeletonFlags]
        type AttrBaseTypeConstraint DBusInterfaceSkeletonGFlagsPropertyInfo = IsDBusInterfaceSkeleton
        type AttrGetType DBusInterfaceSkeletonGFlagsPropertyInfo = [Gio.Flags.DBusInterfaceSkeletonFlags]
        type AttrLabel DBusInterfaceSkeletonGFlagsPropertyInfo = "g-flags"
        type AttrOrigin DBusInterfaceSkeletonGFlagsPropertyInfo = DBusInterfaceSkeleton
        attrGet _ = getDBusInterfaceSkeletonGFlags
        attrSet _ = setDBusInterfaceSkeletonGFlags
        attrConstruct _ = constructDBusInterfaceSkeletonGFlags
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList DBusInterfaceSkeleton
    type instance O.AttributeList DBusInterfaceSkeleton = DBusInterfaceSkeletonAttributeList
    type DBusInterfaceSkeletonAttributeList = ('[ '("gFlags", DBusInterfaceSkeletonGFlagsPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    dBusInterfaceSkeletonGFlags :: AttrLabelProxy "gFlags"
    dBusInterfaceSkeletonGFlags = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGAuthorizeMethodSignalInfo
    instance SignalInfo DBusInterfaceSkeletonGAuthorizeMethodSignalInfo where
        type HaskellCallbackType DBusInterfaceSkeletonGAuthorizeMethodSignalInfo = DBusInterfaceSkeletonGAuthorizeMethodCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DBusInterfaceSkeletonGAuthorizeMethodCallback cb
            cb'' <- mk_DBusInterfaceSkeletonGAuthorizeMethodCallback cb'
            connectSignalFunPtr obj "g-authorize-method" cb'' connectMode

    type instance O.SignalList DBusInterfaceSkeleton = DBusInterfaceSkeletonSignalList
    type DBusInterfaceSkeletonSignalList = ('[ '("gAuthorizeMethod", DBusInterfaceSkeletonGAuthorizeMethodSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method DBusInterfaceSkeleton::export
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The D-Bus interface to export.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "DBusConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusConnection to export @interface_ on.", 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 path to export the interface at.", 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_interface_skeleton_export" g_dbus_interface_skeleton_export ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
        CString ->                              -- object_path : TBasicType TUTF8
        Ptr (Ptr GError) ->                     -- error
        IO CInt

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

    This can be called multiple times to export the same /@interface_@/
    onto multiple connections however the /@objectPath@/ provided must be
    the same for all connections.

    Use 'GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexport' to unexport the object.

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonExport ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) =>
        a
        {- ^ /@interface_@/: The D-Bus interface to export. -}
        -> b
        {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection' to export /@interface_@/ on. -}
        -> T.Text
        {- ^ /@objectPath@/: The path to export the interface at. -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    dBusInterfaceSkeletonExport interface_ connection objectPath = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        connection' <- unsafeManagedPtrCastPtr connection
        objectPath' <- textToCString objectPath
        onException (do
            _ <- propagateGError $ g_dbus_interface_skeleton_export interface_' connection' objectPath'
            touchManagedPtr interface_
            touchManagedPtr connection
            freeMem objectPath'
            return ()
         ) (do
            freeMem objectPath'
         )

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonExportMethodInfo
    instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.MethodInfo DBusInterfaceSkeletonExportMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonExport

    #endif

    -- method DBusInterfaceSkeleton::flush
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", 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_interface_skeleton_flush" g_dbus_interface_skeleton_flush ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO ()

    {- |
    If /@interface_@/ has outstanding changes, request for these changes to be
    emitted immediately.

    For example, an exported D-Bus interface may queue up property
    changes and emit the
    @org.freedesktop.DBus.Properties.PropertiesChanged@
    signal later (e.g. in an idle handler). This technique is useful
    for collapsing multiple property changes into one.

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonFlush ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m ()
    dBusInterfaceSkeletonFlush interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        g_dbus_interface_skeleton_flush interface_'
        touchManagedPtr interface_
        return ()

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonFlushMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonFlushMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonFlush

    #endif

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

    foreign import ccall "g_dbus_interface_skeleton_get_connection" g_dbus_interface_skeleton_get_connection ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO (Ptr Gio.DBusConnection.DBusConnection)

    {- |
    Gets the first connection that /@interface_@/ is exported on, if any.

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonGetConnection ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m Gio.DBusConnection.DBusConnection
        {- ^ __Returns:__ A 'GI.Gio.Objects.DBusConnection.DBusConnection' or 'Nothing' if /@interface_@/ is
    not exported anywhere. Do not free, the object belongs to /@interface_@/. -}
    dBusInterfaceSkeletonGetConnection interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        result <- g_dbus_interface_skeleton_get_connection interface_'
        checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetConnection" result
        result' <- (newObject Gio.DBusConnection.DBusConnection) result
        touchManagedPtr interface_
        return result'

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGetConnectionMethodInfo
    instance (signature ~ (m Gio.DBusConnection.DBusConnection), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetConnectionMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonGetConnection

    #endif

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

    foreign import ccall "g_dbus_interface_skeleton_get_connections" g_dbus_interface_skeleton_get_connections ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO (Ptr (GList (Ptr Gio.DBusConnection.DBusConnection)))

    {- |
    Gets a list of the connections that /@interface_@/ is exported on.

    /Since: 2.32/
    -}
    dBusInterfaceSkeletonGetConnections ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m [Gio.DBusConnection.DBusConnection]
        {- ^ __Returns:__ A list of
      all the connections that /@interface_@/ is exported on. The returned
      list should be freed with @/g_list_free()/@ after each element has
      been freed with 'GI.GObject.Objects.Object.objectUnref'. -}
    dBusInterfaceSkeletonGetConnections interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        result <- g_dbus_interface_skeleton_get_connections interface_'
        result' <- unpackGList result
        result'' <- mapM (wrapObject Gio.DBusConnection.DBusConnection) result'
        g_list_free result
        touchManagedPtr interface_
        return result''

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGetConnectionsMethodInfo
    instance (signature ~ (m [Gio.DBusConnection.DBusConnection]), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetConnectionsMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonGetConnections

    #endif

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

    foreign import ccall "g_dbus_interface_skeleton_get_flags" g_dbus_interface_skeleton_get_flags ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO CUInt

    {- |
    Gets the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' that describes what the behavior
    of /@interface_@/

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonGetFlags ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m [Gio.Flags.DBusInterfaceSkeletonFlags]
        {- ^ __Returns:__ One or more flags from the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' enumeration. -}
    dBusInterfaceSkeletonGetFlags interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        result <- g_dbus_interface_skeleton_get_flags interface_'
        let result' = wordToGFlags result
        touchManagedPtr interface_
        return result'

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGetFlagsMethodInfo
    instance (signature ~ (m [Gio.Flags.DBusInterfaceSkeletonFlags]), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetFlagsMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonGetFlags

    #endif

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

    foreign import ccall "g_dbus_interface_skeleton_get_info" g_dbus_interface_skeleton_get_info ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO (Ptr Gio.DBusInterfaceInfo.DBusInterfaceInfo)

    {- |
    Gets D-Bus introspection information for the D-Bus interface
    implemented by /@interface_@/.

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonGetInfo ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m Gio.DBusInterfaceInfo.DBusInterfaceInfo
        {- ^ __Returns:__ A 'GI.Gio.Structs.DBusInterfaceInfo.DBusInterfaceInfo' (never 'Nothing'). Do not free. -}
    dBusInterfaceSkeletonGetInfo interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        result <- g_dbus_interface_skeleton_get_info interface_'
        checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetInfo" result
        result' <- (newBoxed Gio.DBusInterfaceInfo.DBusInterfaceInfo) result
        touchManagedPtr interface_
        return result'

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGetInfoMethodInfo
    instance (signature ~ (m Gio.DBusInterfaceInfo.DBusInterfaceInfo), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetInfoMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonGetInfo

    #endif

    -- method DBusInterfaceSkeleton::get_object_path
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", 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_interface_skeleton_get_object_path" g_dbus_interface_skeleton_get_object_path ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO CString

    {- |
    Gets the object path that /@interface_@/ is exported on, if any.

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonGetObjectPath ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m T.Text
        {- ^ __Returns:__ A string owned by /@interface_@/ or 'Nothing' if /@interface_@/ is not exported
    anywhere. Do not free, the string belongs to /@interface_@/. -}
    dBusInterfaceSkeletonGetObjectPath interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        result <- g_dbus_interface_skeleton_get_object_path interface_'
        checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetObjectPath" result
        result' <- cstringToText result
        touchManagedPtr interface_
        return result'

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGetObjectPathMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetObjectPathMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonGetObjectPath

    #endif

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

    foreign import ccall "g_dbus_interface_skeleton_get_properties" g_dbus_interface_skeleton_get_properties ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO (Ptr GVariant)

    {- |
    Gets all D-Bus properties for /@interface_@/.

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonGetProperties ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m GVariant
        {- ^ __Returns:__ A 'GVariant' of type
    [\'a{sv}\'][G-VARIANT-TYPE-VARDICT:CAPS].
    Free with 'GI.GLib.Structs.Variant.variantUnref'. -}
    dBusInterfaceSkeletonGetProperties interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        result <- g_dbus_interface_skeleton_get_properties interface_'
        checkUnexpectedReturnNULL "dBusInterfaceSkeletonGetProperties" result
        result' <- B.GVariant.wrapGVariantPtr result
        touchManagedPtr interface_
        return result'

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonGetPropertiesMethodInfo
    instance (signature ~ (m GVariant), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonGetPropertiesMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonGetProperties

    #endif

    -- method DBusInterfaceSkeleton::has_connection
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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_interface_skeleton_has_connection" g_dbus_interface_skeleton_has_connection ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
        IO CInt

    {- |
    Checks if /@interface_@/ is exported on /@connection@/.

    /Since: 2.32/
    -}
    dBusInterfaceSkeletonHasConnection ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> b
        {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if /@interface_@/ is exported on /@connection@/, 'False' otherwise. -}
    dBusInterfaceSkeletonHasConnection interface_ connection = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        connection' <- unsafeManagedPtrCastPtr connection
        result <- g_dbus_interface_skeleton_has_connection interface_' connection'
        let result' = (/= 0) result
        touchManagedPtr interface_
        touchManagedPtr connection
        return result'

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonHasConnectionMethodInfo
    instance (signature ~ (b -> m Bool), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.MethodInfo DBusInterfaceSkeletonHasConnectionMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonHasConnection

    #endif

    -- method DBusInterfaceSkeleton::set_flags
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeletonFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags from the #GDBusInterfaceSkeletonFlags enumeration.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_dbus_interface_skeleton_set_flags" g_dbus_interface_skeleton_set_flags ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeletonFlags"})
        IO ()

    {- |
    Sets flags describing what the behavior of /@skeleton@/ should be.

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonSetFlags ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> [Gio.Flags.DBusInterfaceSkeletonFlags]
        {- ^ /@flags@/: Flags from the 'GI.Gio.Flags.DBusInterfaceSkeletonFlags' enumeration. -}
        -> m ()
    dBusInterfaceSkeletonSetFlags interface_ flags = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        let flags' = gflagsToWord flags
        g_dbus_interface_skeleton_set_flags interface_' flags'
        touchManagedPtr interface_
        return ()

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonSetFlagsMethodInfo
    instance (signature ~ ([Gio.Flags.DBusInterfaceSkeletonFlags] -> m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonSetFlagsMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonSetFlags

    #endif

    -- method DBusInterfaceSkeleton::unexport
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", 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_interface_skeleton_unexport" g_dbus_interface_skeleton_unexport ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        IO ()

    {- |
    Stops exporting /@interface_@/ on all connections it is exported on.

    To unexport /@interface_@/ from only a single connection, use
    'GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexportFromConnection'

    /Since: 2.30/
    -}
    dBusInterfaceSkeletonUnexport ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> m ()
    dBusInterfaceSkeletonUnexport interface_ = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        g_dbus_interface_skeleton_unexport interface_'
        touchManagedPtr interface_
        return ()

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonUnexportMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsDBusInterfaceSkeleton a) => O.MethodInfo DBusInterfaceSkeletonUnexportMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonUnexport

    #endif

    -- method DBusInterfaceSkeleton::unexport_from_connection
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "interface_", argType = TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusInterfaceSkeleton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},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_interface_skeleton_unexport_from_connection" g_dbus_interface_skeleton_unexport_from_connection ::
        Ptr DBusInterfaceSkeleton ->            -- interface_ : TInterface (Name {namespace = "Gio", name = "DBusInterfaceSkeleton"})
        Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
        IO ()

    {- |
    Stops exporting /@interface_@/ on /@connection@/.

    To stop exporting on all connections the interface is exported on,
    use 'GI.Gio.Objects.DBusInterfaceSkeleton.dBusInterfaceSkeletonUnexport'.

    /Since: 2.32/
    -}
    dBusInterfaceSkeletonUnexportFromConnection ::
        (B.CallStack.HasCallStack, MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) =>
        a
        {- ^ /@interface_@/: A 'GI.Gio.Objects.DBusInterfaceSkeleton.DBusInterfaceSkeleton'. -}
        -> b
        {- ^ /@connection@/: A 'GI.Gio.Objects.DBusConnection.DBusConnection'. -}
        -> m ()
    dBusInterfaceSkeletonUnexportFromConnection interface_ connection = liftIO $ do
        interface_' <- unsafeManagedPtrCastPtr interface_
        connection' <- unsafeManagedPtrCastPtr connection
        g_dbus_interface_skeleton_unexport_from_connection interface_' connection'
        touchManagedPtr interface_
        touchManagedPtr connection
        return ()

    #if ENABLE_OVERLOADING
    data DBusInterfaceSkeletonUnexportFromConnectionMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsDBusInterfaceSkeleton a, Gio.DBusConnection.IsDBusConnection b) => O.MethodInfo DBusInterfaceSkeletonUnexportFromConnectionMethodInfo a signature where
        overloadedMethod _ = dBusInterfaceSkeletonUnexportFromConnection

    #endif