Sysroot.hs


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

/No description available in the introspection data./
-}

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

module GI.OSTree.Objects.Sysroot
    ( 

-- * Exported types
    Sysroot(..)                             ,
    IsSysroot                               ,
    toSysroot                               ,
    noSysroot                               ,


 -- * Methods
-- ** cleanup #method:cleanup#

#if ENABLE_OVERLOADING
    SysrootCleanupMethodInfo                ,
#endif
    sysrootCleanup                          ,


-- ** cleanupPruneRepo #method:cleanupPruneRepo#

#if ENABLE_OVERLOADING
    SysrootCleanupPruneRepoMethodInfo       ,
#endif
    sysrootCleanupPruneRepo                 ,


-- ** deployTree #method:deployTree#

#if ENABLE_OVERLOADING
    SysrootDeployTreeMethodInfo             ,
#endif
    sysrootDeployTree                       ,


-- ** deploymentSetKargs #method:deploymentSetKargs#

#if ENABLE_OVERLOADING
    SysrootDeploymentSetKargsMethodInfo     ,
#endif
    sysrootDeploymentSetKargs               ,


-- ** deploymentSetMutable #method:deploymentSetMutable#

#if ENABLE_OVERLOADING
    SysrootDeploymentSetMutableMethodInfo   ,
#endif
    sysrootDeploymentSetMutable             ,


-- ** deploymentSetPinned #method:deploymentSetPinned#

#if ENABLE_OVERLOADING
    SysrootDeploymentSetPinnedMethodInfo    ,
#endif
    sysrootDeploymentSetPinned              ,


-- ** deploymentUnlock #method:deploymentUnlock#

#if ENABLE_OVERLOADING
    SysrootDeploymentUnlockMethodInfo       ,
#endif
    sysrootDeploymentUnlock                 ,


-- ** ensureInitialized #method:ensureInitialized#

#if ENABLE_OVERLOADING
    SysrootEnsureInitializedMethodInfo      ,
#endif
    sysrootEnsureInitialized                ,


-- ** getBootedDeployment #method:getBootedDeployment#

#if ENABLE_OVERLOADING
    SysrootGetBootedDeploymentMethodInfo    ,
#endif
    sysrootGetBootedDeployment              ,


-- ** getBootversion #method:getBootversion#

#if ENABLE_OVERLOADING
    SysrootGetBootversionMethodInfo         ,
#endif
    sysrootGetBootversion                   ,


-- ** getDeploymentDirectory #method:getDeploymentDirectory#

#if ENABLE_OVERLOADING
    SysrootGetDeploymentDirectoryMethodInfo ,
#endif
    sysrootGetDeploymentDirectory           ,


-- ** getDeploymentDirpath #method:getDeploymentDirpath#

#if ENABLE_OVERLOADING
    SysrootGetDeploymentDirpathMethodInfo   ,
#endif
    sysrootGetDeploymentDirpath             ,


-- ** getDeploymentOriginPath #method:getDeploymentOriginPath#

    sysrootGetDeploymentOriginPath          ,


-- ** getDeployments #method:getDeployments#

#if ENABLE_OVERLOADING
    SysrootGetDeploymentsMethodInfo         ,
#endif
    sysrootGetDeployments                   ,


-- ** getFd #method:getFd#

#if ENABLE_OVERLOADING
    SysrootGetFdMethodInfo                  ,
#endif
    sysrootGetFd                            ,


-- ** getMergeDeployment #method:getMergeDeployment#

#if ENABLE_OVERLOADING
    SysrootGetMergeDeploymentMethodInfo     ,
#endif
    sysrootGetMergeDeployment               ,


-- ** getPath #method:getPath#

#if ENABLE_OVERLOADING
    SysrootGetPathMethodInfo                ,
#endif
    sysrootGetPath                          ,


-- ** getRepo #method:getRepo#

#if ENABLE_OVERLOADING
    SysrootGetRepoMethodInfo                ,
#endif
    sysrootGetRepo                          ,


-- ** getStagedDeployment #method:getStagedDeployment#

#if ENABLE_OVERLOADING
    SysrootGetStagedDeploymentMethodInfo    ,
#endif
    sysrootGetStagedDeployment              ,


-- ** getSubbootversion #method:getSubbootversion#

#if ENABLE_OVERLOADING
    SysrootGetSubbootversionMethodInfo      ,
#endif
    sysrootGetSubbootversion                ,


-- ** initOsname #method:initOsname#

#if ENABLE_OVERLOADING
    SysrootInitOsnameMethodInfo             ,
#endif
    sysrootInitOsname                       ,


-- ** load #method:load#

#if ENABLE_OVERLOADING
    SysrootLoadMethodInfo                   ,
#endif
    sysrootLoad                             ,


-- ** loadIfChanged #method:loadIfChanged#

#if ENABLE_OVERLOADING
    SysrootLoadIfChangedMethodInfo          ,
#endif
    sysrootLoadIfChanged                    ,


-- ** lock #method:lock#

#if ENABLE_OVERLOADING
    SysrootLockMethodInfo                   ,
#endif
    sysrootLock                             ,


-- ** lockAsync #method:lockAsync#

#if ENABLE_OVERLOADING
    SysrootLockAsyncMethodInfo              ,
#endif
    sysrootLockAsync                        ,


-- ** lockFinish #method:lockFinish#

#if ENABLE_OVERLOADING
    SysrootLockFinishMethodInfo             ,
#endif
    sysrootLockFinish                       ,


-- ** new #method:new#

    sysrootNew                              ,


-- ** newDefault #method:newDefault#

    sysrootNewDefault                       ,


-- ** originNewFromRefspec #method:originNewFromRefspec#

#if ENABLE_OVERLOADING
    SysrootOriginNewFromRefspecMethodInfo   ,
#endif
    sysrootOriginNewFromRefspec             ,


-- ** prepareCleanup #method:prepareCleanup#

#if ENABLE_OVERLOADING
    SysrootPrepareCleanupMethodInfo         ,
#endif
    sysrootPrepareCleanup                   ,


-- ** queryDeploymentsFor #method:queryDeploymentsFor#

#if ENABLE_OVERLOADING
    SysrootQueryDeploymentsForMethodInfo    ,
#endif
    sysrootQueryDeploymentsFor              ,


-- ** repo #method:repo#

#if ENABLE_OVERLOADING
    SysrootRepoMethodInfo                   ,
#endif
    sysrootRepo                             ,


-- ** simpleWriteDeployment #method:simpleWriteDeployment#

#if ENABLE_OVERLOADING
    SysrootSimpleWriteDeploymentMethodInfo  ,
#endif
    sysrootSimpleWriteDeployment            ,


-- ** stageTree #method:stageTree#

#if ENABLE_OVERLOADING
    SysrootStageTreeMethodInfo              ,
#endif
    sysrootStageTree                        ,


-- ** tryLock #method:tryLock#

#if ENABLE_OVERLOADING
    SysrootTryLockMethodInfo                ,
#endif
    sysrootTryLock                          ,


-- ** unload #method:unload#

#if ENABLE_OVERLOADING
    SysrootUnloadMethodInfo                 ,
#endif
    sysrootUnload                           ,


-- ** unlock #method:unlock#

#if ENABLE_OVERLOADING
    SysrootUnlockMethodInfo                 ,
#endif
    sysrootUnlock                           ,


-- ** writeDeployments #method:writeDeployments#

#if ENABLE_OVERLOADING
    SysrootWriteDeploymentsMethodInfo       ,
#endif
    sysrootWriteDeployments                 ,


-- ** writeDeploymentsWithOptions #method:writeDeploymentsWithOptions#

#if ENABLE_OVERLOADING
    SysrootWriteDeploymentsWithOptionsMethodInfo,
#endif
    sysrootWriteDeploymentsWithOptions      ,


-- ** writeOriginFile #method:writeOriginFile#

#if ENABLE_OVERLOADING
    SysrootWriteOriginFileMethodInfo        ,
#endif
    sysrootWriteOriginFile                  ,




 -- * Properties
-- ** path #attr:path#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    SysrootPathPropertyInfo                 ,
#endif
    constructSysrootPath                    ,
    getSysrootPath                          ,
#if ENABLE_OVERLOADING
    sysrootPath                             ,
#endif




 -- * Signals
-- ** journalMsg #signal:journalMsg#

    C_SysrootJournalMsgCallback             ,
    SysrootJournalMsgCallback               ,
#if ENABLE_OVERLOADING
    SysrootJournalMsgSignalInfo             ,
#endif
    afterSysrootJournalMsg                  ,
    genClosure_SysrootJournalMsg            ,
    mk_SysrootJournalMsgCallback            ,
    noSysrootJournalMsgCallback             ,
    onSysrootJournalMsg                     ,
    wrap_SysrootJournalMsgCallback          ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GLib.Structs.KeyFile as GLib.KeyFile
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags
import {-# SOURCE #-} qualified GI.OSTree.Objects.Deployment as OSTree.Deployment
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoPruneOptions as OSTree.RepoPruneOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.SysrootWriteDeploymentsOpts as OSTree.SysrootWriteDeploymentsOpts

-- | Memory-managed wrapper type.
newtype Sysroot = Sysroot (ManagedPtr Sysroot)
foreign import ccall "ostree_sysroot_get_type"
    c_ostree_sysroot_get_type :: IO GType

instance GObject Sysroot where
    gobjectType = c_ostree_sysroot_get_type
    

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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `Sysroot`.
noSysroot :: Maybe Sysroot
noSysroot = Nothing

#if ENABLE_OVERLOADING
type family ResolveSysrootMethod (t :: Symbol) (o :: *) :: * where
    ResolveSysrootMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSysrootMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSysrootMethod "cleanup" o = SysrootCleanupMethodInfo
    ResolveSysrootMethod "cleanupPruneRepo" o = SysrootCleanupPruneRepoMethodInfo
    ResolveSysrootMethod "deployTree" o = SysrootDeployTreeMethodInfo
    ResolveSysrootMethod "deploymentSetKargs" o = SysrootDeploymentSetKargsMethodInfo
    ResolveSysrootMethod "deploymentSetMutable" o = SysrootDeploymentSetMutableMethodInfo
    ResolveSysrootMethod "deploymentSetPinned" o = SysrootDeploymentSetPinnedMethodInfo
    ResolveSysrootMethod "deploymentUnlock" o = SysrootDeploymentUnlockMethodInfo
    ResolveSysrootMethod "ensureInitialized" o = SysrootEnsureInitializedMethodInfo
    ResolveSysrootMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSysrootMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSysrootMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSysrootMethod "initOsname" o = SysrootInitOsnameMethodInfo
    ResolveSysrootMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSysrootMethod "load" o = SysrootLoadMethodInfo
    ResolveSysrootMethod "loadIfChanged" o = SysrootLoadIfChangedMethodInfo
    ResolveSysrootMethod "lock" o = SysrootLockMethodInfo
    ResolveSysrootMethod "lockAsync" o = SysrootLockAsyncMethodInfo
    ResolveSysrootMethod "lockFinish" o = SysrootLockFinishMethodInfo
    ResolveSysrootMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSysrootMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSysrootMethod "originNewFromRefspec" o = SysrootOriginNewFromRefspecMethodInfo
    ResolveSysrootMethod "prepareCleanup" o = SysrootPrepareCleanupMethodInfo
    ResolveSysrootMethod "queryDeploymentsFor" o = SysrootQueryDeploymentsForMethodInfo
    ResolveSysrootMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSysrootMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSysrootMethod "repo" o = SysrootRepoMethodInfo
    ResolveSysrootMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSysrootMethod "simpleWriteDeployment" o = SysrootSimpleWriteDeploymentMethodInfo
    ResolveSysrootMethod "stageTree" o = SysrootStageTreeMethodInfo
    ResolveSysrootMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSysrootMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSysrootMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSysrootMethod "tryLock" o = SysrootTryLockMethodInfo
    ResolveSysrootMethod "unload" o = SysrootUnloadMethodInfo
    ResolveSysrootMethod "unlock" o = SysrootUnlockMethodInfo
    ResolveSysrootMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSysrootMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSysrootMethod "writeDeployments" o = SysrootWriteDeploymentsMethodInfo
    ResolveSysrootMethod "writeDeploymentsWithOptions" o = SysrootWriteDeploymentsWithOptionsMethodInfo
    ResolveSysrootMethod "writeOriginFile" o = SysrootWriteOriginFileMethodInfo
    ResolveSysrootMethod "getBootedDeployment" o = SysrootGetBootedDeploymentMethodInfo
    ResolveSysrootMethod "getBootversion" o = SysrootGetBootversionMethodInfo
    ResolveSysrootMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSysrootMethod "getDeploymentDirectory" o = SysrootGetDeploymentDirectoryMethodInfo
    ResolveSysrootMethod "getDeploymentDirpath" o = SysrootGetDeploymentDirpathMethodInfo
    ResolveSysrootMethod "getDeployments" o = SysrootGetDeploymentsMethodInfo
    ResolveSysrootMethod "getFd" o = SysrootGetFdMethodInfo
    ResolveSysrootMethod "getMergeDeployment" o = SysrootGetMergeDeploymentMethodInfo
    ResolveSysrootMethod "getPath" o = SysrootGetPathMethodInfo
    ResolveSysrootMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSysrootMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSysrootMethod "getRepo" o = SysrootGetRepoMethodInfo
    ResolveSysrootMethod "getStagedDeployment" o = SysrootGetStagedDeploymentMethodInfo
    ResolveSysrootMethod "getSubbootversion" o = SysrootGetSubbootversionMethodInfo
    ResolveSysrootMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSysrootMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSysrootMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Sysroot::journal-msg
{- |
libostree will log to the journal various events, such as the \/etc merge
status, and transaction completion. Connect to this signal to also
synchronously receive the text for those messages. This is intended to be
used by command line tools which link to libostree as a library.

Currently, the structured data is only available via the systemd journal.

/Since: 2017.10/
-}
type SysrootJournalMsgCallback =
    T.Text
    {- ^ /@msg@/: Human-readable string (should not contain newlines) -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SysrootJournalMsgCallback`@.
noSysrootJournalMsgCallback :: Maybe SysrootJournalMsgCallback
noSysrootJournalMsgCallback = Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_SysrootJournalMsg :: MonadIO m => SysrootJournalMsgCallback -> m (GClosure C_SysrootJournalMsgCallback)
genClosure_SysrootJournalMsg cb = liftIO $ do
    let cb' = wrap_SysrootJournalMsgCallback cb
    mk_SysrootJournalMsgCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `SysrootJournalMsgCallback` into a `C_SysrootJournalMsgCallback`.
wrap_SysrootJournalMsgCallback ::
    SysrootJournalMsgCallback ->
    C_SysrootJournalMsgCallback
wrap_SysrootJournalMsgCallback _cb _ msg _ = do
    msg' <- cstringToText msg
    _cb  msg'


{- |
Connect a signal handler for the “@journal-msg@” 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' sysroot #journalMsg callback
@
-}
onSysrootJournalMsg :: (IsSysroot a, MonadIO m) => a -> SysrootJournalMsgCallback -> m SignalHandlerId
onSysrootJournalMsg obj cb = liftIO $ do
    let cb' = wrap_SysrootJournalMsgCallback cb
    cb'' <- mk_SysrootJournalMsgCallback cb'
    connectSignalFunPtr obj "journal-msg" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@journal-msg@” 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' sysroot #journalMsg callback
@
-}
afterSysrootJournalMsg :: (IsSysroot a, MonadIO m) => a -> SysrootJournalMsgCallback -> m SignalHandlerId
afterSysrootJournalMsg obj cb = liftIO $ do
    let cb' = wrap_SysrootJournalMsgCallback cb
    cb'' <- mk_SysrootJournalMsgCallback cb'
    connectSignalFunPtr obj "journal-msg" cb'' SignalConnectAfter


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

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

@
'Data.GI.Base.Attributes.get' sysroot #path
@
-}
getSysrootPath :: (MonadIO m, IsSysroot o) => o -> m Gio.File.File
getSysrootPath obj = liftIO $ checkUnexpectedNothing "getSysrootPath" $ B.Properties.getObjectPropertyObject obj "path" Gio.File.File

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

#if ENABLE_OVERLOADING
data SysrootPathPropertyInfo
instance AttrInfo SysrootPathPropertyInfo where
    type AttrAllowedOps SysrootPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SysrootPathPropertyInfo = Gio.File.IsFile
    type AttrBaseTypeConstraint SysrootPathPropertyInfo = IsSysroot
    type AttrGetType SysrootPathPropertyInfo = Gio.File.File
    type AttrLabel SysrootPathPropertyInfo = "path"
    type AttrOrigin SysrootPathPropertyInfo = Sysroot
    attrGet _ = getSysrootPath
    attrSet _ = undefined
    attrConstruct _ = constructSysrootPath
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList Sysroot
type instance O.AttributeList Sysroot = SysrootAttributeList
type SysrootAttributeList = ('[ '("path", SysrootPathPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
sysrootPath :: AttrLabelProxy "path"
sysrootPath = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data SysrootJournalMsgSignalInfo
instance SignalInfo SysrootJournalMsgSignalInfo where
    type HaskellCallbackType SysrootJournalMsgSignalInfo = SysrootJournalMsgCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_SysrootJournalMsgCallback cb
        cb'' <- mk_SysrootJournalMsgCallback cb'
        connectSignalFunPtr obj "journal-msg" cb'' connectMode

type instance O.SignalList Sysroot = SysrootSignalList
type SysrootSignalList = ('[ '("journalMsg", SysrootJournalMsgSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Sysroot::new
-- method type : Constructor
-- Args : [Arg {argCName = "path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Path to a system root directory, or %NULL to use the\n  current visible root file system", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Sysroot"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_new" ostree_sysroot_new :: 
    Ptr Gio.File.File ->                    -- path : TInterface (Name {namespace = "Gio", name = "File"})
    IO (Ptr Sysroot)

{- |
Create a new 'GI.OSTree.Objects.Sysroot.Sysroot' object for the sysroot at /@path@/. If /@path@/ is 'Nothing',
the current visible root file system is used, equivalent to
'GI.OSTree.Objects.Sysroot.sysrootNewDefault'.
-}
sysrootNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
    Maybe (a)
    {- ^ /@path@/: Path to a system root directory, or 'Nothing' to use the
  current visible root file system -}
    -> m Sysroot
    {- ^ __Returns:__ An accessor object for an system root located at /@path@/ -}
sysrootNew path = liftIO $ do
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- unsafeManagedPtrCastPtr jPath
            return jPath'
    result <- ostree_sysroot_new maybePath
    checkUnexpectedReturnNULL "sysrootNew" result
    result' <- (wrapObject Sysroot) result
    whenJust path touchManagedPtr
    return result'

#if ENABLE_OVERLOADING
#endif

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

foreign import ccall "ostree_sysroot_new_default" ostree_sysroot_new_default :: 
    IO (Ptr Sysroot)

{- |
/No description available in the introspection data./
-}
sysrootNewDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Sysroot
    {- ^ __Returns:__ An accessor for the current visible root \/ filesystem -}
sysrootNewDefault  = liftIO $ do
    result <- ostree_sysroot_new_default
    checkUnexpectedReturnNULL "sysrootNewDefault" result
    result' <- (wrapObject Sysroot) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method Sysroot::cleanup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_cleanup" ostree_sysroot_cleanup :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Delete any state that resulted from a partially completed
transaction, such as incomplete deployments.
-}
sysrootCleanup ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootCleanup self cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_cleanup self' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

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

#endif

-- method Sysroot::cleanup_prune_repo
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "OSTree", name = "RepoPruneOptions"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling pruning", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_objects_total", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects found", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_objects_pruned", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Number of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_pruned_object_size_total", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Storage size in bytes of objects deleted", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_cleanup_prune_repo" ostree_sysroot_cleanup_prune_repo :: 
    Ptr Sysroot ->                          -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.RepoPruneOptions.RepoPruneOptions -> -- options : TInterface (Name {namespace = "OSTree", name = "RepoPruneOptions"})
    Ptr Int32 ->                            -- out_objects_total : TBasicType TInt
    Ptr Int32 ->                            -- out_objects_pruned : TBasicType TInt
    Ptr Word64 ->                           -- out_pruned_object_size_total : TBasicType TUInt64
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Prune the system repository.  This is a thin wrapper
around 'GI.OSTree.Objects.Repo.repoPruneFromReachable'; the primary
addition is that this function automatically gathers
all deployed commits into the reachable set.

You generally want to at least set the @OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY@
flag in /@options@/.  A commit traversal depth of @0@ is assumed.

Locking: exclusive

/Since: 2018.6/
-}
sysrootCleanupPruneRepo ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@sysroot@/: Sysroot -}
    -> OSTree.RepoPruneOptions.RepoPruneOptions
    {- ^ /@options@/: Flags controlling pruning -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ((Int32, Int32, Word64))
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootCleanupPruneRepo sysroot options cancellable = liftIO $ do
    sysroot' <- unsafeManagedPtrCastPtr sysroot
    options' <- unsafeManagedPtrGetPtr options
    outObjectsTotal <- allocMem :: IO (Ptr Int32)
    outObjectsPruned <- allocMem :: IO (Ptr Int32)
    outPrunedObjectSizeTotal <- allocMem :: IO (Ptr Word64)
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_cleanup_prune_repo sysroot' options' outObjectsTotal outObjectsPruned outPrunedObjectSizeTotal maybeCancellable
        outObjectsTotal' <- peek outObjectsTotal
        outObjectsPruned' <- peek outObjectsPruned
        outPrunedObjectSizeTotal' <- peek outPrunedObjectSizeTotal
        touchManagedPtr sysroot
        touchManagedPtr options
        whenJust cancellable touchManagedPtr
        freeMem outObjectsTotal
        freeMem outObjectsPruned
        freeMem outPrunedObjectSizeTotal
        return (outObjectsTotal', outObjectsPruned', outPrunedObjectSizeTotal')
     ) (do
        freeMem outObjectsTotal
        freeMem outObjectsPruned
        freeMem outPrunedObjectSizeTotal
     )

#if ENABLE_OVERLOADING
data SysrootCleanupPruneRepoMethodInfo
instance (signature ~ (OSTree.RepoPruneOptions.RepoPruneOptions -> Maybe (b) -> m ((Int32, Int32, Word64))), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootCleanupPruneRepoMethodInfo a signature where
    overloadedMethod _ = sysrootCleanupPruneRepo

#endif

-- method Sysroot::deploy_tree
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "osname to use for merge deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "revision", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Origin to use for upgrades", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "provided_merge_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use this deployment for merge path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "override_kernel_argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use these as kernel arguments; if %NULL, inherit options from provided_merge_deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_new_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new deployment path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_deploy_tree" ostree_sysroot_deploy_tree :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CString ->                              -- osname : TBasicType TUTF8
    CString ->                              -- revision : TBasicType TUTF8
    Ptr GLib.KeyFile.KeyFile ->             -- origin : TInterface (Name {namespace = "GLib", name = "KeyFile"})
    Ptr OSTree.Deployment.Deployment ->     -- provided_merge_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr CString ->                          -- override_kernel_argv : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_new_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Check out deployment tree with revision /@revision@/, performing a 3
way merge with /@providedMergeDeployment@/ for configuration.

While this API is not deprecated, you most likely want to use the
'GI.OSTree.Objects.Sysroot.sysrootStageTree' API.
-}
sysrootDeployTree ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (T.Text)
    {- ^ /@osname@/: osname to use for merge deployment -}
    -> T.Text
    {- ^ /@revision@/: Checksum to add -}
    -> Maybe (GLib.KeyFile.KeyFile)
    {- ^ /@origin@/: Origin to use for upgrades -}
    -> Maybe (b)
    {- ^ /@providedMergeDeployment@/: Use this deployment for merge path -}
    -> Maybe ([T.Text])
    {- ^ /@overrideKernelArgv@/: Use these as kernel arguments; if 'Nothing', inherit options from provided_merge_deployment -}
    -> Maybe (c)
    {- ^ /@cancellable@/: Cancellable -}
    -> m (OSTree.Deployment.Deployment)
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootDeployTree self osname revision origin providedMergeDeployment overrideKernelArgv cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeOsname <- case osname of
        Nothing -> return nullPtr
        Just jOsname -> do
            jOsname' <- textToCString jOsname
            return jOsname'
    revision' <- textToCString revision
    maybeOrigin <- case origin of
        Nothing -> return nullPtr
        Just jOrigin -> do
            jOrigin' <- unsafeManagedPtrGetPtr jOrigin
            return jOrigin'
    maybeProvidedMergeDeployment <- case providedMergeDeployment of
        Nothing -> return nullPtr
        Just jProvidedMergeDeployment -> do
            jProvidedMergeDeployment' <- unsafeManagedPtrCastPtr jProvidedMergeDeployment
            return jProvidedMergeDeployment'
    maybeOverrideKernelArgv <- case overrideKernelArgv of
        Nothing -> return nullPtr
        Just jOverrideKernelArgv -> do
            jOverrideKernelArgv' <- packZeroTerminatedUTF8CArray jOverrideKernelArgv
            return jOverrideKernelArgv'
    outNewDeployment <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment))
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_deploy_tree self' maybeOsname revision' maybeOrigin maybeProvidedMergeDeployment maybeOverrideKernelArgv outNewDeployment maybeCancellable
        outNewDeployment' <- peek outNewDeployment
        outNewDeployment'' <- (wrapObject OSTree.Deployment.Deployment) outNewDeployment'
        touchManagedPtr self
        whenJust origin touchManagedPtr
        whenJust providedMergeDeployment touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem maybeOsname
        freeMem revision'
        mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv
        freeMem maybeOverrideKernelArgv
        freeMem outNewDeployment
        return outNewDeployment''
     ) (do
        freeMem maybeOsname
        freeMem revision'
        mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv
        freeMem maybeOverrideKernelArgv
        freeMem outNewDeployment
     )

#if ENABLE_OVERLOADING
data SysrootDeployTreeMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (GLib.KeyFile.KeyFile) -> Maybe (b) -> Maybe ([T.Text]) -> Maybe (c) -> m (OSTree.Deployment.Deployment)), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeployTreeMethodInfo a signature where
    overloadedMethod _ = sysrootDeployTree

#endif

-- method Sysroot::deployment_set_kargs
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_kargs", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Replace deployment's kernel arguments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_deployment_set_kargs" ostree_sysroot_deployment_set_kargs :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.Deployment.Deployment ->     -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr CString ->                          -- new_kargs : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Entirely replace the kernel arguments of /@deployment@/ with the
values in /@newKargs@/.
-}
sysrootDeploymentSetKargs ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> b
    {- ^ /@deployment@/: A deployment -}
    -> [T.Text]
    {- ^ /@newKargs@/: Replace deployment\'s kernel arguments -}
    -> Maybe (c)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootDeploymentSetKargs self deployment newKargs cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    deployment' <- unsafeManagedPtrCastPtr deployment
    newKargs' <- packZeroTerminatedUTF8CArray newKargs
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_deployment_set_kargs self' deployment' newKargs' maybeCancellable
        touchManagedPtr self
        touchManagedPtr deployment
        whenJust cancellable touchManagedPtr
        mapZeroTerminatedCArray freeMem newKargs'
        freeMem newKargs'
        return ()
     ) (do
        mapZeroTerminatedCArray freeMem newKargs'
        freeMem newKargs'
     )

#if ENABLE_OVERLOADING
data SysrootDeploymentSetKargsMethodInfo
instance (signature ~ (b -> [T.Text] -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeploymentSetKargsMethodInfo a signature where
    overloadedMethod _ = sysrootDeploymentSetKargs

#endif

-- method Sysroot::deployment_set_mutable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_mutable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not deployment's files can be changed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_deployment_set_mutable" ostree_sysroot_deployment_set_mutable :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.Deployment.Deployment ->     -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    CInt ->                                 -- is_mutable : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
By default, deployment directories are not mutable.  This function
will allow making them temporarily mutable, for example to allow
layering additional non-OSTree content.
-}
sysrootDeploymentSetMutable ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> b
    {- ^ /@deployment@/: A deployment -}
    -> Bool
    {- ^ /@isMutable@/: Whether or not deployment\'s files can be changed -}
    -> Maybe (c)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootDeploymentSetMutable self deployment isMutable cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    deployment' <- unsafeManagedPtrCastPtr deployment
    let isMutable' = (fromIntegral . fromEnum) isMutable
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_deployment_set_mutable self' deployment' isMutable' maybeCancellable
        touchManagedPtr self
        touchManagedPtr deployment
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data SysrootDeploymentSetMutableMethodInfo
instance (signature ~ (b -> Bool -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeploymentSetMutableMethodInfo a signature where
    overloadedMethod _ = sysrootDeploymentSetMutable

#endif

-- method Sysroot::deployment_set_pinned
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_pinned", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not deployment will be automatically GC'd", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_deployment_set_pinned" ostree_sysroot_deployment_set_pinned :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.Deployment.Deployment ->     -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    CInt ->                                 -- is_pinned : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
By default, deployments may be subject to garbage collection. Typical uses of
libostree only retain at most 2 deployments. If /@isPinned@/ is @TRUE@, a
metadata bit will be set causing libostree to avoid automatic GC of the
deployment. However, this is really an \"advisory\" note; it\'s still possible
for e.g. older versions of libostree unaware of pinning to GC the deployment.

This function does nothing and returns successfully if the deployment
is already in the desired pinning state.  It is an error to try to pin
the staged deployment (as it\'s not in the bootloader entries).

/Since: 2018.3/
-}
sysrootDeploymentSetPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> b
    {- ^ /@deployment@/: A deployment -}
    -> Bool
    {- ^ /@isPinned@/: Whether or not deployment will be automatically GC\'d -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootDeploymentSetPinned self deployment isPinned = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    deployment' <- unsafeManagedPtrCastPtr deployment
    let isPinned' = (fromIntegral . fromEnum) isPinned
    onException (do
        _ <- propagateGError $ ostree_sysroot_deployment_set_pinned self' deployment' isPinned'
        touchManagedPtr self
        touchManagedPtr deployment
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data SysrootDeploymentSetPinnedMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => O.MethodInfo SysrootDeploymentSetPinnedMethodInfo a signature where
    overloadedMethod _ = sysrootDeploymentSetPinned

#endif

-- method Sysroot::deployment_unlock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unlocked_state", argType = TInterface (Name {namespace = "OSTree", name = "DeploymentUnlockedState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Transition to this unlocked state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_deployment_unlock" ostree_sysroot_deployment_unlock :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.Deployment.Deployment ->     -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    CUInt ->                                -- unlocked_state : TInterface (Name {namespace = "OSTree", name = "DeploymentUnlockedState"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Configure the target deployment /@deployment@/ such that it
is writable.  There are multiple modes, essentially differing
in whether or not any changes persist across reboot.

The @OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX@ state is persistent
across reboots.
-}
sysrootDeploymentUnlock ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> b
    {- ^ /@deployment@/: Deployment -}
    -> OSTree.Enums.DeploymentUnlockedState
    {- ^ /@unlockedState@/: Transition to this unlocked state -}
    -> Maybe (c)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootDeploymentUnlock self deployment unlockedState cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    deployment' <- unsafeManagedPtrCastPtr deployment
    let unlockedState' = (fromIntegral . fromEnum) unlockedState
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_deployment_unlock self' deployment' unlockedState' maybeCancellable
        touchManagedPtr self
        touchManagedPtr deployment
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data SysrootDeploymentUnlockMethodInfo
instance (signature ~ (b -> OSTree.Enums.DeploymentUnlockedState -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootDeploymentUnlockMethodInfo a signature where
    overloadedMethod _ = sysrootDeploymentUnlock

#endif

-- method Sysroot::ensure_initialized
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_ensure_initialized" ostree_sysroot_ensure_initialized :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Ensure that /@self@/ is set up as a valid rootfs, by creating
\/ostree\/repo, among other things.
-}
sysrootEnsureInitialized ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootEnsureInitialized self cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_ensure_initialized self' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

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

#endif

-- method Sysroot::get_booted_deployment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_booted_deployment" ostree_sysroot_get_booted_deployment :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO (Ptr OSTree.Deployment.Deployment)

{- |
/No description available in the introspection data./
-}
sysrootGetBootedDeployment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> m OSTree.Deployment.Deployment
    {- ^ __Returns:__ The currently booted deployment, or 'Nothing' if none -}
sysrootGetBootedDeployment self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_get_booted_deployment self'
    checkUnexpectedReturnNULL "sysrootGetBootedDeployment" result
    result' <- (newObject OSTree.Deployment.Deployment) result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data SysrootGetBootedDeploymentMethodInfo
instance (signature ~ (m OSTree.Deployment.Deployment), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetBootedDeploymentMethodInfo a signature where
    overloadedMethod _ = sysrootGetBootedDeployment

#endif

-- method Sysroot::get_bootversion
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_bootversion" ostree_sysroot_get_bootversion :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO Int32

{- |
/No description available in the introspection data./
-}
sysrootGetBootversion ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    -> m Int32
sysrootGetBootversion self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_get_bootversion self'
    touchManagedPtr self
    return result

#if ENABLE_OVERLOADING
data SysrootGetBootversionMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetBootversionMethodInfo a signature where
    overloadedMethod _ = sysrootGetBootversion

#endif

-- method Sysroot::get_deployment_directory
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_deployment_directory" ostree_sysroot_get_deployment_directory :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.Deployment.Deployment ->     -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    IO (Ptr Gio.File.File)

{- |
/No description available in the introspection data./
-}
sysrootGetDeploymentDirectory ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> b
    {- ^ /@deployment@/: A deployment -}
    -> m Gio.File.File
    {- ^ __Returns:__ Path to deployment root directory -}
sysrootGetDeploymentDirectory self deployment = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    deployment' <- unsafeManagedPtrCastPtr deployment
    result <- ostree_sysroot_get_deployment_directory self' deployment'
    checkUnexpectedReturnNULL "sysrootGetDeploymentDirectory" result
    result' <- (wrapObject Gio.File.File) result
    touchManagedPtr self
    touchManagedPtr deployment
    return result'

#if ENABLE_OVERLOADING
data SysrootGetDeploymentDirectoryMethodInfo
instance (signature ~ (b -> m Gio.File.File), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => O.MethodInfo SysrootGetDeploymentDirectoryMethodInfo a signature where
    overloadedMethod _ = sysrootGetDeploymentDirectory

#endif

-- method Sysroot::get_deployment_dirpath
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_deployment_dirpath" ostree_sysroot_get_deployment_dirpath :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.Deployment.Deployment ->     -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    IO CString

{- |
Note this function only returns a *relative* path - if you want
to access, it, you must either use fd-relative api such as @/openat()/@,
or concatenate it with the full 'GI.OSTree.Objects.Sysroot.sysrootGetPath'.
-}
sysrootGetDeploymentDirpath ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) =>
    a
    {- ^ /@self@/: Repo -}
    -> b
    {- ^ /@deployment@/: A deployment -}
    -> m T.Text
    {- ^ __Returns:__ Path to deployment root directory, relative to sysroot -}
sysrootGetDeploymentDirpath self deployment = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    deployment' <- unsafeManagedPtrCastPtr deployment
    result <- ostree_sysroot_get_deployment_dirpath self' deployment'
    checkUnexpectedReturnNULL "sysrootGetDeploymentDirpath" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    touchManagedPtr deployment
    return result'

#if ENABLE_OVERLOADING
data SysrootGetDeploymentDirpathMethodInfo
instance (signature ~ (b -> m T.Text), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b) => O.MethodInfo SysrootGetDeploymentDirpathMethodInfo a signature where
    overloadedMethod _ = sysrootGetDeploymentDirpath

#endif

-- method Sysroot::get_deployments
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"})))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_deployments" ostree_sysroot_get_deployments :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO (Ptr (GPtrArray (Ptr OSTree.Deployment.Deployment)))

{- |
/No description available in the introspection data./
-}
sysrootGetDeployments ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> m [OSTree.Deployment.Deployment]
    {- ^ __Returns:__ Ordered list of deployments -}
sysrootGetDeployments self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_get_deployments self'
    checkUnexpectedReturnNULL "sysrootGetDeployments" result
    result' <- unpackGPtrArray result
    result'' <- mapM (newObject OSTree.Deployment.Deployment) result'
    unrefPtrArray result
    touchManagedPtr self
    return result''

#if ENABLE_OVERLOADING
data SysrootGetDeploymentsMethodInfo
instance (signature ~ (m [OSTree.Deployment.Deployment]), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetDeploymentsMethodInfo a signature where
    overloadedMethod _ = sysrootGetDeployments

#endif

-- method Sysroot::get_fd
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_fd" ostree_sysroot_get_fd :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO Int32

{- |
Access a file descriptor that refers to the root directory of this
sysroot.  'GI.OSTree.Objects.Sysroot.sysrootLoad' must have been invoked prior to
calling this function.
-}
sysrootGetFd ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> m Int32
    {- ^ __Returns:__ A file descriptor valid for the lifetime of /@self@/ -}
sysrootGetFd self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_get_fd self'
    touchManagedPtr self
    return result

#if ENABLE_OVERLOADING
data SysrootGetFdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetFdMethodInfo a signature where
    overloadedMethod _ = sysrootGetFd

#endif

-- method Sysroot::get_merge_deployment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Operating system group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_merge_deployment" ostree_sysroot_get_merge_deployment :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CString ->                              -- osname : TBasicType TUTF8
    IO (Ptr OSTree.Deployment.Deployment)

{- |
Find the deployment to use as a configuration merge source; this is
the first one in the current deployment list which matches osname.
-}
sysrootGetMergeDeployment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (T.Text)
    {- ^ /@osname@/: Operating system group -}
    -> m OSTree.Deployment.Deployment
    {- ^ __Returns:__ Configuration merge deployment -}
sysrootGetMergeDeployment self osname = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeOsname <- case osname of
        Nothing -> return nullPtr
        Just jOsname -> do
            jOsname' <- textToCString jOsname
            return jOsname'
    result <- ostree_sysroot_get_merge_deployment self' maybeOsname
    checkUnexpectedReturnNULL "sysrootGetMergeDeployment" result
    result' <- (wrapObject OSTree.Deployment.Deployment) result
    touchManagedPtr self
    freeMem maybeOsname
    return result'

#if ENABLE_OVERLOADING
data SysrootGetMergeDeploymentMethodInfo
instance (signature ~ (Maybe (T.Text) -> m OSTree.Deployment.Deployment), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetMergeDeploymentMethodInfo a signature where
    overloadedMethod _ = sysrootGetMergeDeployment

#endif

-- method Sysroot::get_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_path" ostree_sysroot_get_path :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO (Ptr Gio.File.File)

{- |
/No description available in the introspection data./
-}
sysrootGetPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    -> m Gio.File.File
    {- ^ __Returns:__ Path to rootfs -}
sysrootGetPath self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_get_path self'
    checkUnexpectedReturnNULL "sysrootGetPath" result
    result' <- (newObject Gio.File.File) result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data SysrootGetPathMethodInfo
instance (signature ~ (m Gio.File.File), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetPathMethodInfo a signature where
    overloadedMethod _ = sysrootGetPath

#endif

-- method Sysroot::get_repo
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repository in sysroot @self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_get_repo" ostree_sysroot_get_repo :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr (Ptr OSTree.Repo.Repo) ->           -- out_repo : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Retrieve the OSTree repository in sysroot /@self@/. The repo is guaranteed to be open
(see 'GI.OSTree.Objects.Repo.repoOpen').
-}
sysrootGetRepo ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m (OSTree.Repo.Repo)
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootGetRepo self cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    outRepo <- allocMem :: IO (Ptr (Ptr OSTree.Repo.Repo))
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_get_repo self' outRepo maybeCancellable
        outRepo' <- peek outRepo
        outRepo'' <- (wrapObject OSTree.Repo.Repo) outRepo'
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        freeMem outRepo
        return outRepo''
     ) (do
        freeMem outRepo
     )

#if ENABLE_OVERLOADING
data SysrootGetRepoMethodInfo
instance (signature ~ (Maybe (b) -> m (OSTree.Repo.Repo)), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootGetRepoMethodInfo a signature where
    overloadedMethod _ = sysrootGetRepo

#endif

-- method Sysroot::get_staged_deployment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Deployment"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_staged_deployment" ostree_sysroot_get_staged_deployment :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO (Ptr OSTree.Deployment.Deployment)

{- |
/No description available in the introspection data./
-}
sysrootGetStagedDeployment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> m OSTree.Deployment.Deployment
    {- ^ __Returns:__ The currently staged deployment, or 'Nothing' if none -}
sysrootGetStagedDeployment self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_get_staged_deployment self'
    checkUnexpectedReturnNULL "sysrootGetStagedDeployment" result
    result' <- (newObject OSTree.Deployment.Deployment) result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data SysrootGetStagedDeploymentMethodInfo
instance (signature ~ (m OSTree.Deployment.Deployment), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetStagedDeploymentMethodInfo a signature where
    overloadedMethod _ = sysrootGetStagedDeployment

#endif

-- method Sysroot::get_subbootversion
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_subbootversion" ostree_sysroot_get_subbootversion :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO Int32

{- |
/No description available in the introspection data./
-}
sysrootGetSubbootversion ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    -> m Int32
sysrootGetSubbootversion self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_get_subbootversion self'
    touchManagedPtr self
    return result

#if ENABLE_OVERLOADING
data SysrootGetSubbootversionMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsSysroot a) => O.MethodInfo SysrootGetSubbootversionMethodInfo a signature where
    overloadedMethod _ = sysrootGetSubbootversion

#endif

-- method Sysroot::init_osname
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Name group of operating system checkouts", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_init_osname" ostree_sysroot_init_osname :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CString ->                              -- osname : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Initialize the directory structure for an \"osname\", which is a
group of operating system deployments, with a shared @\/var@.  One
is required for generating a deployment.
-}
sysrootInitOsname ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> T.Text
    {- ^ /@osname@/: Name group of operating system checkouts -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootInitOsname self osname cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    osname' <- textToCString osname
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_init_osname self' osname' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        freeMem osname'
        return ()
     ) (do
        freeMem osname'
     )

#if ENABLE_OVERLOADING
data SysrootInitOsnameMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootInitOsnameMethodInfo a signature where
    overloadedMethod _ = sysrootInitOsname

#endif

-- method Sysroot::load
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_load" ostree_sysroot_load :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Load deployment list, bootversion, and subbootversion from the
rootfs /@self@/.
-}
sysrootLoad ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootLoad self cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_load self' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

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

#endif

-- method Sysroot::load_if_changed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_changed", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_load_if_changed" ostree_sysroot_load_if_changed :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CInt ->                                 -- out_changed : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
/No description available in the introspection data./
-}
sysrootLoadIfChanged ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    -> Bool
    -> Maybe (b)
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootLoadIfChanged self outChanged cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let outChanged' = (fromIntegral . fromEnum) outChanged
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_load_if_changed self' outChanged' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data SysrootLoadIfChangedMethodInfo
instance (signature ~ (Bool -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootLoadIfChangedMethodInfo a signature where
    overloadedMethod _ = sysrootLoadIfChanged

#endif

-- method Sysroot::lock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_lock" ostree_sysroot_lock :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Acquire an exclusive multi-process write lock for /@self@/.  This call
blocks until the lock has been acquired.  The lock is not
reentrant.

Release the lock with 'GI.OSTree.Objects.Sysroot.sysrootUnlock'.  The lock will also
be released if /@self@/ is deallocated.
-}
sysrootLock ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Self -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootLock self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    onException (do
        _ <- propagateGError $ ostree_sysroot_lock self'
        touchManagedPtr self
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data SysrootLockMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSysroot a) => O.MethodInfo SysrootLockMethodInfo a signature where
    overloadedMethod _ = sysrootLock

#endif

-- method Sysroot::lock_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_lock_async" ostree_sysroot_lock_async :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
An asynchronous version of 'GI.OSTree.Objects.Sysroot.sysrootLock'.
-}
sysrootLockAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Self -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: Callback -}
    -> m ()
sysrootLockAsync self cancellable callback = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    ostree_sysroot_lock_async self' maybeCancellable maybeCallback userData
    touchManagedPtr self
    whenJust cancellable touchManagedPtr
    return ()

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

#endif

-- method Sysroot::lock_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_lock_finish" ostree_sysroot_lock_finish :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Call when 'GI.OSTree.Objects.Sysroot.sysrootLockAsync' is ready.
-}
sysrootLockFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@self@/: Self -}
    -> b
    {- ^ /@result@/: Result -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootLockFinish self result_ = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ ostree_sysroot_lock_finish self' result_'
        touchManagedPtr self
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

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

#endif

-- method Sysroot::origin_new_from_refspec
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refspec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A refspec", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "KeyFile"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_origin_new_from_refspec" ostree_sysroot_origin_new_from_refspec :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CString ->                              -- refspec : TBasicType TUTF8
    IO (Ptr GLib.KeyFile.KeyFile)

{- |
/No description available in the introspection data./
-}
sysrootOriginNewFromRefspec ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> T.Text
    {- ^ /@refspec@/: A refspec -}
    -> m GLib.KeyFile.KeyFile
    {- ^ __Returns:__ A new config file which sets /@refspec@/ as an origin -}
sysrootOriginNewFromRefspec self refspec = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    refspec' <- textToCString refspec
    result <- ostree_sysroot_origin_new_from_refspec self' refspec'
    checkUnexpectedReturnNULL "sysrootOriginNewFromRefspec" result
    result' <- (wrapBoxed GLib.KeyFile.KeyFile) result
    touchManagedPtr self
    freeMem refspec'
    return result'

#if ENABLE_OVERLOADING
data SysrootOriginNewFromRefspecMethodInfo
instance (signature ~ (T.Text -> m GLib.KeyFile.KeyFile), MonadIO m, IsSysroot a) => O.MethodInfo SysrootOriginNewFromRefspecMethodInfo a signature where
    overloadedMethod _ = sysrootOriginNewFromRefspec

#endif

-- method Sysroot::prepare_cleanup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_prepare_cleanup" ostree_sysroot_prepare_cleanup :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Like 'GI.OSTree.Objects.Sysroot.sysrootCleanup' in that it cleans up incomplete deployments
and old boot versions, but does NOT prune the repository.
-}
sysrootPrepareCleanup ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootPrepareCleanup self cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_prepare_cleanup self' maybeCancellable
        touchManagedPtr self
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

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

#endif

-- method Sysroot::query_deployments_for
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\"stateroot\" name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_pending", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The pending deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "out_rollback", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The rollback deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_query_deployments_for" ostree_sysroot_query_deployments_for :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CString ->                              -- osname : TBasicType TUTF8
    Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_pending : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_rollback : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    IO ()

{- |
Find the pending and rollback deployments for /@osname@/. Pass 'Nothing' for /@osname@/
to use the booted deployment\'s osname. By default, pending deployment is the
first deployment in the order that matches /@osname@/, and /@rollback@/ will be the
next one after the booted deployment, or the deployment after the pending if
we\'re not looking at the booted deployment.

/Since: 2017.7/
-}
sysrootQueryDeploymentsFor ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (T.Text)
    {- ^ /@osname@/: \"stateroot\" name -}
    -> m ((OSTree.Deployment.Deployment, OSTree.Deployment.Deployment))
sysrootQueryDeploymentsFor self osname = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeOsname <- case osname of
        Nothing -> return nullPtr
        Just jOsname -> do
            jOsname' <- textToCString jOsname
            return jOsname'
    outPending <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment))
    outRollback <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment))
    ostree_sysroot_query_deployments_for self' maybeOsname outPending outRollback
    outPending' <- peek outPending
    outPending'' <- (wrapObject OSTree.Deployment.Deployment) outPending'
    outRollback' <- peek outRollback
    outRollback'' <- (wrapObject OSTree.Deployment.Deployment) outRollback'
    touchManagedPtr self
    freeMem maybeOsname
    freeMem outPending
    freeMem outRollback
    return (outPending'', outRollback'')

#if ENABLE_OVERLOADING
data SysrootQueryDeploymentsForMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ((OSTree.Deployment.Deployment, OSTree.Deployment.Deployment))), MonadIO m, IsSysroot a) => O.MethodInfo SysrootQueryDeploymentsForMethodInfo a signature where
    overloadedMethod _ = sysrootQueryDeploymentsFor

#endif

-- method Sysroot::repo
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "Repo"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_repo" ostree_sysroot_repo :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO (Ptr OSTree.Repo.Repo)

{- |
This function is a variant of 'GI.OSTree.Objects.Sysroot.sysrootGetRepo' that cannot fail, and
returns a cached repository. Can only be called after 'GI.OSTree.Objects.Sysroot.sysrootLoad'
has been invoked successfully.
-}
sysrootRepo ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> m OSTree.Repo.Repo
    {- ^ __Returns:__ The OSTree repository in sysroot /@self@/. -}
sysrootRepo self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- ostree_sysroot_repo self'
    checkUnexpectedReturnNULL "sysrootRepo" result
    result' <- (newObject OSTree.Repo.Repo) result
    touchManagedPtr self
    return result'

#if ENABLE_OVERLOADING
data SysrootRepoMethodInfo
instance (signature ~ (m OSTree.Repo.Repo), MonadIO m, IsSysroot a) => O.MethodInfo SysrootRepoMethodInfo a signature where
    overloadedMethod _ = sysrootRepo

#endif

-- method Sysroot::simple_write_deployment
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "OS name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Prepend this deployment to the list", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use this deployment for configuration merge", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "OSTree", name = "SysrootSimpleWriteDeploymentFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags controlling behavior", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_simple_write_deployment" ostree_sysroot_simple_write_deployment :: 
    Ptr Sysroot ->                          -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CString ->                              -- osname : TBasicType TUTF8
    Ptr OSTree.Deployment.Deployment ->     -- new_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr OSTree.Deployment.Deployment ->     -- merge_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "SysrootSimpleWriteDeploymentFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Prepend /@newDeployment@/ to the list of deployments, commit, and
cleanup.  By default, all other deployments for the given /@osname@/
except the merge deployment and the booted deployment will be
garbage collected.

If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsRetain' is
specified, then all current deployments will be kept.

If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsRetainPending' is
specified, then pending deployments will be kept.

If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsRetainRollback' is
specified, then rollback deployments will be kept.

If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsNotDefault' is
specified, then instead of prepending, the new deployment will be
added right after the booted or merge deployment, instead of first.

If 'GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlagsNoClean' is
specified, then no cleanup will be performed after adding the
deployment. Make sure to call 'GI.OSTree.Objects.Sysroot.sysrootCleanup' sometime
later, instead.
-}
sysrootSimpleWriteDeployment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, OSTree.Deployment.IsDeployment c, Gio.Cancellable.IsCancellable d) =>
    a
    {- ^ /@sysroot@/: Sysroot -}
    -> Maybe (T.Text)
    {- ^ /@osname@/: OS name -}
    -> b
    {- ^ /@newDeployment@/: Prepend this deployment to the list -}
    -> Maybe (c)
    {- ^ /@mergeDeployment@/: Use this deployment for configuration merge -}
    -> [OSTree.Flags.SysrootSimpleWriteDeploymentFlags]
    {- ^ /@flags@/: Flags controlling behavior -}
    -> Maybe (d)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootSimpleWriteDeployment sysroot osname newDeployment mergeDeployment flags cancellable = liftIO $ do
    sysroot' <- unsafeManagedPtrCastPtr sysroot
    maybeOsname <- case osname of
        Nothing -> return nullPtr
        Just jOsname -> do
            jOsname' <- textToCString jOsname
            return jOsname'
    newDeployment' <- unsafeManagedPtrCastPtr newDeployment
    maybeMergeDeployment <- case mergeDeployment of
        Nothing -> return nullPtr
        Just jMergeDeployment -> do
            jMergeDeployment' <- unsafeManagedPtrCastPtr jMergeDeployment
            return jMergeDeployment'
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_simple_write_deployment sysroot' maybeOsname newDeployment' maybeMergeDeployment flags' maybeCancellable
        touchManagedPtr sysroot
        touchManagedPtr newDeployment
        whenJust mergeDeployment touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem maybeOsname
        return ()
     ) (do
        freeMem maybeOsname
     )

#if ENABLE_OVERLOADING
data SysrootSimpleWriteDeploymentMethodInfo
instance (signature ~ (Maybe (T.Text) -> b -> Maybe (c) -> [OSTree.Flags.SysrootSimpleWriteDeploymentFlags] -> Maybe (d) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, OSTree.Deployment.IsDeployment c, Gio.Cancellable.IsCancellable d) => O.MethodInfo SysrootSimpleWriteDeploymentMethodInfo a signature where
    overloadedMethod _ = sysrootSimpleWriteDeployment

#endif

-- method Sysroot::stage_tree
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "osname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "osname to use for merge deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "revision", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Checksum to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Origin to use for upgrades", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "merge_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use this deployment for merge path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "override_kernel_argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Use these as kernel arguments; if %NULL, inherit options from provided_merge_deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_new_deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new deployment path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_stage_tree" ostree_sysroot_stage_tree :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    CString ->                              -- osname : TBasicType TUTF8
    CString ->                              -- revision : TBasicType TUTF8
    Ptr GLib.KeyFile.KeyFile ->             -- origin : TInterface (Name {namespace = "GLib", name = "KeyFile"})
    Ptr OSTree.Deployment.Deployment ->     -- merge_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr CString ->                          -- override_kernel_argv : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr (Ptr OSTree.Deployment.Deployment) -> -- out_new_deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Like 'GI.OSTree.Objects.Sysroot.sysrootDeployTree', but \"finalization\" only occurs at OS
shutdown time.
-}
sysrootStageTree ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> Maybe (T.Text)
    {- ^ /@osname@/: osname to use for merge deployment -}
    -> T.Text
    {- ^ /@revision@/: Checksum to add -}
    -> Maybe (GLib.KeyFile.KeyFile)
    {- ^ /@origin@/: Origin to use for upgrades -}
    -> Maybe (b)
    {- ^ /@mergeDeployment@/: Use this deployment for merge path -}
    -> Maybe ([T.Text])
    {- ^ /@overrideKernelArgv@/: Use these as kernel arguments; if 'Nothing', inherit options from provided_merge_deployment -}
    -> Maybe (c)
    {- ^ /@cancellable@/: Cancellable -}
    -> m (OSTree.Deployment.Deployment)
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootStageTree self osname revision origin mergeDeployment overrideKernelArgv cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    maybeOsname <- case osname of
        Nothing -> return nullPtr
        Just jOsname -> do
            jOsname' <- textToCString jOsname
            return jOsname'
    revision' <- textToCString revision
    maybeOrigin <- case origin of
        Nothing -> return nullPtr
        Just jOrigin -> do
            jOrigin' <- unsafeManagedPtrGetPtr jOrigin
            return jOrigin'
    maybeMergeDeployment <- case mergeDeployment of
        Nothing -> return nullPtr
        Just jMergeDeployment -> do
            jMergeDeployment' <- unsafeManagedPtrCastPtr jMergeDeployment
            return jMergeDeployment'
    maybeOverrideKernelArgv <- case overrideKernelArgv of
        Nothing -> return nullPtr
        Just jOverrideKernelArgv -> do
            jOverrideKernelArgv' <- packZeroTerminatedUTF8CArray jOverrideKernelArgv
            return jOverrideKernelArgv'
    outNewDeployment <- allocMem :: IO (Ptr (Ptr OSTree.Deployment.Deployment))
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_stage_tree self' maybeOsname revision' maybeOrigin maybeMergeDeployment maybeOverrideKernelArgv outNewDeployment maybeCancellable
        outNewDeployment' <- peek outNewDeployment
        outNewDeployment'' <- (wrapObject OSTree.Deployment.Deployment) outNewDeployment'
        touchManagedPtr self
        whenJust origin touchManagedPtr
        whenJust mergeDeployment touchManagedPtr
        whenJust cancellable touchManagedPtr
        freeMem maybeOsname
        freeMem revision'
        mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv
        freeMem maybeOverrideKernelArgv
        freeMem outNewDeployment
        return outNewDeployment''
     ) (do
        freeMem maybeOsname
        freeMem revision'
        mapZeroTerminatedCArray freeMem maybeOverrideKernelArgv
        freeMem maybeOverrideKernelArgv
        freeMem outNewDeployment
     )

#if ENABLE_OVERLOADING
data SysrootStageTreeMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (GLib.KeyFile.KeyFile) -> Maybe (b) -> Maybe ([T.Text]) -> Maybe (c) -> m (OSTree.Deployment.Deployment)), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootStageTreeMethodInfo a signature where
    overloadedMethod _ = sysrootStageTree

#endif

-- method Sysroot::try_lock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_acquired", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether or not the lock has been acquired", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_try_lock" ostree_sysroot_try_lock :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr CInt ->                             -- out_acquired : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Try to acquire an exclusive multi-process write lock for /@self@/.  If
another process holds the lock, this function will return
immediately, setting /@outAcquired@/ to 'False', and returning 'True'
(and no error).

Release the lock with 'GI.OSTree.Objects.Sysroot.sysrootUnlock'.  The lock will also
be released if /@self@/ is deallocated.
-}
sysrootTryLock ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Self -}
    -> m (Bool)
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootTryLock self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    outAcquired <- allocMem :: IO (Ptr CInt)
    onException (do
        _ <- propagateGError $ ostree_sysroot_try_lock self' outAcquired
        outAcquired' <- peek outAcquired
        let outAcquired'' = (/= 0) outAcquired'
        touchManagedPtr self
        freeMem outAcquired
        return outAcquired''
     ) (do
        freeMem outAcquired
     )

#if ENABLE_OVERLOADING
data SysrootTryLockMethodInfo
instance (signature ~ (m (Bool)), MonadIO m, IsSysroot a) => O.MethodInfo SysrootTryLockMethodInfo a signature where
    overloadedMethod _ = sysrootTryLock

#endif

-- method Sysroot::unload
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_unload" ostree_sysroot_unload :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO ()

{- |
Release any resources such as file descriptors referring to the
root directory of this sysroot.  Normally, those resources are
cleared by finalization, but in garbage collected languages that
may not be predictable.

This undoes the effect of @ostree_sysroot_load()@.
-}
sysrootUnload ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> m ()
sysrootUnload self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    ostree_sysroot_unload self'
    touchManagedPtr self
    return ()

#if ENABLE_OVERLOADING
data SysrootUnloadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSysroot a) => O.MethodInfo SysrootUnloadMethodInfo a signature where
    overloadedMethod _ = sysrootUnload

#endif

-- method Sysroot::unlock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_unlock" ostree_sysroot_unlock :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    IO ()

{- |
Clear the lock previously acquired with 'GI.OSTree.Objects.Sysroot.sysrootLock'.  It
is safe to call this function if the lock has not been previously
acquired.
-}
sysrootUnlock ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a) =>
    a
    {- ^ /@self@/: Self -}
    -> m ()
sysrootUnlock self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    ostree_sysroot_unlock self'
    touchManagedPtr self
    return ()

#if ENABLE_OVERLOADING
data SysrootUnlockMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSysroot a) => O.MethodInfo SysrootUnlockMethodInfo a signature where
    overloadedMethod _ = sysrootUnlock

#endif

-- method Sysroot::write_deployments
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_deployments", argType = TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "List of new deployments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_write_deployments" ostree_sysroot_write_deployments :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr (GPtrArray (Ptr OSTree.Deployment.Deployment)) -> -- new_deployments : TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"}))
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Older version of 'GI.OSTree.Objects.Sysroot.sysrootWriteDeploymentsWithOptions'. This
version will perform post-deployment cleanup by default.
-}
sysrootWriteDeployments ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> [OSTree.Deployment.Deployment]
    {- ^ /@newDeployments@/: List of new deployments -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootWriteDeployments self newDeployments cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    newDeployments' <- mapM unsafeManagedPtrCastPtr newDeployments
    newDeployments'' <- packGPtrArray newDeployments'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_write_deployments self' newDeployments'' maybeCancellable
        touchManagedPtr self
        mapM_ touchManagedPtr newDeployments
        whenJust cancellable touchManagedPtr
        unrefPtrArray newDeployments''
        return ()
     ) (do
        unrefPtrArray newDeployments''
     )

#if ENABLE_OVERLOADING
data SysrootWriteDeploymentsMethodInfo
instance (signature ~ ([OSTree.Deployment.Deployment] -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootWriteDeploymentsMethodInfo a signature where
    overloadedMethod _ = sysrootWriteDeployments

#endif

-- method Sysroot::write_deployments_with_options
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Sysroot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_deployments", argType = TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "List of new deployments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "opts", argType = TInterface (Name {namespace = "OSTree", name = "SysrootWriteDeploymentsOpts"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_write_deployments_with_options" ostree_sysroot_write_deployments_with_options :: 
    Ptr Sysroot ->                          -- self : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr (GPtrArray (Ptr OSTree.Deployment.Deployment)) -> -- new_deployments : TPtrArray (TInterface (Name {namespace = "OSTree", name = "Deployment"}))
    Ptr OSTree.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts -> -- opts : TInterface (Name {namespace = "OSTree", name = "SysrootWriteDeploymentsOpts"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Assuming /@newDeployments@/ have already been deployed in place on disk via
'GI.OSTree.Objects.Sysroot.sysrootDeployTree', atomically update bootloader configuration. By
default, no post-transaction cleanup will be performed. You should invoke
'GI.OSTree.Objects.Sysroot.sysrootCleanup' at some point after the transaction, or specify
@do_postclean@ in /@opts@/.  Skipping the post-transaction cleanup is useful
if for example you want to control pruning of the repository.
-}
sysrootWriteDeploymentsWithOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@self@/: Sysroot -}
    -> [OSTree.Deployment.Deployment]
    {- ^ /@newDeployments@/: List of new deployments -}
    -> OSTree.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts
    {- ^ /@opts@/: Options -}
    -> Maybe (b)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootWriteDeploymentsWithOptions self newDeployments opts cancellable = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    newDeployments' <- mapM unsafeManagedPtrCastPtr newDeployments
    newDeployments'' <- packGPtrArray newDeployments'
    opts' <- unsafeManagedPtrGetPtr opts
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_write_deployments_with_options self' newDeployments'' opts' maybeCancellable
        touchManagedPtr self
        mapM_ touchManagedPtr newDeployments
        touchManagedPtr opts
        whenJust cancellable touchManagedPtr
        unrefPtrArray newDeployments''
        return ()
     ) (do
        unrefPtrArray newDeployments''
     )

#if ENABLE_OVERLOADING
data SysrootWriteDeploymentsWithOptionsMethodInfo
instance (signature ~ ([OSTree.Deployment.Deployment] -> OSTree.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts -> Maybe (b) -> m ()), MonadIO m, IsSysroot a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SysrootWriteDeploymentsWithOptionsMethodInfo a signature where
    overloadedMethod _ = sysrootWriteDeploymentsWithOptions

#endif

-- method Sysroot::write_origin_file
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sysroot", argType = TInterface (Name {namespace = "OSTree", name = "Sysroot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "System root", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "deployment", argType = TInterface (Name {namespace = "OSTree", name = "Deployment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Deployment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_origin", argType = TInterface (Name {namespace = "GLib", name = "KeyFile"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Origin content", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_sysroot_write_origin_file" ostree_sysroot_write_origin_file :: 
    Ptr Sysroot ->                          -- sysroot : TInterface (Name {namespace = "OSTree", name = "Sysroot"})
    Ptr OSTree.Deployment.Deployment ->     -- deployment : TInterface (Name {namespace = "OSTree", name = "Deployment"})
    Ptr GLib.KeyFile.KeyFile ->             -- new_origin : TInterface (Name {namespace = "GLib", name = "KeyFile"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Immediately replace the origin file of the referenced /@deployment@/
with the contents of /@newOrigin@/.  If /@newOrigin@/ is 'Nothing',
this function will write the current origin of /@deployment@/.
-}
sysrootWriteOriginFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@sysroot@/: System root -}
    -> b
    {- ^ /@deployment@/: Deployment -}
    -> Maybe (GLib.KeyFile.KeyFile)
    {- ^ /@newOrigin@/: Origin content -}
    -> Maybe (c)
    {- ^ /@cancellable@/: Cancellable -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
sysrootWriteOriginFile sysroot deployment newOrigin cancellable = liftIO $ do
    sysroot' <- unsafeManagedPtrCastPtr sysroot
    deployment' <- unsafeManagedPtrCastPtr deployment
    maybeNewOrigin <- case newOrigin of
        Nothing -> return nullPtr
        Just jNewOrigin -> do
            jNewOrigin' <- unsafeManagedPtrGetPtr jNewOrigin
            return jNewOrigin'
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ ostree_sysroot_write_origin_file sysroot' deployment' maybeNewOrigin maybeCancellable
        touchManagedPtr sysroot
        touchManagedPtr deployment
        whenJust newOrigin touchManagedPtr
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

#if ENABLE_OVERLOADING
data SysrootWriteOriginFileMethodInfo
instance (signature ~ (b -> Maybe (GLib.KeyFile.KeyFile) -> Maybe (c) -> m ()), MonadIO m, IsSysroot a, OSTree.Deployment.IsDeployment b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SysrootWriteOriginFileMethodInfo a signature where
    overloadedMethod _ = sysrootWriteOriginFile

#endif

-- method Sysroot::get_deployment_origin_path
-- method type : MemberFunction
-- Args : [Arg {argCName = "deployment_path", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A deployment path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"}))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_sysroot_get_deployment_origin_path" ostree_sysroot_get_deployment_origin_path :: 
    Ptr Gio.File.File ->                    -- deployment_path : TInterface (Name {namespace = "Gio", name = "File"})
    IO (Ptr Gio.File.File)

{- |
/No description available in the introspection data./
-}
sysrootGetDeploymentOriginPath ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
    a
    {- ^ /@deploymentPath@/: A deployment path -}
    -> m Gio.File.File
    {- ^ __Returns:__ Path to deployment origin file -}
sysrootGetDeploymentOriginPath deploymentPath = liftIO $ do
    deploymentPath' <- unsafeManagedPtrCastPtr deploymentPath
    result <- ostree_sysroot_get_deployment_origin_path deploymentPath'
    checkUnexpectedReturnNULL "sysrootGetDeploymentOriginPath" result
    result' <- (wrapObject Gio.File.File) result
    touchManagedPtr deploymentPath
    return result'

#if ENABLE_OVERLOADING
#endif