    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' is for listing the user interesting devices and volumes
    -- on the computer. In other words, what a file selector or file manager
    -- would show in a sidebar.
    --
    -- t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' is not
    -- [thread-default-context aware][g-main-context-push-thread-default],
    -- and so should not be used other than from the main thread, with no
    -- thread-default-context active.
    --
    -- In order to receive updates about volumes and mounts monitored through GVFS,
    -- a main loop must be running.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gio.Objects.VolumeMonitor
        (

    -- * Exported types
        VolumeMonitor(..)                       ,
        IsVolumeMonitor                         ,
        toVolumeMonitor                         ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveVolumeMonitorMethod              ,
    #endif

    -- ** adoptOrphanMount #method:adoptOrphanMount#

        volumeMonitorAdoptOrphanMount           ,

    -- ** get #method:get#

        volumeMonitorGet                        ,

    -- ** getConnectedDrives #method:getConnectedDrives#

    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorGetConnectedDrivesMethodInfo,
    #endif
        volumeMonitorGetConnectedDrives         ,

    -- ** getMountForUuid #method:getMountForUuid#

    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorGetMountForUuidMethodInfo  ,
    #endif
        volumeMonitorGetMountForUuid            ,

    -- ** getMounts #method:getMounts#

    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorGetMountsMethodInfo        ,
    #endif
        volumeMonitorGetMounts                  ,

    -- ** getVolumeForUuid #method:getVolumeForUuid#

    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorGetVolumeForUuidMethodInfo ,
    #endif
        volumeMonitorGetVolumeForUuid           ,

    -- ** getVolumes #method:getVolumes#

    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorGetVolumesMethodInfo       ,
    #endif
        volumeMonitorGetVolumes                 ,

     -- * Signals
    -- ** driveChanged #signal:driveChanged#

        C_VolumeMonitorDriveChangedCallback     ,
        VolumeMonitorDriveChangedCallback       ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorDriveChangedSignalInfo     ,
    #endif
        afterVolumeMonitorDriveChanged          ,
        genClosure_VolumeMonitorDriveChanged    ,
        mk_VolumeMonitorDriveChangedCallback    ,
        noVolumeMonitorDriveChangedCallback     ,
        onVolumeMonitorDriveChanged             ,
        wrap_VolumeMonitorDriveChangedCallback  ,

    -- ** driveConnected #signal:driveConnected#

        C_VolumeMonitorDriveConnectedCallback   ,
        VolumeMonitorDriveConnectedCallback     ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorDriveConnectedSignalInfo   ,
    #endif
        afterVolumeMonitorDriveConnected        ,
        genClosure_VolumeMonitorDriveConnected  ,
        mk_VolumeMonitorDriveConnectedCallback  ,
        noVolumeMonitorDriveConnectedCallback   ,
        onVolumeMonitorDriveConnected           ,
        wrap_VolumeMonitorDriveConnectedCallback,

    -- ** driveDisconnected #signal:driveDisconnected#

        C_VolumeMonitorDriveDisconnectedCallback,
        VolumeMonitorDriveDisconnectedCallback  ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorDriveDisconnectedSignalInfo,
    #endif
        afterVolumeMonitorDriveDisconnected     ,
        genClosure_VolumeMonitorDriveDisconnected,
        mk_VolumeMonitorDriveDisconnectedCallback,
        noVolumeMonitorDriveDisconnectedCallback,
        onVolumeMonitorDriveDisconnected        ,
        wrap_VolumeMonitorDriveDisconnectedCallback,

    -- ** driveEjectButton #signal:driveEjectButton#

        C_VolumeMonitorDriveEjectButtonCallback ,
        VolumeMonitorDriveEjectButtonCallback   ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorDriveEjectButtonSignalInfo ,
    #endif
        afterVolumeMonitorDriveEjectButton      ,
        genClosure_VolumeMonitorDriveEjectButton,
        mk_VolumeMonitorDriveEjectButtonCallback,
        noVolumeMonitorDriveEjectButtonCallback ,
        onVolumeMonitorDriveEjectButton         ,
        wrap_VolumeMonitorDriveEjectButtonCallback,

    -- ** driveStopButton #signal:driveStopButton#

        C_VolumeMonitorDriveStopButtonCallback  ,
        VolumeMonitorDriveStopButtonCallback    ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorDriveStopButtonSignalInfo  ,
    #endif
        afterVolumeMonitorDriveStopButton       ,
        genClosure_VolumeMonitorDriveStopButton ,
        mk_VolumeMonitorDriveStopButtonCallback ,
        noVolumeMonitorDriveStopButtonCallback  ,
        onVolumeMonitorDriveStopButton          ,
        wrap_VolumeMonitorDriveStopButtonCallback,

    -- ** mountAdded #signal:mountAdded#

        C_VolumeMonitorMountAddedCallback       ,
        VolumeMonitorMountAddedCallback         ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorMountAddedSignalInfo       ,
    #endif
        afterVolumeMonitorMountAdded            ,
        genClosure_VolumeMonitorMountAdded      ,
        mk_VolumeMonitorMountAddedCallback      ,
        noVolumeMonitorMountAddedCallback       ,
        onVolumeMonitorMountAdded               ,
        wrap_VolumeMonitorMountAddedCallback    ,

    -- ** mountChanged #signal:mountChanged#

        C_VolumeMonitorMountChangedCallback     ,
        VolumeMonitorMountChangedCallback       ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorMountChangedSignalInfo     ,
    #endif
        afterVolumeMonitorMountChanged          ,
        genClosure_VolumeMonitorMountChanged    ,
        mk_VolumeMonitorMountChangedCallback    ,
        noVolumeMonitorMountChangedCallback     ,
        onVolumeMonitorMountChanged             ,
        wrap_VolumeMonitorMountChangedCallback  ,

    -- ** mountPreUnmount #signal:mountPreUnmount#

        C_VolumeMonitorMountPreUnmountCallback  ,
        VolumeMonitorMountPreUnmountCallback    ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorMountPreUnmountSignalInfo  ,
    #endif
        afterVolumeMonitorMountPreUnmount       ,
        genClosure_VolumeMonitorMountPreUnmount ,
        mk_VolumeMonitorMountPreUnmountCallback ,
        noVolumeMonitorMountPreUnmountCallback  ,
        onVolumeMonitorMountPreUnmount          ,
        wrap_VolumeMonitorMountPreUnmountCallback,

    -- ** mountRemoved #signal:mountRemoved#

        C_VolumeMonitorMountRemovedCallback     ,
        VolumeMonitorMountRemovedCallback       ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorMountRemovedSignalInfo     ,
    #endif
        afterVolumeMonitorMountRemoved          ,
        genClosure_VolumeMonitorMountRemoved    ,
        mk_VolumeMonitorMountRemovedCallback    ,
        noVolumeMonitorMountRemovedCallback     ,
        onVolumeMonitorMountRemoved             ,
        wrap_VolumeMonitorMountRemovedCallback  ,

    -- ** volumeAdded #signal:volumeAdded#

        C_VolumeMonitorVolumeAddedCallback      ,
        VolumeMonitorVolumeAddedCallback        ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorVolumeAddedSignalInfo      ,
    #endif
        afterVolumeMonitorVolumeAdded           ,
        genClosure_VolumeMonitorVolumeAdded     ,
        mk_VolumeMonitorVolumeAddedCallback     ,
        noVolumeMonitorVolumeAddedCallback      ,
        onVolumeMonitorVolumeAdded              ,
        wrap_VolumeMonitorVolumeAddedCallback   ,

    -- ** volumeChanged #signal:volumeChanged#

        C_VolumeMonitorVolumeChangedCallback    ,
        VolumeMonitorVolumeChangedCallback      ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorVolumeChangedSignalInfo    ,
    #endif
        afterVolumeMonitorVolumeChanged         ,
        genClosure_VolumeMonitorVolumeChanged   ,
        mk_VolumeMonitorVolumeChangedCallback   ,
        noVolumeMonitorVolumeChangedCallback    ,
        onVolumeMonitorVolumeChanged            ,
        wrap_VolumeMonitorVolumeChangedCallback ,

    -- ** volumeRemoved #signal:volumeRemoved#

        C_VolumeMonitorVolumeRemovedCallback    ,
        VolumeMonitorVolumeRemovedCallback      ,
    #if defined(ENABLE_OVERLOADING)
        VolumeMonitorVolumeRemovedSignalInfo    ,
    #endif
        afterVolumeMonitorVolumeRemoved         ,
        genClosure_VolumeMonitorVolumeRemoved   ,
        mk_VolumeMonitorVolumeRemovedCallback   ,
        noVolumeMonitorVolumeRemovedCallback    ,
        onVolumeMonitorVolumeRemoved            ,
        wrap_VolumeMonitorVolumeRemovedCallback ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Drive as Gio.Drive
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Mount as Gio.Mount
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Volume as Gio.Volume

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

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

    foreign import ccall "g_volume_monitor_get_type"
        c_g_volume_monitor_get_type :: IO B.Types.GType

    instance B.Types.TypedObject VolumeMonitor where
        glibType :: IO GType
    glibType = IO GType
    c_g_volume_monitor_get_type

    instance B.Types.GObject VolumeMonitor

    -- | Convert 'VolumeMonitor' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue VolumeMonitor where
        toGValue :: VolumeMonitor -> IO GValue
    toGValue o :: VolumeMonitor
    o = do
            GType
    gtype <- IO GType
    c_g_volume_monitor_get_type
            VolumeMonitor -> (Ptr VolumeMonitor -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr VolumeMonitor
    o (GType
    -> (GValue -> Ptr VolumeMonitor -> IO ())
    -> Ptr VolumeMonitor
    -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr VolumeMonitor -> IO ()
    forall a. GObject a => GValue -> Ptr a -> IO ()
    B.GValue.set_object)

        fromGValue :: GValue -> IO VolumeMonitor
    fromGValue gv :: GValue
    gv = do
            Ptr VolumeMonitor
    ptr <- GValue -> IO (Ptr VolumeMonitor)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr VolumeMonitor)
            (ManagedPtr VolumeMonitor -> VolumeMonitor)
    -> Ptr VolumeMonitor -> IO VolumeMonitor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr VolumeMonitor -> VolumeMonitor
    VolumeMonitor Ptr VolumeMonitor
    ptr

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

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveVolumeMonitorMethod (t :: Symbol) (o :: *) :: * where
        ResolveVolumeMonitorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveVolumeMonitorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveVolumeMonitorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveVolumeMonitorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveVolumeMonitorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveVolumeMonitorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveVolumeMonitorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveVolumeMonitorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveVolumeMonitorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveVolumeMonitorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveVolumeMonitorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveVolumeMonitorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveVolumeMonitorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveVolumeMonitorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveVolumeMonitorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveVolumeMonitorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveVolumeMonitorMethod "getConnectedDrives" o = VolumeMonitorGetConnectedDrivesMethodInfo
        ResolveVolumeMonitorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveVolumeMonitorMethod "getMountForUuid" o = VolumeMonitorGetMountForUuidMethodInfo
        ResolveVolumeMonitorMethod "getMounts" o = VolumeMonitorGetMountsMethodInfo
        ResolveVolumeMonitorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveVolumeMonitorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveVolumeMonitorMethod "getVolumeForUuid" o = VolumeMonitorGetVolumeForUuidMethodInfo
        ResolveVolumeMonitorMethod "getVolumes" o = VolumeMonitorGetVolumesMethodInfo
        ResolveVolumeMonitorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveVolumeMonitorMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveVolumeMonitorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveVolumeMonitorMethod l o = O.MethodResolutionFailed l o

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

    #endif

    -- signal VolumeMonitor::drive-changed
    -- | Emitted when a drive changes.
    type VolumeMonitorDriveChangedCallback =
        Gio.Drive.Drive
        -- ^ /@drive@/: the drive that changed
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveChangedCallback`@.
    noVolumeMonitorDriveChangedCallback :: Maybe VolumeMonitorDriveChangedCallback
    noVolumeMonitorDriveChangedCallback :: Maybe VolumeMonitorDriveChangedCallback
    noVolumeMonitorDriveChangedCallback = Maybe VolumeMonitorDriveChangedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorDriveChanged :: MonadIO m => VolumeMonitorDriveChangedCallback -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    genClosure_VolumeMonitorDriveChanged :: VolumeMonitorDriveChangedCallback
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    genClosure_VolumeMonitorDriveChanged cb :: VolumeMonitorDriveChangedCallback
    cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
     -> m (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveChangedCallback VolumeMonitorDriveChangedCallback
    cb
        C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveChangedCallback C_VolumeMonitorDriveChangedCallback
    cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    -> (FunPtr C_VolumeMonitorDriveChangedCallback
        -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorDriveChangedCallback` into a `C_VolumeMonitorDriveChangedCallback`.
    wrap_VolumeMonitorDriveChangedCallback ::
        VolumeMonitorDriveChangedCallback ->
        C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveChangedCallback :: VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveChangedCallback _cb :: VolumeMonitorDriveChangedCallback
    _cb _ drive :: Ptr Drive
    drive _ = do
        Drive
    drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Drive -> Drive
    Gio.Drive.Drive) Ptr Drive
    drive
        VolumeMonitorDriveChangedCallback
    _cb  Drive
    drive'

    -- | Connect a signal handler for the [driveChanged](#signal:driveChanged) 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' volumeMonitor #driveChanged callback
    -- @
    --
    --
    onVolumeMonitorDriveChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    onVolumeMonitorDriveChanged :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    onVolumeMonitorDriveChanged obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveChangedCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveChangedCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-changed" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [driveChanged](#signal:driveChanged) 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' volumeMonitor #driveChanged callback
    -- @
    --
    --
    afterVolumeMonitorDriveChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveChanged :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveChanged obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveChangedCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveChangedCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-changed" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorDriveChangedSignalInfo
    instance SignalInfo VolumeMonitorDriveChangedSignalInfo where
        type HaskellCallbackType VolumeMonitorDriveChangedSignalInfo = VolumeMonitorDriveChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorDriveChangedCallback cb
            cb'' <- mk_VolumeMonitorDriveChangedCallback cb'
            connectSignalFunPtr obj "drive-changed" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::drive-connected
    -- | Emitted when a drive is connected to the system.
    type VolumeMonitorDriveConnectedCallback =
        Gio.Drive.Drive
        -- ^ /@drive@/: a t'GI.Gio.Interfaces.Drive.Drive' that was connected.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveConnectedCallback`@.
    noVolumeMonitorDriveConnectedCallback :: Maybe VolumeMonitorDriveConnectedCallback
    noVolumeMonitorDriveConnectedCallback :: Maybe VolumeMonitorDriveChangedCallback
    noVolumeMonitorDriveConnectedCallback = Maybe VolumeMonitorDriveChangedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorDriveConnected :: MonadIO m => VolumeMonitorDriveConnectedCallback -> m (GClosure C_VolumeMonitorDriveConnectedCallback)
    genClosure_VolumeMonitorDriveConnected :: VolumeMonitorDriveChangedCallback
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    genClosure_VolumeMonitorDriveConnected cb :: VolumeMonitorDriveChangedCallback
    cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
     -> m (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveConnectedCallback VolumeMonitorDriveChangedCallback
    cb
        C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveConnectedCallback C_VolumeMonitorDriveChangedCallback
    cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    -> (FunPtr C_VolumeMonitorDriveChangedCallback
        -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorDriveConnectedCallback` into a `C_VolumeMonitorDriveConnectedCallback`.
    wrap_VolumeMonitorDriveConnectedCallback ::
        VolumeMonitorDriveConnectedCallback ->
        C_VolumeMonitorDriveConnectedCallback
    wrap_VolumeMonitorDriveConnectedCallback :: VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveConnectedCallback _cb :: VolumeMonitorDriveChangedCallback
    _cb _ drive :: Ptr Drive
    drive _ = do
        Drive
    drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Drive -> Drive
    Gio.Drive.Drive) Ptr Drive
    drive
        VolumeMonitorDriveChangedCallback
    _cb  Drive
    drive'

    -- | Connect a signal handler for the [driveConnected](#signal:driveConnected) 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' volumeMonitor #driveConnected callback
    -- @
    --
    --
    onVolumeMonitorDriveConnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveConnectedCallback -> m SignalHandlerId
    onVolumeMonitorDriveConnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    onVolumeMonitorDriveConnected obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveConnectedCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveConnectedCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-connected" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [driveConnected](#signal:driveConnected) 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' volumeMonitor #driveConnected callback
    -- @
    --
    --
    afterVolumeMonitorDriveConnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveConnectedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveConnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveConnected obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveConnectedCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveConnectedCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-connected" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorDriveConnectedSignalInfo
    instance SignalInfo VolumeMonitorDriveConnectedSignalInfo where
        type HaskellCallbackType VolumeMonitorDriveConnectedSignalInfo = VolumeMonitorDriveConnectedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorDriveConnectedCallback cb
            cb'' <- mk_VolumeMonitorDriveConnectedCallback cb'
            connectSignalFunPtr obj "drive-connected" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::drive-disconnected
    -- | Emitted when a drive is disconnected from the system.
    type VolumeMonitorDriveDisconnectedCallback =
        Gio.Drive.Drive
        -- ^ /@drive@/: a t'GI.Gio.Interfaces.Drive.Drive' that was disconnected.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveDisconnectedCallback`@.
    noVolumeMonitorDriveDisconnectedCallback :: Maybe VolumeMonitorDriveDisconnectedCallback
    noVolumeMonitorDriveDisconnectedCallback :: Maybe VolumeMonitorDriveChangedCallback
    noVolumeMonitorDriveDisconnectedCallback = Maybe VolumeMonitorDriveChangedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorDriveDisconnected :: MonadIO m => VolumeMonitorDriveDisconnectedCallback -> m (GClosure C_VolumeMonitorDriveDisconnectedCallback)
    genClosure_VolumeMonitorDriveDisconnected :: VolumeMonitorDriveChangedCallback
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    genClosure_VolumeMonitorDriveDisconnected cb :: VolumeMonitorDriveChangedCallback
    cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
     -> m (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveDisconnectedCallback VolumeMonitorDriveChangedCallback
    cb
        C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveDisconnectedCallback C_VolumeMonitorDriveChangedCallback
    cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    -> (FunPtr C_VolumeMonitorDriveChangedCallback
        -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorDriveDisconnectedCallback` into a `C_VolumeMonitorDriveDisconnectedCallback`.
    wrap_VolumeMonitorDriveDisconnectedCallback ::
        VolumeMonitorDriveDisconnectedCallback ->
        C_VolumeMonitorDriveDisconnectedCallback
    wrap_VolumeMonitorDriveDisconnectedCallback :: VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveDisconnectedCallback _cb :: VolumeMonitorDriveChangedCallback
    _cb _ drive :: Ptr Drive
    drive _ = do
        Drive
    drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Drive -> Drive
    Gio.Drive.Drive) Ptr Drive
    drive
        VolumeMonitorDriveChangedCallback
    _cb  Drive
    drive'

    -- | Connect a signal handler for the [driveDisconnected](#signal:driveDisconnected) 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' volumeMonitor #driveDisconnected callback
    -- @
    --
    --
    onVolumeMonitorDriveDisconnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveDisconnectedCallback -> m SignalHandlerId
    onVolumeMonitorDriveDisconnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    onVolumeMonitorDriveDisconnected obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveDisconnectedCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveDisconnectedCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-disconnected" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [driveDisconnected](#signal:driveDisconnected) 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' volumeMonitor #driveDisconnected callback
    -- @
    --
    --
    afterVolumeMonitorDriveDisconnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveDisconnectedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveDisconnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveDisconnected obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveDisconnectedCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveDisconnectedCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-disconnected" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorDriveDisconnectedSignalInfo
    instance SignalInfo VolumeMonitorDriveDisconnectedSignalInfo where
        type HaskellCallbackType VolumeMonitorDriveDisconnectedSignalInfo = VolumeMonitorDriveDisconnectedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorDriveDisconnectedCallback cb
            cb'' <- mk_VolumeMonitorDriveDisconnectedCallback cb'
            connectSignalFunPtr obj "drive-disconnected" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::drive-eject-button
    -- | Emitted when the eject button is pressed on /@drive@/.
    --
    -- /Since: 2.18/
    type VolumeMonitorDriveEjectButtonCallback =
        Gio.Drive.Drive
        -- ^ /@drive@/: the drive where the eject button was pressed
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveEjectButtonCallback`@.
    noVolumeMonitorDriveEjectButtonCallback :: Maybe VolumeMonitorDriveEjectButtonCallback
    noVolumeMonitorDriveEjectButtonCallback :: Maybe VolumeMonitorDriveChangedCallback
    noVolumeMonitorDriveEjectButtonCallback = Maybe VolumeMonitorDriveChangedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorDriveEjectButton :: MonadIO m => VolumeMonitorDriveEjectButtonCallback -> m (GClosure C_VolumeMonitorDriveEjectButtonCallback)
    genClosure_VolumeMonitorDriveEjectButton :: VolumeMonitorDriveChangedCallback
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    genClosure_VolumeMonitorDriveEjectButton cb :: VolumeMonitorDriveChangedCallback
    cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
     -> m (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveEjectButtonCallback VolumeMonitorDriveChangedCallback
    cb
        C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveEjectButtonCallback C_VolumeMonitorDriveChangedCallback
    cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    -> (FunPtr C_VolumeMonitorDriveChangedCallback
        -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorDriveEjectButtonCallback` into a `C_VolumeMonitorDriveEjectButtonCallback`.
    wrap_VolumeMonitorDriveEjectButtonCallback ::
        VolumeMonitorDriveEjectButtonCallback ->
        C_VolumeMonitorDriveEjectButtonCallback
    wrap_VolumeMonitorDriveEjectButtonCallback :: VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveEjectButtonCallback _cb :: VolumeMonitorDriveChangedCallback
    _cb _ drive :: Ptr Drive
    drive _ = do
        Drive
    drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Drive -> Drive
    Gio.Drive.Drive) Ptr Drive
    drive
        VolumeMonitorDriveChangedCallback
    _cb  Drive
    drive'

    -- | Connect a signal handler for the [driveEjectButton](#signal:driveEjectButton) 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' volumeMonitor #driveEjectButton callback
    -- @
    --
    --
    onVolumeMonitorDriveEjectButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveEjectButtonCallback -> m SignalHandlerId
    onVolumeMonitorDriveEjectButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    onVolumeMonitorDriveEjectButton obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveEjectButtonCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveEjectButtonCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-eject-button" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [driveEjectButton](#signal:driveEjectButton) 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' volumeMonitor #driveEjectButton callback
    -- @
    --
    --
    afterVolumeMonitorDriveEjectButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveEjectButtonCallback -> m SignalHandlerId
    afterVolumeMonitorDriveEjectButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveEjectButton obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveEjectButtonCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveEjectButtonCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-eject-button" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorDriveEjectButtonSignalInfo
    instance SignalInfo VolumeMonitorDriveEjectButtonSignalInfo where
        type HaskellCallbackType VolumeMonitorDriveEjectButtonSignalInfo = VolumeMonitorDriveEjectButtonCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorDriveEjectButtonCallback cb
            cb'' <- mk_VolumeMonitorDriveEjectButtonCallback cb'
            connectSignalFunPtr obj "drive-eject-button" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::drive-stop-button
    -- | Emitted when the stop button is pressed on /@drive@/.
    --
    -- /Since: 2.22/
    type VolumeMonitorDriveStopButtonCallback =
        Gio.Drive.Drive
        -- ^ /@drive@/: the drive where the stop button was pressed
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveStopButtonCallback`@.
    noVolumeMonitorDriveStopButtonCallback :: Maybe VolumeMonitorDriveStopButtonCallback
    noVolumeMonitorDriveStopButtonCallback :: Maybe VolumeMonitorDriveChangedCallback
    noVolumeMonitorDriveStopButtonCallback = Maybe VolumeMonitorDriveChangedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorDriveStopButton :: MonadIO m => VolumeMonitorDriveStopButtonCallback -> m (GClosure C_VolumeMonitorDriveStopButtonCallback)
    genClosure_VolumeMonitorDriveStopButton :: VolumeMonitorDriveChangedCallback
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    genClosure_VolumeMonitorDriveStopButton cb :: VolumeMonitorDriveChangedCallback
    cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
     -> m (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    -> m (GClosure C_VolumeMonitorDriveChangedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveStopButtonCallback VolumeMonitorDriveChangedCallback
    cb
        C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveStopButtonCallback C_VolumeMonitorDriveChangedCallback
    cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    -> (FunPtr C_VolumeMonitorDriveChangedCallback
        -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorDriveStopButtonCallback` into a `C_VolumeMonitorDriveStopButtonCallback`.
    wrap_VolumeMonitorDriveStopButtonCallback ::
        VolumeMonitorDriveStopButtonCallback ->
        C_VolumeMonitorDriveStopButtonCallback
    wrap_VolumeMonitorDriveStopButtonCallback :: VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveStopButtonCallback _cb :: VolumeMonitorDriveChangedCallback
    _cb _ drive :: Ptr Drive
    drive _ = do
        Drive
    drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Drive -> Drive
    Gio.Drive.Drive) Ptr Drive
    drive
        VolumeMonitorDriveChangedCallback
    _cb  Drive
    drive'

    -- | Connect a signal handler for the [driveStopButton](#signal:driveStopButton) 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' volumeMonitor #driveStopButton callback
    -- @
    --
    --
    onVolumeMonitorDriveStopButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveStopButtonCallback -> m SignalHandlerId
    onVolumeMonitorDriveStopButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    onVolumeMonitorDriveStopButton obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveStopButtonCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveStopButtonCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-stop-button" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [driveStopButton](#signal:driveStopButton) 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' volumeMonitor #driveStopButton callback
    -- @
    --
    --
    afterVolumeMonitorDriveStopButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveStopButtonCallback -> m SignalHandlerId
    afterVolumeMonitorDriveStopButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
    afterVolumeMonitorDriveStopButton obj :: a
    obj cb :: VolumeMonitorDriveChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorDriveChangedCallback
    cb' = VolumeMonitorDriveChangedCallback
    -> C_VolumeMonitorDriveChangedCallback
    wrap_VolumeMonitorDriveStopButtonCallback VolumeMonitorDriveChangedCallback
    cb
        FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' <- C_VolumeMonitorDriveChangedCallback
    -> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
    mk_VolumeMonitorDriveStopButtonCallback C_VolumeMonitorDriveChangedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorDriveChangedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "drive-stop-button" FunPtr C_VolumeMonitorDriveChangedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorDriveStopButtonSignalInfo
    instance SignalInfo VolumeMonitorDriveStopButtonSignalInfo where
        type HaskellCallbackType VolumeMonitorDriveStopButtonSignalInfo = VolumeMonitorDriveStopButtonCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorDriveStopButtonCallback cb
            cb'' <- mk_VolumeMonitorDriveStopButtonCallback cb'
            connectSignalFunPtr obj "drive-stop-button" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::mount-added
    -- | Emitted when a mount is added.
    type VolumeMonitorMountAddedCallback =
        Gio.Mount.Mount
        -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that was added.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountAddedCallback`@.
    noVolumeMonitorMountAddedCallback :: Maybe VolumeMonitorMountAddedCallback
    noVolumeMonitorMountAddedCallback :: Maybe VolumeMonitorMountAddedCallback
    noVolumeMonitorMountAddedCallback = Maybe VolumeMonitorMountAddedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorMountAdded :: MonadIO m => VolumeMonitorMountAddedCallback -> m (GClosure C_VolumeMonitorMountAddedCallback)
    genClosure_VolumeMonitorMountAdded :: VolumeMonitorMountAddedCallback
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    genClosure_VolumeMonitorMountAdded cb :: VolumeMonitorMountAddedCallback
    cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
     -> m (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountAddedCallback VolumeMonitorMountAddedCallback
    cb
        C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountAddedCallback C_VolumeMonitorMountAddedCallback
    cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
    -> (FunPtr C_VolumeMonitorMountAddedCallback
        -> IO (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorMountAddedCallback` into a `C_VolumeMonitorMountAddedCallback`.
    wrap_VolumeMonitorMountAddedCallback ::
        VolumeMonitorMountAddedCallback ->
        C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountAddedCallback :: VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountAddedCallback _cb :: VolumeMonitorMountAddedCallback
    _cb _ mount :: Ptr Mount
    mount _ = do
        Mount
    mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Mount -> Mount
    Gio.Mount.Mount) Ptr Mount
    mount
        VolumeMonitorMountAddedCallback
    _cb  Mount
    mount'

    -- | Connect a signal handler for the [mountAdded](#signal:mountAdded) 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' volumeMonitor #mountAdded callback
    -- @
    --
    --
    onVolumeMonitorMountAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    onVolumeMonitorMountAdded :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    onVolumeMonitorMountAdded obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountAddedCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountAddedCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-added" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [mountAdded](#signal:mountAdded) 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' volumeMonitor #mountAdded callback
    -- @
    --
    --
    afterVolumeMonitorMountAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    afterVolumeMonitorMountAdded :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    afterVolumeMonitorMountAdded obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountAddedCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountAddedCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-added" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorMountAddedSignalInfo
    instance SignalInfo VolumeMonitorMountAddedSignalInfo where
        type HaskellCallbackType VolumeMonitorMountAddedSignalInfo = VolumeMonitorMountAddedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorMountAddedCallback cb
            cb'' <- mk_VolumeMonitorMountAddedCallback cb'
            connectSignalFunPtr obj "mount-added" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::mount-changed
    -- | Emitted when a mount changes.
    type VolumeMonitorMountChangedCallback =
        Gio.Mount.Mount
        -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that changed.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountChangedCallback`@.
    noVolumeMonitorMountChangedCallback :: Maybe VolumeMonitorMountChangedCallback
    noVolumeMonitorMountChangedCallback :: Maybe VolumeMonitorMountAddedCallback
    noVolumeMonitorMountChangedCallback = Maybe VolumeMonitorMountAddedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorMountChanged :: MonadIO m => VolumeMonitorMountChangedCallback -> m (GClosure C_VolumeMonitorMountChangedCallback)
    genClosure_VolumeMonitorMountChanged :: VolumeMonitorMountAddedCallback
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    genClosure_VolumeMonitorMountChanged cb :: VolumeMonitorMountAddedCallback
    cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
     -> m (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountChangedCallback VolumeMonitorMountAddedCallback
    cb
        C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountChangedCallback C_VolumeMonitorMountAddedCallback
    cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
    -> (FunPtr C_VolumeMonitorMountAddedCallback
        -> IO (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorMountChangedCallback` into a `C_VolumeMonitorMountChangedCallback`.
    wrap_VolumeMonitorMountChangedCallback ::
        VolumeMonitorMountChangedCallback ->
        C_VolumeMonitorMountChangedCallback
    wrap_VolumeMonitorMountChangedCallback :: VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountChangedCallback _cb :: VolumeMonitorMountAddedCallback
    _cb _ mount :: Ptr Mount
    mount _ = do
        Mount
    mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Mount -> Mount
    Gio.Mount.Mount) Ptr Mount
    mount
        VolumeMonitorMountAddedCallback
    _cb  Mount
    mount'

    -- | Connect a signal handler for the [mountChanged](#signal:mountChanged) 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' volumeMonitor #mountChanged callback
    -- @
    --
    --
    onVolumeMonitorMountChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountChangedCallback -> m SignalHandlerId
    onVolumeMonitorMountChanged :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    onVolumeMonitorMountChanged obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountChangedCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountChangedCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-changed" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [mountChanged](#signal:mountChanged) 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' volumeMonitor #mountChanged callback
    -- @
    --
    --
    afterVolumeMonitorMountChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountChangedCallback -> m SignalHandlerId
    afterVolumeMonitorMountChanged :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    afterVolumeMonitorMountChanged obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountChangedCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountChangedCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-changed" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorMountChangedSignalInfo
    instance SignalInfo VolumeMonitorMountChangedSignalInfo where
        type HaskellCallbackType VolumeMonitorMountChangedSignalInfo = VolumeMonitorMountChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorMountChangedCallback cb
            cb'' <- mk_VolumeMonitorMountChangedCallback cb'
            connectSignalFunPtr obj "mount-changed" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::mount-pre-unmount
    -- | May be emitted when a mount is about to be removed.
    --
    -- This signal depends on the backend and is only emitted if
    -- GIO was used to unmount.
    type VolumeMonitorMountPreUnmountCallback =
        Gio.Mount.Mount
        -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that is being unmounted.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountPreUnmountCallback`@.
    noVolumeMonitorMountPreUnmountCallback :: Maybe VolumeMonitorMountPreUnmountCallback
    noVolumeMonitorMountPreUnmountCallback :: Maybe VolumeMonitorMountAddedCallback
    noVolumeMonitorMountPreUnmountCallback = Maybe VolumeMonitorMountAddedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorMountPreUnmount :: MonadIO m => VolumeMonitorMountPreUnmountCallback -> m (GClosure C_VolumeMonitorMountPreUnmountCallback)
    genClosure_VolumeMonitorMountPreUnmount :: VolumeMonitorMountAddedCallback
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    genClosure_VolumeMonitorMountPreUnmount cb :: VolumeMonitorMountAddedCallback
    cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
     -> m (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountPreUnmountCallback VolumeMonitorMountAddedCallback
    cb
        C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountPreUnmountCallback C_VolumeMonitorMountAddedCallback
    cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
    -> (FunPtr C_VolumeMonitorMountAddedCallback
        -> IO (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorMountPreUnmountCallback` into a `C_VolumeMonitorMountPreUnmountCallback`.
    wrap_VolumeMonitorMountPreUnmountCallback ::
        VolumeMonitorMountPreUnmountCallback ->
        C_VolumeMonitorMountPreUnmountCallback
    wrap_VolumeMonitorMountPreUnmountCallback :: VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountPreUnmountCallback _cb :: VolumeMonitorMountAddedCallback
    _cb _ mount :: Ptr Mount
    mount _ = do
        Mount
    mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Mount -> Mount
    Gio.Mount.Mount) Ptr Mount
    mount
        VolumeMonitorMountAddedCallback
    _cb  Mount
    mount'

    -- | Connect a signal handler for the [mountPreUnmount](#signal:mountPreUnmount) 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' volumeMonitor #mountPreUnmount callback
    -- @
    --
    --
    onVolumeMonitorMountPreUnmount :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountPreUnmountCallback -> m SignalHandlerId
    onVolumeMonitorMountPreUnmount :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    onVolumeMonitorMountPreUnmount obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountPreUnmountCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountPreUnmountCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-pre-unmount" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [mountPreUnmount](#signal:mountPreUnmount) 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' volumeMonitor #mountPreUnmount callback
    -- @
    --
    --
    afterVolumeMonitorMountPreUnmount :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountPreUnmountCallback -> m SignalHandlerId
    afterVolumeMonitorMountPreUnmount :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    afterVolumeMonitorMountPreUnmount obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountPreUnmountCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountPreUnmountCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-pre-unmount" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorMountPreUnmountSignalInfo
    instance SignalInfo VolumeMonitorMountPreUnmountSignalInfo where
        type HaskellCallbackType VolumeMonitorMountPreUnmountSignalInfo = VolumeMonitorMountPreUnmountCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorMountPreUnmountCallback cb
            cb'' <- mk_VolumeMonitorMountPreUnmountCallback cb'
            connectSignalFunPtr obj "mount-pre-unmount" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::mount-removed
    -- | Emitted when a mount is removed.
    type VolumeMonitorMountRemovedCallback =
        Gio.Mount.Mount
        -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that was removed.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountRemovedCallback`@.
    noVolumeMonitorMountRemovedCallback :: Maybe VolumeMonitorMountRemovedCallback
    noVolumeMonitorMountRemovedCallback :: Maybe VolumeMonitorMountAddedCallback
    noVolumeMonitorMountRemovedCallback = Maybe VolumeMonitorMountAddedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorMountRemoved :: MonadIO m => VolumeMonitorMountRemovedCallback -> m (GClosure C_VolumeMonitorMountRemovedCallback)
    genClosure_VolumeMonitorMountRemoved :: VolumeMonitorMountAddedCallback
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    genClosure_VolumeMonitorMountRemoved cb :: VolumeMonitorMountAddedCallback
    cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
     -> m (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    -> m (GClosure C_VolumeMonitorMountAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountRemovedCallback VolumeMonitorMountAddedCallback
    cb
        C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountRemovedCallback C_VolumeMonitorMountAddedCallback
    cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
    -> (FunPtr C_VolumeMonitorMountAddedCallback
        -> IO (GClosure C_VolumeMonitorMountAddedCallback))
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorMountRemovedCallback` into a `C_VolumeMonitorMountRemovedCallback`.
    wrap_VolumeMonitorMountRemovedCallback ::
        VolumeMonitorMountRemovedCallback ->
        C_VolumeMonitorMountRemovedCallback
    wrap_VolumeMonitorMountRemovedCallback :: VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountRemovedCallback _cb :: VolumeMonitorMountAddedCallback
    _cb _ mount :: Ptr Mount
    mount _ = do
        Mount
    mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Mount -> Mount
    Gio.Mount.Mount) Ptr Mount
    mount
        VolumeMonitorMountAddedCallback
    _cb  Mount
    mount'

    -- | Connect a signal handler for the [mountRemoved](#signal:mountRemoved) 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' volumeMonitor #mountRemoved callback
    -- @
    --
    --
    onVolumeMonitorMountRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountRemovedCallback -> m SignalHandlerId
    onVolumeMonitorMountRemoved :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    onVolumeMonitorMountRemoved obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountRemovedCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountRemovedCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-removed" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [mountRemoved](#signal:mountRemoved) 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' volumeMonitor #mountRemoved callback
    -- @
    --
    --
    afterVolumeMonitorMountRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountRemovedCallback -> m SignalHandlerId
    afterVolumeMonitorMountRemoved :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
    afterVolumeMonitorMountRemoved obj :: a
    obj cb :: VolumeMonitorMountAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorMountAddedCallback
    cb' = VolumeMonitorMountAddedCallback
    -> C_VolumeMonitorMountAddedCallback
    wrap_VolumeMonitorMountRemovedCallback VolumeMonitorMountAddedCallback
    cb
        FunPtr C_VolumeMonitorMountAddedCallback
    cb'' <- C_VolumeMonitorMountAddedCallback
    -> IO (FunPtr C_VolumeMonitorMountAddedCallback)
    mk_VolumeMonitorMountRemovedCallback C_VolumeMonitorMountAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorMountAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "mount-removed" FunPtr C_VolumeMonitorMountAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorMountRemovedSignalInfo
    instance SignalInfo VolumeMonitorMountRemovedSignalInfo where
        type HaskellCallbackType VolumeMonitorMountRemovedSignalInfo = VolumeMonitorMountRemovedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorMountRemovedCallback cb
            cb'' <- mk_VolumeMonitorMountRemovedCallback cb'
            connectSignalFunPtr obj "mount-removed" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::volume-added
    -- | Emitted when a mountable volume is added to the system.
    type VolumeMonitorVolumeAddedCallback =
        Gio.Volume.Volume
        -- ^ /@volume@/: a t'GI.Gio.Interfaces.Volume.Volume' that was added.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorVolumeAddedCallback`@.
    noVolumeMonitorVolumeAddedCallback :: Maybe VolumeMonitorVolumeAddedCallback
    noVolumeMonitorVolumeAddedCallback :: Maybe VolumeMonitorVolumeAddedCallback
    noVolumeMonitorVolumeAddedCallback = Maybe VolumeMonitorVolumeAddedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorVolumeAdded :: MonadIO m => VolumeMonitorVolumeAddedCallback -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    genClosure_VolumeMonitorVolumeAdded :: VolumeMonitorVolumeAddedCallback
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    genClosure_VolumeMonitorVolumeAdded cb :: VolumeMonitorVolumeAddedCallback
    cb = IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorVolumeAddedCallback)
     -> m (GClosure C_VolumeMonitorVolumeAddedCallback))
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeAddedCallback VolumeMonitorVolumeAddedCallback
    cb
        C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeAddedCallback C_VolumeMonitorVolumeAddedCallback
    cb' IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    -> (FunPtr C_VolumeMonitorVolumeAddedCallback
        -> IO (GClosure C_VolumeMonitorVolumeAddedCallback))
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorVolumeAddedCallback
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorVolumeAddedCallback` into a `C_VolumeMonitorVolumeAddedCallback`.
    wrap_VolumeMonitorVolumeAddedCallback ::
        VolumeMonitorVolumeAddedCallback ->
        C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeAddedCallback :: VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeAddedCallback _cb :: VolumeMonitorVolumeAddedCallback
    _cb _ volume :: Ptr Volume
    volume _ = do
        Volume
    volume' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Volume -> Volume
    Gio.Volume.Volume) Ptr Volume
    volume
        VolumeMonitorVolumeAddedCallback
    _cb  Volume
    volume'

    -- | Connect a signal handler for the [volumeAdded](#signal:volumeAdded) 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' volumeMonitor #volumeAdded callback
    -- @
    --
    --
    onVolumeMonitorVolumeAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    onVolumeMonitorVolumeAdded :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    onVolumeMonitorVolumeAdded obj :: a
    obj cb :: VolumeMonitorVolumeAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeAddedCallback VolumeMonitorVolumeAddedCallback
    cb
        FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' <- C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeAddedCallback C_VolumeMonitorVolumeAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorVolumeAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "volume-added" FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [volumeAdded](#signal:volumeAdded) 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' volumeMonitor #volumeAdded callback
    -- @
    --
    --
    afterVolumeMonitorVolumeAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    afterVolumeMonitorVolumeAdded :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    afterVolumeMonitorVolumeAdded obj :: a
    obj cb :: VolumeMonitorVolumeAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeAddedCallback VolumeMonitorVolumeAddedCallback
    cb
        FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' <- C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeAddedCallback C_VolumeMonitorVolumeAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorVolumeAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "volume-added" FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorVolumeAddedSignalInfo
    instance SignalInfo VolumeMonitorVolumeAddedSignalInfo where
        type HaskellCallbackType VolumeMonitorVolumeAddedSignalInfo = VolumeMonitorVolumeAddedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorVolumeAddedCallback cb
            cb'' <- mk_VolumeMonitorVolumeAddedCallback cb'
            connectSignalFunPtr obj "volume-added" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::volume-changed
    -- | Emitted when mountable volume is changed.
    type VolumeMonitorVolumeChangedCallback =
        Gio.Volume.Volume
        -- ^ /@volume@/: a t'GI.Gio.Interfaces.Volume.Volume' that changed.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorVolumeChangedCallback`@.
    noVolumeMonitorVolumeChangedCallback :: Maybe VolumeMonitorVolumeChangedCallback
    noVolumeMonitorVolumeChangedCallback :: Maybe VolumeMonitorVolumeAddedCallback
    noVolumeMonitorVolumeChangedCallback = Maybe VolumeMonitorVolumeAddedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorVolumeChanged :: MonadIO m => VolumeMonitorVolumeChangedCallback -> m (GClosure C_VolumeMonitorVolumeChangedCallback)
    genClosure_VolumeMonitorVolumeChanged :: VolumeMonitorVolumeAddedCallback
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    genClosure_VolumeMonitorVolumeChanged cb :: VolumeMonitorVolumeAddedCallback
    cb = IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorVolumeAddedCallback)
     -> m (GClosure C_VolumeMonitorVolumeAddedCallback))
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeChangedCallback VolumeMonitorVolumeAddedCallback
    cb
        C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeChangedCallback C_VolumeMonitorVolumeAddedCallback
    cb' IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    -> (FunPtr C_VolumeMonitorVolumeAddedCallback
        -> IO (GClosure C_VolumeMonitorVolumeAddedCallback))
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorVolumeAddedCallback
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorVolumeChangedCallback` into a `C_VolumeMonitorVolumeChangedCallback`.
    wrap_VolumeMonitorVolumeChangedCallback ::
        VolumeMonitorVolumeChangedCallback ->
        C_VolumeMonitorVolumeChangedCallback
    wrap_VolumeMonitorVolumeChangedCallback :: VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeChangedCallback _cb :: VolumeMonitorVolumeAddedCallback
    _cb _ volume :: Ptr Volume
    volume _ = do
        Volume
    volume' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Volume -> Volume
    Gio.Volume.Volume) Ptr Volume
    volume
        VolumeMonitorVolumeAddedCallback
    _cb  Volume
    volume'

    -- | Connect a signal handler for the [volumeChanged](#signal:volumeChanged) 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' volumeMonitor #volumeChanged callback
    -- @
    --
    --
    onVolumeMonitorVolumeChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeChangedCallback -> m SignalHandlerId
    onVolumeMonitorVolumeChanged :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    onVolumeMonitorVolumeChanged obj :: a
    obj cb :: VolumeMonitorVolumeAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeChangedCallback VolumeMonitorVolumeAddedCallback
    cb
        FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' <- C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeChangedCallback C_VolumeMonitorVolumeAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorVolumeAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "volume-changed" FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [volumeChanged](#signal:volumeChanged) 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' volumeMonitor #volumeChanged callback
    -- @
    --
    --
    afterVolumeMonitorVolumeChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeChangedCallback -> m SignalHandlerId
    afterVolumeMonitorVolumeChanged :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    afterVolumeMonitorVolumeChanged obj :: a
    obj cb :: VolumeMonitorVolumeAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeChangedCallback VolumeMonitorVolumeAddedCallback
    cb
        FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' <- C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeChangedCallback C_VolumeMonitorVolumeAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorVolumeAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "volume-changed" FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorVolumeChangedSignalInfo
    instance SignalInfo VolumeMonitorVolumeChangedSignalInfo where
        type HaskellCallbackType VolumeMonitorVolumeChangedSignalInfo = VolumeMonitorVolumeChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorVolumeChangedCallback cb
            cb'' <- mk_VolumeMonitorVolumeChangedCallback cb'
            connectSignalFunPtr obj "volume-changed" cb'' connectMode detail

    #endif

    -- signal VolumeMonitor::volume-removed
    -- | Emitted when a mountable volume is removed from the system.
    type VolumeMonitorVolumeRemovedCallback =
        Gio.Volume.Volume
        -- ^ /@volume@/: a t'GI.Gio.Interfaces.Volume.Volume' that was removed.
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorVolumeRemovedCallback`@.
    noVolumeMonitorVolumeRemovedCallback :: Maybe VolumeMonitorVolumeRemovedCallback
    noVolumeMonitorVolumeRemovedCallback :: Maybe VolumeMonitorVolumeAddedCallback
    noVolumeMonitorVolumeRemovedCallback = Maybe VolumeMonitorVolumeAddedCallback
    forall a. Maybe a
    Nothing

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

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

    -- | Wrap the callback into a `GClosure`.
    genClosure_VolumeMonitorVolumeRemoved :: MonadIO m => VolumeMonitorVolumeRemovedCallback -> m (GClosure C_VolumeMonitorVolumeRemovedCallback)
    genClosure_VolumeMonitorVolumeRemoved :: VolumeMonitorVolumeAddedCallback
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    genClosure_VolumeMonitorVolumeRemoved cb :: VolumeMonitorVolumeAddedCallback
    cb = IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (GClosure C_VolumeMonitorVolumeAddedCallback)
     -> m (GClosure C_VolumeMonitorVolumeAddedCallback))
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeRemovedCallback VolumeMonitorVolumeAddedCallback
    cb
        C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeRemovedCallback C_VolumeMonitorVolumeAddedCallback
    cb' IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    -> (FunPtr C_VolumeMonitorVolumeAddedCallback
        -> IO (GClosure C_VolumeMonitorVolumeAddedCallback))
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= FunPtr C_VolumeMonitorVolumeAddedCallback
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
    forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
    B.GClosure.newGClosure

    -- | Wrap a `VolumeMonitorVolumeRemovedCallback` into a `C_VolumeMonitorVolumeRemovedCallback`.
    wrap_VolumeMonitorVolumeRemovedCallback ::
        VolumeMonitorVolumeRemovedCallback ->
        C_VolumeMonitorVolumeRemovedCallback
    wrap_VolumeMonitorVolumeRemovedCallback :: VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeRemovedCallback _cb :: VolumeMonitorVolumeAddedCallback
    _cb _ volume :: Ptr Volume
    volume _ = do
        Volume
    volume' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Volume -> Volume
    Gio.Volume.Volume) Ptr Volume
    volume
        VolumeMonitorVolumeAddedCallback
    _cb  Volume
    volume'

    -- | Connect a signal handler for the [volumeRemoved](#signal:volumeRemoved) 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' volumeMonitor #volumeRemoved callback
    -- @
    --
    --
    onVolumeMonitorVolumeRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeRemovedCallback -> m SignalHandlerId
    onVolumeMonitorVolumeRemoved :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    onVolumeMonitorVolumeRemoved obj :: a
    obj cb :: VolumeMonitorVolumeAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeRemovedCallback VolumeMonitorVolumeAddedCallback
    cb
        FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' <- C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeRemovedCallback C_VolumeMonitorVolumeAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorVolumeAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "volume-removed" FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' SignalConnectMode
    SignalConnectBefore Maybe Text
    forall a. Maybe a
    Nothing

    -- | Connect a signal handler for the [volumeRemoved](#signal:volumeRemoved) 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' volumeMonitor #volumeRemoved callback
    -- @
    --
    --
    afterVolumeMonitorVolumeRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeRemovedCallback -> m SignalHandlerId
    afterVolumeMonitorVolumeRemoved :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
    afterVolumeMonitorVolumeRemoved obj :: a
    obj cb :: VolumeMonitorVolumeAddedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let cb' :: C_VolumeMonitorVolumeAddedCallback
    cb' = VolumeMonitorVolumeAddedCallback
    -> C_VolumeMonitorVolumeAddedCallback
    wrap_VolumeMonitorVolumeRemovedCallback VolumeMonitorVolumeAddedCallback
    cb
        FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' <- C_VolumeMonitorVolumeAddedCallback
    -> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
    mk_VolumeMonitorVolumeRemovedCallback C_VolumeMonitorVolumeAddedCallback
    cb'
        a
    -> Text
    -> FunPtr C_VolumeMonitorVolumeAddedCallback
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    forall o a.
    GObject o =>
    o
    -> Text
    -> FunPtr a
    -> SignalConnectMode
    -> Maybe Text
    -> IO SignalHandlerId
    connectSignalFunPtr a
    obj "volume-removed" FunPtr C_VolumeMonitorVolumeAddedCallback
    cb'' SignalConnectMode
    SignalConnectAfter Maybe Text
    forall a. Maybe a
    Nothing

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorVolumeRemovedSignalInfo
    instance SignalInfo VolumeMonitorVolumeRemovedSignalInfo where
        type HaskellCallbackType VolumeMonitorVolumeRemovedSignalInfo = VolumeMonitorVolumeRemovedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_VolumeMonitorVolumeRemovedCallback cb
            cb'' <- mk_VolumeMonitorVolumeRemovedCallback cb'
            connectSignalFunPtr obj "volume-removed" cb'' connectMode detail

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList VolumeMonitor
    type instance O.AttributeList VolumeMonitor = VolumeMonitorAttributeList
    type VolumeMonitorAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList VolumeMonitor = VolumeMonitorSignalList
    type VolumeMonitorSignalList = ('[ '("driveChanged", VolumeMonitorDriveChangedSignalInfo), '("driveConnected", VolumeMonitorDriveConnectedSignalInfo), '("driveDisconnected", VolumeMonitorDriveDisconnectedSignalInfo), '("driveEjectButton", VolumeMonitorDriveEjectButtonSignalInfo), '("driveStopButton", VolumeMonitorDriveStopButtonSignalInfo), '("mountAdded", VolumeMonitorMountAddedSignalInfo), '("mountChanged", VolumeMonitorMountChangedSignalInfo), '("mountPreUnmount", VolumeMonitorMountPreUnmountSignalInfo), '("mountRemoved", VolumeMonitorMountRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("volumeAdded", VolumeMonitorVolumeAddedSignalInfo), '("volumeChanged", VolumeMonitorVolumeChangedSignalInfo), '("volumeRemoved", VolumeMonitorVolumeRemovedSignalInfo)] :: [(Symbol, *)])

    #endif

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

    foreign import ccall "g_volume_monitor_get_connected_drives" g_volume_monitor_get_connected_drives ::
        Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
        IO (Ptr (GList (Ptr Gio.Drive.Drive)))

    -- | Gets a list of drives connected to the system.
    --
    -- The returned list should be freed with @/g_list_free()/@, after
    -- its elements have been unreffed with 'GI.GObject.Objects.Object.objectUnref'.
    volumeMonitorGetConnectedDrives ::
        (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
        a
        -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
        -> m [Gio.Drive.Drive]
        -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of connected t'GI.Gio.Interfaces.Drive.Drive' objects.
    volumeMonitorGetConnectedDrives :: a -> m [Drive]
    volumeMonitorGetConnectedDrives volumeMonitor :: a
    volumeMonitor = IO [Drive] -> m [Drive]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Drive] -> m [Drive]) -> IO [Drive] -> m [Drive]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr VolumeMonitor
    volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    volumeMonitor
        Ptr (GList (Ptr Drive))
    result <- Ptr VolumeMonitor -> IO (Ptr (GList (Ptr Drive)))
    g_volume_monitor_get_connected_drives Ptr VolumeMonitor
    volumeMonitor'
        [Ptr Drive]
    result' <- Ptr (GList (Ptr Drive)) -> IO [Ptr Drive]
    forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
    unpackGList Ptr (GList (Ptr Drive))
    result
        [Drive]
    result'' <- (Ptr Drive -> IO Drive) -> [Ptr Drive] -> IO [Drive]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Drive -> Drive
    Gio.Drive.Drive) [Ptr Drive]
    result'
        Ptr (GList (Ptr Drive)) -> IO ()
    forall a. Ptr (GList a) -> IO ()
    g_list_free Ptr (GList (Ptr Drive))
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    volumeMonitor
        [Drive] -> IO [Drive]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Drive]
    result''

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorGetConnectedDrivesMethodInfo
    instance (signature ~ (m [Gio.Drive.Drive]), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetConnectedDrivesMethodInfo a signature where
        overloadedMethod = volumeMonitorGetConnectedDrives

    #endif

    -- method VolumeMonitor::get_mount_for_uuid
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "volume_monitor"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "VolumeMonitor" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GVolumeMonitor." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "uuid"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the UUID to look for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Mount" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_volume_monitor_get_mount_for_uuid" g_volume_monitor_get_mount_for_uuid ::
        Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
        CString ->                              -- uuid : TBasicType TUTF8
        IO (Ptr Gio.Mount.Mount)

    -- | Finds a t'GI.Gio.Interfaces.Mount.Mount' object by its UUID (see 'GI.Gio.Interfaces.Mount.mountGetUuid')
    volumeMonitorGetMountForUuid ::
        (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
        a
        -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
        -> T.Text
        -- ^ /@uuid@/: the UUID to look for
        -> m Gio.Mount.Mount
        -- ^ __Returns:__ a t'GI.Gio.Interfaces.Mount.Mount' or 'P.Nothing' if no such mount is available.
        --     Free the returned object with 'GI.GObject.Objects.Object.objectUnref'.
    volumeMonitorGetMountForUuid :: a -> Text -> m Mount
    volumeMonitorGetMountForUuid volumeMonitor :: a
    volumeMonitor uuid :: Text
    uuid = IO Mount -> m Mount
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Mount -> m Mount) -> IO Mount -> m Mount
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr VolumeMonitor
    volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    volumeMonitor
        CString
    uuid' <- Text -> IO CString
    textToCString Text
    uuid
        Ptr Mount
    result <- Ptr VolumeMonitor -> CString -> IO (Ptr Mount)
    g_volume_monitor_get_mount_for_uuid Ptr VolumeMonitor
    volumeMonitor' CString
    uuid'
        Text -> Ptr Mount -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "volumeMonitorGetMountForUuid" Ptr Mount
    result
        Mount
    result' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Mount -> Mount
    Gio.Mount.Mount) Ptr Mount
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    volumeMonitor
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    uuid'
        Mount -> IO Mount
    forall (m :: * -> *) a. Monad m => a -> m a
    return Mount
    result'

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorGetMountForUuidMethodInfo
    instance (signature ~ (T.Text -> m Gio.Mount.Mount), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetMountForUuidMethodInfo a signature where
        overloadedMethod = volumeMonitorGetMountForUuid

    #endif

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

    foreign import ccall "g_volume_monitor_get_mounts" g_volume_monitor_get_mounts ::
        Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
        IO (Ptr (GList (Ptr Gio.Mount.Mount)))

    -- | Gets a list of the mounts on the system.
    --
    -- The returned list should be freed with @/g_list_free()/@, after
    -- its elements have been unreffed with 'GI.GObject.Objects.Object.objectUnref'.
    volumeMonitorGetMounts ::
        (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
        a
        -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
        -> m [Gio.Mount.Mount]
        -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of t'GI.Gio.Interfaces.Mount.Mount' objects.
    volumeMonitorGetMounts :: a -> m [Mount]
    volumeMonitorGetMounts volumeMonitor :: a
    volumeMonitor = IO [Mount] -> m [Mount]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Mount] -> m [Mount]) -> IO [Mount] -> m [Mount]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr VolumeMonitor
    volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    volumeMonitor
        Ptr (GList (Ptr Mount))
    result <- Ptr VolumeMonitor -> IO (Ptr (GList (Ptr Mount)))
    g_volume_monitor_get_mounts Ptr VolumeMonitor
    volumeMonitor'
        [Ptr Mount]
    result' <- Ptr (GList (Ptr Mount)) -> IO [Ptr Mount]
    forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
    unpackGList Ptr (GList (Ptr Mount))
    result
        [Mount]
    result'' <- (Ptr Mount -> IO Mount) -> [Ptr Mount] -> IO [Mount]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Mount -> Mount
    Gio.Mount.Mount) [Ptr Mount]
    result'
        Ptr (GList (Ptr Mount)) -> IO ()
    forall a. Ptr (GList a) -> IO ()
    g_list_free Ptr (GList (Ptr Mount))
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    volumeMonitor
        [Mount] -> IO [Mount]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Mount]
    result''

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorGetMountsMethodInfo
    instance (signature ~ (m [Gio.Mount.Mount]), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetMountsMethodInfo a signature where
        overloadedMethod = volumeMonitorGetMounts

    #endif

    -- method VolumeMonitor::get_volume_for_uuid
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "volume_monitor"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "VolumeMonitor" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GVolumeMonitor." , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "uuid"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the UUID to look for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Volume" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_volume_monitor_get_volume_for_uuid" g_volume_monitor_get_volume_for_uuid ::
        Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
        CString ->                              -- uuid : TBasicType TUTF8
        IO (Ptr Gio.Volume.Volume)

    -- | Finds a t'GI.Gio.Interfaces.Volume.Volume' object by its UUID (see 'GI.Gio.Interfaces.Volume.volumeGetUuid')
    volumeMonitorGetVolumeForUuid ::
        (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
        a
        -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
        -> T.Text
        -- ^ /@uuid@/: the UUID to look for
        -> m Gio.Volume.Volume
        -- ^ __Returns:__ a t'GI.Gio.Interfaces.Volume.Volume' or 'P.Nothing' if no such volume is available.
        --     Free the returned object with 'GI.GObject.Objects.Object.objectUnref'.
    volumeMonitorGetVolumeForUuid :: a -> Text -> m Volume
    volumeMonitorGetVolumeForUuid volumeMonitor :: a
    volumeMonitor uuid :: Text
    uuid = IO Volume -> m Volume
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Volume -> m Volume) -> IO Volume -> m Volume
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr VolumeMonitor
    volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    volumeMonitor
        CString
    uuid' <- Text -> IO CString
    textToCString Text
    uuid
        Ptr Volume
    result <- Ptr VolumeMonitor -> CString -> IO (Ptr Volume)
    g_volume_monitor_get_volume_for_uuid Ptr VolumeMonitor
    volumeMonitor' CString
    uuid'
        Text -> Ptr Volume -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "volumeMonitorGetVolumeForUuid" Ptr Volume
    result
        Volume
    result' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Volume -> Volume
    Gio.Volume.Volume) Ptr Volume
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    volumeMonitor
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    uuid'
        Volume -> IO Volume
    forall (m :: * -> *) a. Monad m => a -> m a
    return Volume
    result'

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorGetVolumeForUuidMethodInfo
    instance (signature ~ (T.Text -> m Gio.Volume.Volume), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetVolumeForUuidMethodInfo a signature where
        overloadedMethod = volumeMonitorGetVolumeForUuid

    #endif

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

    foreign import ccall "g_volume_monitor_get_volumes" g_volume_monitor_get_volumes ::
        Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
        IO (Ptr (GList (Ptr Gio.Volume.Volume)))

    -- | Gets a list of the volumes on the system.
    --
    -- The returned list should be freed with @/g_list_free()/@, after
    -- its elements have been unreffed with 'GI.GObject.Objects.Object.objectUnref'.
    volumeMonitorGetVolumes ::
        (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
        a
        -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
        -> m [Gio.Volume.Volume]
        -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of t'GI.Gio.Interfaces.Volume.Volume' objects.
    volumeMonitorGetVolumes :: a -> m [Volume]
    volumeMonitorGetVolumes volumeMonitor :: a
    volumeMonitor = IO [Volume] -> m [Volume]
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Volume] -> m [Volume]) -> IO [Volume] -> m [Volume]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr VolumeMonitor
    volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    volumeMonitor
        Ptr (GList (Ptr Volume))
    result <- Ptr VolumeMonitor -> IO (Ptr (GList (Ptr Volume)))
    g_volume_monitor_get_volumes Ptr VolumeMonitor
    volumeMonitor'
        [Ptr Volume]
    result' <- Ptr (GList (Ptr Volume)) -> IO [Ptr Volume]
    forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
    unpackGList Ptr (GList (Ptr Volume))
    result
        [Volume]
    result'' <- (Ptr Volume -> IO Volume) -> [Ptr Volume] -> IO [Volume]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Volume -> Volume
    Gio.Volume.Volume) [Ptr Volume]
    result'
        Ptr (GList (Ptr Volume)) -> IO ()
    forall a. Ptr (GList a) -> IO ()
    g_list_free Ptr (GList (Ptr Volume))
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    volumeMonitor
        [Volume] -> IO [Volume]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Volume]
    result''

    #if defined(ENABLE_OVERLOADING)
    data VolumeMonitorGetVolumesMethodInfo
    instance (signature ~ (m [Gio.Volume.Volume]), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetVolumesMethodInfo a signature where
        overloadedMethod = volumeMonitorGetVolumes

    #endif

    -- method VolumeMonitor::adopt_orphan_mount
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "mount"
    --           , argType = TInterface Name { namespace = "Gio" , name = "Mount" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GMount object to find a parent for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Volume" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_volume_monitor_adopt_orphan_mount" g_volume_monitor_adopt_orphan_mount ::
        Ptr Gio.Mount.Mount ->                  -- mount : TInterface (Name {namespace = "Gio", name = "Mount"})
        IO (Ptr Gio.Volume.Volume)

    {-# DEPRECATED volumeMonitorAdoptOrphanMount ["(Since version 2.20)","Instead of using this function, t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'","implementations should instead create shadow mounts with the URI of","the mount they intend to adopt. See the proxy volume monitor in","gvfs for an example of this. Also see 'GI.Gio.Interfaces.Mount.mountIsShadowed',","'GI.Gio.Interfaces.Mount.mountShadow' and 'GI.Gio.Interfaces.Mount.mountUnshadow' functions."] #-}
    -- | This function should be called by any t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'
    -- implementation when a new t'GI.Gio.Interfaces.Mount.Mount' object is created that is not
    -- associated with a t'GI.Gio.Interfaces.Volume.Volume' object. It must be called just before
    -- emitting the /@mountAdded@/ signal.
    --
    -- If the return value is not 'P.Nothing', the caller must associate the
    -- returned t'GI.Gio.Interfaces.Volume.Volume' object with the t'GI.Gio.Interfaces.Mount.Mount'. This involves returning
    -- it in its 'GI.Gio.Interfaces.Mount.mountGetVolume' implementation. The caller must
    -- also listen for the \"removed\" signal on the returned object
    -- and give up its reference when handling that signal
    --
    -- Similarly, if implementing 'GI.Gio.Objects.VolumeMonitor.volumeMonitorAdoptOrphanMount',
    -- the implementor must take a reference to /@mount@/ and return it in
    -- its 'GI.Gio.Interfaces.Volume.volumeGetMount' implemented. Also, the implementor must
    -- listen for the \"unmounted\" signal on /@mount@/ and give up its
    -- reference upon handling that signal.
    --
    -- There are two main use cases for this function.
    --
    -- One is when implementing a user space file system driver that reads
    -- blocks of a block device that is already represented by the native
    -- volume monitor (for example a CD Audio file system driver). Such
    -- a driver will generate its own t'GI.Gio.Interfaces.Mount.Mount' object that needs to be
    -- associated with the t'GI.Gio.Interfaces.Volume.Volume' object that represents the volume.
    --
    -- The other is for implementing a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' whose sole purpose
    -- is to return t'GI.Gio.Interfaces.Volume.Volume' objects representing entries in the users
    -- \"favorite servers\" list or similar.
    volumeMonitorAdoptOrphanMount ::
        (B.CallStack.HasCallStack, MonadIO m, Gio.Mount.IsMount a) =>
        a
        -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' object to find a parent for
        -> m Gio.Volume.Volume
        -- ^ __Returns:__ the t'GI.Gio.Interfaces.Volume.Volume' object that is the parent for /@mount@/ or 'P.Nothing'
        -- if no wants to adopt the t'GI.Gio.Interfaces.Mount.Mount'.
    volumeMonitorAdoptOrphanMount :: a -> m Volume
    volumeMonitorAdoptOrphanMount mount :: a
    mount = IO Volume -> m Volume
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Volume -> m Volume) -> IO Volume -> m Volume
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Mount
    mount' <- a -> IO (Ptr Mount)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    mount
        Ptr Volume
    result <- Ptr Mount -> IO (Ptr Volume)
    g_volume_monitor_adopt_orphan_mount Ptr Mount
    mount'
        Text -> Ptr Volume -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "volumeMonitorAdoptOrphanMount" Ptr Volume
    result
        Volume
    result' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Volume -> Volume
    Gio.Volume.Volume) Ptr Volume
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    mount
        Volume -> IO Volume
    forall (m :: * -> *) a. Monad m => a -> m a
    return Volume
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "g_volume_monitor_get" g_volume_monitor_get ::
        IO (Ptr VolumeMonitor)

    -- | Gets the volume monitor used by gio.
    volumeMonitorGet ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m VolumeMonitor
        -- ^ __Returns:__ a reference to the t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' used by gio. Call
        --    'GI.GObject.Objects.Object.objectUnref' when done with it.
    volumeMonitorGet :: m VolumeMonitor
    volumeMonitorGet  = IO VolumeMonitor -> m VolumeMonitor
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO VolumeMonitor -> m VolumeMonitor)
    -> IO VolumeMonitor -> m VolumeMonitor
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr VolumeMonitor
    result <- IO (Ptr VolumeMonitor)
    g_volume_monitor_get
        Text -> Ptr VolumeMonitor -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "volumeMonitorGet" Ptr VolumeMonitor
    result
        VolumeMonitor
    result' <- ((ManagedPtr VolumeMonitor -> VolumeMonitor)
    -> Ptr VolumeMonitor -> IO VolumeMonitor
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr VolumeMonitor -> VolumeMonitor
    VolumeMonitor) Ptr VolumeMonitor
    result
        VolumeMonitor -> IO VolumeMonitor
    forall (m :: * -> *) a. Monad m => a -> m a
    return VolumeMonitor
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif