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

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

module GI.OSTree.Callbacks
    (

 -- * Signals
-- ** BootloaderInterfaceGetNameFieldCallback #signal:BootloaderInterfaceGetNameFieldCallback#

    BootloaderInterfaceGetNameFieldCallback ,
    C_BootloaderInterfaceGetNameFieldCallback,
    dynamic_BootloaderInterfaceGetNameFieldCallback,
    genClosure_BootloaderInterfaceGetNameFieldCallback,
    mk_BootloaderInterfaceGetNameFieldCallback,
    noBootloaderInterfaceGetNameFieldCallback,
    wrap_BootloaderInterfaceGetNameFieldCallback,


-- ** BootloaderInterfaceIsAtomicFieldCallback #signal:BootloaderInterfaceIsAtomicFieldCallback#

    BootloaderInterfaceIsAtomicFieldCallback,
    C_BootloaderInterfaceIsAtomicFieldCallback,
    dynamic_BootloaderInterfaceIsAtomicFieldCallback,
    genClosure_BootloaderInterfaceIsAtomicFieldCallback,
    mk_BootloaderInterfaceIsAtomicFieldCallback,
    noBootloaderInterfaceIsAtomicFieldCallback,
    wrap_BootloaderInterfaceIsAtomicFieldCallback,


-- ** BootloaderInterfaceQueryFieldCallback #signal:BootloaderInterfaceQueryFieldCallback#

    BootloaderInterfaceQueryFieldCallback   ,
    C_BootloaderInterfaceQueryFieldCallback ,
    dynamic_BootloaderInterfaceQueryFieldCallback,
    mk_BootloaderInterfaceQueryFieldCallback,
    noBootloaderInterfaceQueryFieldCallback ,


-- ** CmdPrivateVTableOstreeFinalizeStagedFieldCallback #signal:CmdPrivateVTableOstreeFinalizeStagedFieldCallback#

    C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback,
    CmdPrivateVTableOstreeFinalizeStagedFieldCallback,
    dynamic_CmdPrivateVTableOstreeFinalizeStagedFieldCallback,
    mk_CmdPrivateVTableOstreeFinalizeStagedFieldCallback,
    noCmdPrivateVTableOstreeFinalizeStagedFieldCallback,


-- ** CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback #signal:CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback#

    C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback,
    CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback,
    dynamic_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback,
    mk_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback,
    noCmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback,


-- ** CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback #signal:CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback#

    C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback,
    CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback,
    dynamic_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback,
    mk_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback,
    noCmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback,


-- ** CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback #signal:CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback#

    C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback,
    CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback,
    dynamic_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback,
    mk_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback,
    noCmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback,


-- ** CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback #signal:CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback#

    C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback,
    CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback,
    dynamic_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback,
    mk_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback,
    noCmdPrivateVTableOstreeStaticDeltaDumpFieldCallback,


-- ** CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback #signal:CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback#

    C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback,
    CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback,
    dynamic_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback,
    mk_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback,
    noCmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback,


-- ** CmdPrivateVTableOstreeSystemGeneratorFieldCallback #signal:CmdPrivateVTableOstreeSystemGeneratorFieldCallback#

    C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback,
    CmdPrivateVTableOstreeSystemGeneratorFieldCallback,
    dynamic_CmdPrivateVTableOstreeSystemGeneratorFieldCallback,
    mk_CmdPrivateVTableOstreeSystemGeneratorFieldCallback,
    noCmdPrivateVTableOstreeSystemGeneratorFieldCallback,


-- ** RepoCheckoutFilter #signal:RepoCheckoutFilter#

    C_RepoCheckoutFilter                    ,
    RepoCheckoutFilter                      ,
    RepoCheckoutFilter_WithClosures         ,
    drop_closures_RepoCheckoutFilter        ,
    dynamic_RepoCheckoutFilter              ,
    genClosure_RepoCheckoutFilter           ,
    mk_RepoCheckoutFilter                   ,
    noRepoCheckoutFilter                    ,
    noRepoCheckoutFilter_WithClosures       ,
    wrap_RepoCheckoutFilter                 ,


-- ** RepoCommitFilter #signal:RepoCommitFilter#

    C_RepoCommitFilter                      ,
    RepoCommitFilter                        ,
    RepoCommitFilter_WithClosures           ,
    drop_closures_RepoCommitFilter          ,
    dynamic_RepoCommitFilter                ,
    genClosure_RepoCommitFilter             ,
    mk_RepoCommitFilter                     ,
    noRepoCommitFilter                      ,
    noRepoCommitFilter_WithClosures         ,
    wrap_RepoCommitFilter                   ,


-- ** RepoCommitModifierXattrCallback #signal:RepoCommitModifierXattrCallback#

    C_RepoCommitModifierXattrCallback       ,
    RepoCommitModifierXattrCallback         ,
    RepoCommitModifierXattrCallback_WithClosures,
    drop_closures_RepoCommitModifierXattrCallback,
    dynamic_RepoCommitModifierXattrCallback ,
    genClosure_RepoCommitModifierXattrCallback,
    mk_RepoCommitModifierXattrCallback      ,
    noRepoCommitModifierXattrCallback       ,
    noRepoCommitModifierXattrCallback_WithClosures,
    wrap_RepoCommitModifierXattrCallback    ,


-- ** RepoImportArchiveTranslatePathname #signal:RepoImportArchiveTranslatePathname#

    C_RepoImportArchiveTranslatePathname    ,
    RepoImportArchiveTranslatePathname      ,
    RepoImportArchiveTranslatePathname_WithClosures,
    drop_closures_RepoImportArchiveTranslatePathname,
    dynamic_RepoImportArchiveTranslatePathname,
    genClosure_RepoImportArchiveTranslatePathname,
    mk_RepoImportArchiveTranslatePathname   ,
    noRepoImportArchiveTranslatePathname    ,
    noRepoImportArchiveTranslatePathname_WithClosures,
    wrap_RepoImportArchiveTranslatePathname ,




    ) 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.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Objects.Repo as OSTree.Repo
import {-# SOURCE #-} qualified GI.OSTree.Objects.Sysroot as OSTree.Sysroot
import {-# SOURCE #-} qualified GI.OSTree.Structs.Bootloader as OSTree.Bootloader

-- callback RepoImportArchiveTranslatePathname
--          -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Stat buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path in the archive", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Possibly change a pathname while importing an archive. If %NULL is returned,\nthen @src_path will be used unchanged.  Otherwise, return a new pathname which\nwill be freed via `g_free()`.\n\nThis pathname translation will be performed *before* any processing from an\nactive `OstreeRepoCommitModifier`. Will be invoked for all directory and file\ntypes, first with outer directories, then their sub-files and directories.\n\nNote that enabling pathname translation will always override the setting for\n`use_ostree_convention`.", sinceVersion = Just "2017.11"}}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoImportArchiveTranslatePathname =
    Ptr OSTree.Repo.Repo ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO CString

-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Stat buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path in the archive", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoImportArchiveTranslatePathname :: FunPtr C_RepoImportArchiveTranslatePathname -> C_RepoImportArchiveTranslatePathname

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoImportArchiveTranslatePathname ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    FunPtr C_RepoImportArchiveTranslatePathname
    -> a
    {- ^ /@repo@/: Repo -}
    -> Ptr ()
    {- ^ /@stbuf@/: Stat buffer -}
    -> T.Text
    {- ^ /@srcPath@/: Path in the archive -}
    -> Ptr ()
    {- ^ /@userData@/: User data -}
    -> m T.Text
dynamic_RepoImportArchiveTranslatePathname __funPtr repo stbuf srcPath userData = liftIO $ do
    repo' <- unsafeManagedPtrCastPtr repo
    srcPath' <- textToCString srcPath
    result <- (__dynamic_C_RepoImportArchiveTranslatePathname __funPtr) repo' stbuf srcPath' userData
    checkUnexpectedReturnNULL "repoImportArchiveTranslatePathname" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr repo
    freeMem srcPath'
    return result'

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

{- |
Possibly change a pathname while importing an archive. If 'Nothing' is returned,
then /@srcPath@/ will be used unchanged.  Otherwise, return a new pathname which
will be freed via @g_free()@.

This pathname translation will be performed *before* any processing from an
active @OstreeRepoCommitModifier@. Will be invoked for all directory and file
types, first with outer directories, then their sub-files and directories.

Note that enabling pathname translation will always override the setting for
@use_ostree_convention@.

/Since: 2017.11/
-}
type RepoImportArchiveTranslatePathname =
    OSTree.Repo.Repo
    {- ^ /@repo@/: Repo -}
    -> Ptr ()
    {- ^ /@stbuf@/: Stat buffer -}
    -> T.Text
    {- ^ /@srcPath@/: Path in the archive -}
    -> IO T.Text

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoImportArchiveTranslatePathname`@.
noRepoImportArchiveTranslatePathname :: Maybe RepoImportArchiveTranslatePathname
noRepoImportArchiveTranslatePathname = Nothing

{- |
Possibly change a pathname while importing an archive. If 'Nothing' is returned,
then /@srcPath@/ will be used unchanged.  Otherwise, return a new pathname which
will be freed via @g_free()@.

This pathname translation will be performed *before* any processing from an
active @OstreeRepoCommitModifier@. Will be invoked for all directory and file
types, first with outer directories, then their sub-files and directories.

Note that enabling pathname translation will always override the setting for
@use_ostree_convention@.

/Since: 2017.11/
-}
type RepoImportArchiveTranslatePathname_WithClosures =
    OSTree.Repo.Repo
    {- ^ /@repo@/: Repo -}
    -> Ptr ()
    {- ^ /@stbuf@/: Stat buffer -}
    -> T.Text
    {- ^ /@srcPath@/: Path in the archive -}
    -> Ptr ()
    {- ^ /@userData@/: User data -}
    -> IO T.Text

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoImportArchiveTranslatePathname_WithClosures`@.
noRepoImportArchiveTranslatePathname_WithClosures :: Maybe RepoImportArchiveTranslatePathname_WithClosures
noRepoImportArchiveTranslatePathname_WithClosures = Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoImportArchiveTranslatePathname :: RepoImportArchiveTranslatePathname -> RepoImportArchiveTranslatePathname_WithClosures
drop_closures_RepoImportArchiveTranslatePathname _f repo stbuf srcPath _ = _f repo stbuf srcPath

-- | Wrap the callback into a `GClosure`.
genClosure_RepoImportArchiveTranslatePathname :: MonadIO m => RepoImportArchiveTranslatePathname -> m (GClosure C_RepoImportArchiveTranslatePathname)
genClosure_RepoImportArchiveTranslatePathname cb = liftIO $ do
    let cb' = drop_closures_RepoImportArchiveTranslatePathname cb
    let cb'' = wrap_RepoImportArchiveTranslatePathname Nothing cb'
    mk_RepoImportArchiveTranslatePathname cb'' >>= B.GClosure.newGClosure


-- | Wrap a `RepoImportArchiveTranslatePathname` into a `C_RepoImportArchiveTranslatePathname`.
wrap_RepoImportArchiveTranslatePathname ::
    Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname)) ->
    RepoImportArchiveTranslatePathname_WithClosures ->
    C_RepoImportArchiveTranslatePathname
wrap_RepoImportArchiveTranslatePathname funptrptr _cb repo stbuf srcPath userData = do
    repo' <- (newObject OSTree.Repo.Repo) repo
    srcPath' <- cstringToText srcPath
    result <- _cb  repo' stbuf srcPath' userData
    maybeReleaseFunPtr funptrptr
    result' <- textToCString result
    return result'


-- callback RepoCommitModifierXattrCallback
--          -> Callable {returnType = Just TVariant, returnMayBeNull = False, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoCommitModifierXattrCallback =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr Gio.FileInfo.FileInfo ->
    Ptr () ->
    IO (Ptr GVariant)

-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoCommitModifierXattrCallback :: FunPtr C_RepoCommitModifierXattrCallback -> C_RepoCommitModifierXattrCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoCommitModifierXattrCallback ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) =>
    FunPtr C_RepoCommitModifierXattrCallback
    -> a
    -> T.Text
    -> b
    -> Ptr ()
    -> m GVariant
dynamic_RepoCommitModifierXattrCallback __funPtr repo path fileInfo userData = liftIO $ do
    repo' <- unsafeManagedPtrCastPtr repo
    path' <- textToCString path
    fileInfo' <- unsafeManagedPtrCastPtr fileInfo
    result <- (__dynamic_C_RepoCommitModifierXattrCallback __funPtr) repo' path' fileInfo' userData
    checkUnexpectedReturnNULL "repoCommitModifierXattrCallback" result
    result' <- B.GVariant.wrapGVariantPtr result
    touchManagedPtr repo
    touchManagedPtr fileInfo
    freeMem path'
    return result'

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

{- |
/No description available in the introspection data./
-}
type RepoCommitModifierXattrCallback =
    OSTree.Repo.Repo
    -> T.Text
    -> Gio.FileInfo.FileInfo
    -> IO GVariant

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitModifierXattrCallback`@.
noRepoCommitModifierXattrCallback :: Maybe RepoCommitModifierXattrCallback
noRepoCommitModifierXattrCallback = Nothing

{- |
/No description available in the introspection data./
-}
type RepoCommitModifierXattrCallback_WithClosures =
    OSTree.Repo.Repo
    -> T.Text
    -> Gio.FileInfo.FileInfo
    -> Ptr ()
    -> IO GVariant

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitModifierXattrCallback_WithClosures`@.
noRepoCommitModifierXattrCallback_WithClosures :: Maybe RepoCommitModifierXattrCallback_WithClosures
noRepoCommitModifierXattrCallback_WithClosures = Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCommitModifierXattrCallback :: RepoCommitModifierXattrCallback -> RepoCommitModifierXattrCallback_WithClosures
drop_closures_RepoCommitModifierXattrCallback _f repo path fileInfo _ = _f repo path fileInfo

-- | Wrap the callback into a `GClosure`.
genClosure_RepoCommitModifierXattrCallback :: MonadIO m => RepoCommitModifierXattrCallback -> m (GClosure C_RepoCommitModifierXattrCallback)
genClosure_RepoCommitModifierXattrCallback cb = liftIO $ do
    let cb' = drop_closures_RepoCommitModifierXattrCallback cb
    let cb'' = wrap_RepoCommitModifierXattrCallback Nothing cb'
    mk_RepoCommitModifierXattrCallback cb'' >>= B.GClosure.newGClosure


-- | Wrap a `RepoCommitModifierXattrCallback` into a `C_RepoCommitModifierXattrCallback`.
wrap_RepoCommitModifierXattrCallback ::
    Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback)) ->
    RepoCommitModifierXattrCallback_WithClosures ->
    C_RepoCommitModifierXattrCallback
wrap_RepoCommitModifierXattrCallback funptrptr _cb repo path fileInfo userData = do
    repo' <- (newObject OSTree.Repo.Repo) repo
    path' <- cstringToText path
    fileInfo' <- (newObject Gio.FileInfo.FileInfo) fileInfo
    result <- _cb  repo' path' fileInfo' userData
    maybeReleaseFunPtr funptrptr
    result' <- B.GVariant.disownGVariant result
    return result'


-- callback RepoCommitFilter
--          -> Callable {returnType = Just (TInterface (Name {namespace = "OSTree", name = "RepoCommitFilterResult"})), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "#OstreeRepoCommitFilterResult saying whether or not to commit this file", sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoCommitFilter =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr Gio.FileInfo.FileInfo ->
    Ptr () ->
    IO CUInt

-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_info", argType = TInterface (Name {namespace = "Gio", name = "FileInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoCommitFilterResult"}))
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoCommitFilter :: FunPtr C_RepoCommitFilter -> C_RepoCommitFilter

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoCommitFilter ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.FileInfo.IsFileInfo b) =>
    FunPtr C_RepoCommitFilter
    -> a
    {- ^ /@repo@/: Repo -}
    -> T.Text
    {- ^ /@path@/: Path to file -}
    -> b
    {- ^ /@fileInfo@/: File information -}
    -> Ptr ()
    {- ^ /@userData@/: User data -}
    -> m OSTree.Enums.RepoCommitFilterResult
    {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file -}
dynamic_RepoCommitFilter __funPtr repo path fileInfo userData = liftIO $ do
    repo' <- unsafeManagedPtrCastPtr repo
    path' <- textToCString path
    fileInfo' <- unsafeManagedPtrCastPtr fileInfo
    result <- (__dynamic_C_RepoCommitFilter __funPtr) repo' path' fileInfo' userData
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr repo
    touchManagedPtr fileInfo
    freeMem path'
    return result'

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

{- |
/No description available in the introspection data./
-}
type RepoCommitFilter =
    OSTree.Repo.Repo
    {- ^ /@repo@/: Repo -}
    -> T.Text
    {- ^ /@path@/: Path to file -}
    -> Gio.FileInfo.FileInfo
    {- ^ /@fileInfo@/: File information -}
    -> IO OSTree.Enums.RepoCommitFilterResult
    {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitFilter`@.
noRepoCommitFilter :: Maybe RepoCommitFilter
noRepoCommitFilter = Nothing

{- |
/No description available in the introspection data./
-}
type RepoCommitFilter_WithClosures =
    OSTree.Repo.Repo
    {- ^ /@repo@/: Repo -}
    -> T.Text
    {- ^ /@path@/: Path to file -}
    -> Gio.FileInfo.FileInfo
    {- ^ /@fileInfo@/: File information -}
    -> Ptr ()
    {- ^ /@userData@/: User data -}
    -> IO OSTree.Enums.RepoCommitFilterResult
    {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCommitFilter_WithClosures`@.
noRepoCommitFilter_WithClosures :: Maybe RepoCommitFilter_WithClosures
noRepoCommitFilter_WithClosures = Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCommitFilter :: RepoCommitFilter -> RepoCommitFilter_WithClosures
drop_closures_RepoCommitFilter _f repo path fileInfo _ = _f repo path fileInfo

-- | Wrap the callback into a `GClosure`.
genClosure_RepoCommitFilter :: MonadIO m => RepoCommitFilter -> m (GClosure C_RepoCommitFilter)
genClosure_RepoCommitFilter cb = liftIO $ do
    let cb' = drop_closures_RepoCommitFilter cb
    let cb'' = wrap_RepoCommitFilter Nothing cb'
    mk_RepoCommitFilter cb'' >>= B.GClosure.newGClosure


-- | Wrap a `RepoCommitFilter` into a `C_RepoCommitFilter`.
wrap_RepoCommitFilter ::
    Maybe (Ptr (FunPtr C_RepoCommitFilter)) ->
    RepoCommitFilter_WithClosures ->
    C_RepoCommitFilter
wrap_RepoCommitFilter funptrptr _cb repo path fileInfo userData = do
    repo' <- (newObject OSTree.Repo.Repo) repo
    path' <- cstringToText path
    fileInfo' <- (newObject Gio.FileInfo.FileInfo) fileInfo
    result <- _cb  repo' path' fileInfo' userData
    maybeReleaseFunPtr funptrptr
    let result' = (fromIntegral . fromEnum) result
    return result'


-- callback RepoCheckoutFilter
--          -> Callable {returnType = Just (TInterface (Name {namespace = "OSTree", name = "RepoCheckoutFilterResult"})), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "#OstreeRepoCheckoutFilterResult saying whether or not to checkout this file", sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Just "2018.2"}}
-- | Type for the callback on the (unwrapped) C side.
type C_RepoCheckoutFilter =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr () ->
    Ptr () ->
    IO CUInt

-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Repo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Path to file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stbuf", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "File information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "OSTree", name = "RepoCheckoutFilterResult"}))
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_RepoCheckoutFilter :: FunPtr C_RepoCheckoutFilter -> C_RepoCheckoutFilter

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_RepoCheckoutFilter ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a) =>
    FunPtr C_RepoCheckoutFilter
    -> a
    {- ^ /@repo@/: Repo -}
    -> T.Text
    {- ^ /@path@/: Path to file -}
    -> Ptr ()
    {- ^ /@stbuf@/: File information -}
    -> Ptr ()
    {- ^ /@userData@/: User data -}
    -> m OSTree.Enums.RepoCheckoutFilterResult
    {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file -}
dynamic_RepoCheckoutFilter __funPtr repo path stbuf userData = liftIO $ do
    repo' <- unsafeManagedPtrCastPtr repo
    path' <- textToCString path
    result <- (__dynamic_C_RepoCheckoutFilter __funPtr) repo' path' stbuf userData
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr repo
    freeMem path'
    return result'

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

{- |
/No description available in the introspection data./

/Since: 2018.2/
-}
type RepoCheckoutFilter =
    OSTree.Repo.Repo
    {- ^ /@repo@/: Repo -}
    -> T.Text
    {- ^ /@path@/: Path to file -}
    -> Ptr ()
    {- ^ /@stbuf@/: File information -}
    -> IO OSTree.Enums.RepoCheckoutFilterResult
    {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCheckoutFilter`@.
noRepoCheckoutFilter :: Maybe RepoCheckoutFilter
noRepoCheckoutFilter = Nothing

{- |
/No description available in the introspection data./

/Since: 2018.2/
-}
type RepoCheckoutFilter_WithClosures =
    OSTree.Repo.Repo
    {- ^ /@repo@/: Repo -}
    -> T.Text
    {- ^ /@path@/: Path to file -}
    -> Ptr ()
    {- ^ /@stbuf@/: File information -}
    -> Ptr ()
    {- ^ /@userData@/: User data -}
    -> IO OSTree.Enums.RepoCheckoutFilterResult
    {- ^ __Returns:__ 'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `RepoCheckoutFilter_WithClosures`@.
noRepoCheckoutFilter_WithClosures :: Maybe RepoCheckoutFilter_WithClosures
noRepoCheckoutFilter_WithClosures = Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCheckoutFilter :: RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures
drop_closures_RepoCheckoutFilter _f repo path stbuf _ = _f repo path stbuf

-- | Wrap the callback into a `GClosure`.
genClosure_RepoCheckoutFilter :: MonadIO m => RepoCheckoutFilter -> m (GClosure C_RepoCheckoutFilter)
genClosure_RepoCheckoutFilter cb = liftIO $ do
    let cb' = drop_closures_RepoCheckoutFilter cb
    let cb'' = wrap_RepoCheckoutFilter Nothing cb'
    mk_RepoCheckoutFilter cb'' >>= B.GClosure.newGClosure


-- | Wrap a `RepoCheckoutFilter` into a `C_RepoCheckoutFilter`.
wrap_RepoCheckoutFilter ::
    Maybe (Ptr (FunPtr C_RepoCheckoutFilter)) ->
    RepoCheckoutFilter_WithClosures ->
    C_RepoCheckoutFilter
wrap_RepoCheckoutFilter funptrptr _cb repo path stbuf userData = do
    repo' <- (newObject OSTree.Repo.Repo) repo
    path' <- cstringToText path
    result <- _cb  repo' path' stbuf userData
    maybeReleaseFunPtr funptrptr
    let result' = (fromIntegral . fromEnum) result
    return result'


-- callback CmdPrivateVTableOstreeSystemGeneratorFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "ostree_cmdline", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "normal_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "early_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "late_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback =
    CString ->
    CString ->
    CString ->
    CString ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "ostree_cmdline", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "normal_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "early_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "late_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, 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 "dynamic" __dynamic_C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback :: FunPtr C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback -> C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CmdPrivateVTableOstreeSystemGeneratorFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback
    -> T.Text
    -> T.Text
    -> T.Text
    -> T.Text
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_CmdPrivateVTableOstreeSystemGeneratorFieldCallback __funPtr ostreeCmdline normalDir earlyDir lateDir = liftIO $ do
    ostreeCmdline' <- textToCString ostreeCmdline
    normalDir' <- textToCString normalDir
    earlyDir' <- textToCString earlyDir
    lateDir' <- textToCString lateDir
    onException (do
        _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeSystemGeneratorFieldCallback __funPtr) ostreeCmdline' normalDir' earlyDir' lateDir'
        freeMem ostreeCmdline'
        freeMem normalDir'
        freeMem earlyDir'
        freeMem lateDir'
        return ()
     ) (do
        freeMem ostreeCmdline'
        freeMem normalDir'
        freeMem earlyDir'
        freeMem lateDir'
     )

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

{- |
/No description available in the introspection data./
-}
type CmdPrivateVTableOstreeSystemGeneratorFieldCallback =
    T.Text
    -> T.Text
    -> T.Text
    -> T.Text
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeSystemGeneratorFieldCallback`@.
noCmdPrivateVTableOstreeSystemGeneratorFieldCallback :: Maybe CmdPrivateVTableOstreeSystemGeneratorFieldCallback
noCmdPrivateVTableOstreeSystemGeneratorFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_exists", 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 = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback =
    Ptr OSTree.Repo.Repo ->
    CString ->
    CInt ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_exists", 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 = False, 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 "dynamic" __dynamic_C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback :: FunPtr C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback -> C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback
    -> a
    -> T.Text
    -> Bool
    -> b
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback __funPtr repo deltaId outExists cancellable = liftIO $ do
    repo' <- unsafeManagedPtrCastPtr repo
    deltaId' <- textToCString deltaId
    let outExists' = (fromIntegral . fromEnum) outExists
    cancellable' <- unsafeManagedPtrCastPtr cancellable
    onException (do
        _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback __funPtr) repo' deltaId' outExists' cancellable'
        touchManagedPtr repo
        touchManagedPtr cancellable
        freeMem deltaId'
        return ()
     ) (do
        freeMem deltaId'
     )

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

{- |
/No description available in the introspection data./
-}
type CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback =
    OSTree.Repo.Repo
    -> T.Text
    -> Bool
    -> Gio.Cancellable.Cancellable
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback`@.
noCmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback :: Maybe CmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback
noCmdPrivateVTableOstreeStaticDeltaQueryExistsFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, 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 = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, 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 = False, 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 "dynamic" __dynamic_C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback :: FunPtr C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback -> C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback
    -> a
    -> T.Text
    -> b
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback __funPtr repo deltaId cancellable = liftIO $ do
    repo' <- unsafeManagedPtrCastPtr repo
    deltaId' <- textToCString deltaId
    cancellable' <- unsafeManagedPtrCastPtr cancellable
    onException (do
        _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback __funPtr) repo' deltaId' cancellable'
        touchManagedPtr repo
        touchManagedPtr cancellable
        freeMem deltaId'
        return ()
     ) (do
        freeMem deltaId'
     )

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

{- |
/No description available in the introspection data./
-}
type CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback =
    OSTree.Repo.Repo
    -> T.Text
    -> Gio.Cancellable.Cancellable
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback`@.
noCmdPrivateVTableOstreeStaticDeltaDumpFieldCallback :: Maybe CmdPrivateVTableOstreeStaticDeltaDumpFieldCallback
noCmdPrivateVTableOstreeStaticDeltaDumpFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, 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 = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback =
    Ptr OSTree.Repo.Repo ->
    CString ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "repo", argType = TInterface (Name {namespace = "OSTree", name = "Repo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delta_id", argType = TBasicType TUTF8, 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 = False, 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 "dynamic" __dynamic_C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback :: FunPtr C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback -> C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Repo.IsRepo a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback
    -> a
    -> T.Text
    -> b
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback __funPtr repo deltaId cancellable = liftIO $ do
    repo' <- unsafeManagedPtrCastPtr repo
    deltaId' <- textToCString deltaId
    cancellable' <- unsafeManagedPtrCastPtr cancellable
    onException (do
        _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback __funPtr) repo' deltaId' cancellable'
        touchManagedPtr repo
        touchManagedPtr cancellable
        freeMem deltaId'
        return ()
     ) (do
        freeMem deltaId'
     )

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

{- |
/No description available in the introspection data./
-}
type CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback =
    OSTree.Repo.Repo
    -> T.Text
    -> Gio.Cancellable.Cancellable
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback`@.
noCmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback :: Maybe CmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback
noCmdPrivateVTableOstreeStaticDeltaDeleteFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback =
    CString ->
    CString ->
    Ptr GVariant ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "collection_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "commit", argType = TVariant, direction = DirectionIn, mayBeNull = False, 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 "dynamic" __dynamic_C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback :: FunPtr C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback -> C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback
    -> T.Text
    -> T.Text
    -> GVariant
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback __funPtr collectionId refName commit = liftIO $ do
    collectionId' <- textToCString collectionId
    refName' <- textToCString refName
    commit' <- unsafeManagedPtrGetPtr commit
    onException (do
        _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback __funPtr) collectionId' refName' commit'
        touchManagedPtr commit
        freeMem collectionId'
        freeMem refName'
        return ()
     ) (do
        freeMem collectionId'
        freeMem refName'
     )

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

{- |
/No description available in the introspection data./
-}
type CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback =
    T.Text
    -> T.Text
    -> GVariant
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback`@.
noCmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback :: Maybe CmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback
noCmdPrivateVTableOstreeRepoVerifyBindingsFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "sysroot", 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 = "bootversion", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_fd", argType = TBasicType TInt, 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 = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback =
    Ptr OSTree.Sysroot.Sysroot ->
    Int32 ->
    Int32 ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "sysroot", 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 = "bootversion", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_fd", argType = TBasicType TInt, 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 = False, 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 "dynamic" __dynamic_C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback :: FunPtr C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback -> C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Sysroot.IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback
    -> a
    -> Int32
    -> Int32
    -> b
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback __funPtr sysroot bootversion targetFd cancellable = liftIO $ do
    sysroot' <- unsafeManagedPtrCastPtr sysroot
    cancellable' <- unsafeManagedPtrCastPtr cancellable
    onException (do
        _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback __funPtr) sysroot' bootversion targetFd cancellable'
        touchManagedPtr sysroot
        touchManagedPtr cancellable
        return ()
     ) (do
        return ()
     )

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

{- |
/No description available in the introspection data./
-}
type CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback =
    OSTree.Sysroot.Sysroot
    -> Int32
    -> Int32
    -> Gio.Cancellable.Cancellable
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback`@.
noCmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback :: Maybe CmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback
noCmdPrivateVTableOstreeGenerateGrub2ConfigFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback CmdPrivateVTableOstreeFinalizeStagedFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "sysroot", 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 = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback =
    Ptr OSTree.Sysroot.Sysroot ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "sysroot", 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 = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = False, 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 "dynamic" __dynamic_C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback :: FunPtr C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback -> C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_CmdPrivateVTableOstreeFinalizeStagedFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.Sysroot.IsSysroot a, Gio.Cancellable.IsCancellable b) =>
    FunPtr C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback
    -> a
    -> b
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_CmdPrivateVTableOstreeFinalizeStagedFieldCallback __funPtr sysroot cancellable = liftIO $ do
    sysroot' <- unsafeManagedPtrCastPtr sysroot
    cancellable' <- unsafeManagedPtrCastPtr cancellable
    onException (do
        _ <- propagateGError $ (__dynamic_C_CmdPrivateVTableOstreeFinalizeStagedFieldCallback __funPtr) sysroot' cancellable'
        touchManagedPtr sysroot
        touchManagedPtr cancellable
        return ()
     ) (do
        return ()
     )

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

{- |
/No description available in the introspection data./
-}
type CmdPrivateVTableOstreeFinalizeStagedFieldCallback =
    OSTree.Sysroot.Sysroot
    -> Gio.Cancellable.Cancellable
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `CmdPrivateVTableOstreeFinalizeStagedFieldCallback`@.
noCmdPrivateVTableOstreeFinalizeStagedFieldCallback :: Maybe CmdPrivateVTableOstreeFinalizeStagedFieldCallback
noCmdPrivateVTableOstreeFinalizeStagedFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback BootloaderInterfaceQueryFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "bootloader", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_is_active", 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 = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_BootloaderInterfaceQueryFieldCallback =
    Ptr OSTree.Bootloader.Bootloader ->
    CInt ->
    Ptr Gio.Cancellable.Cancellable ->
    Ptr (Ptr GError) ->
    IO CInt

-- Args : [Arg {argCName = "bootloader", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_is_active", 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 = False, 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 "dynamic" __dynamic_C_BootloaderInterfaceQueryFieldCallback :: FunPtr C_BootloaderInterfaceQueryFieldCallback -> C_BootloaderInterfaceQueryFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BootloaderInterfaceQueryFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    FunPtr C_BootloaderInterfaceQueryFieldCallback
    -> OSTree.Bootloader.Bootloader
    -> Bool
    -> a
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dynamic_BootloaderInterfaceQueryFieldCallback __funPtr bootloader outIsActive cancellable = liftIO $ do
    bootloader' <- unsafeManagedPtrGetPtr bootloader
    let outIsActive' = (fromIntegral . fromEnum) outIsActive
    cancellable' <- unsafeManagedPtrCastPtr cancellable
    onException (do
        _ <- propagateGError $ (__dynamic_C_BootloaderInterfaceQueryFieldCallback __funPtr) bootloader' outIsActive' cancellable'
        touchManagedPtr bootloader
        touchManagedPtr cancellable
        return ()
     ) (do
        return ()
     )

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

{- |
/No description available in the introspection data./
-}
type BootloaderInterfaceQueryFieldCallback =
    OSTree.Bootloader.Bootloader
    -> Bool
    -> Gio.Cancellable.Cancellable
    -> IO ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}

-- | A convenience synonym for @`Nothing` :: `Maybe` `BootloaderInterfaceQueryFieldCallback`@.
noBootloaderInterfaceQueryFieldCallback :: Maybe BootloaderInterfaceQueryFieldCallback
noBootloaderInterfaceQueryFieldCallback = Nothing

-- No Haskell->C wrapper generated since the function throws.

-- callback BootloaderInterfaceIsAtomicFieldCallback
--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_BootloaderInterfaceIsAtomicFieldCallback =
    Ptr OSTree.Bootloader.Bootloader ->
    IO CInt

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

foreign import ccall "dynamic" __dynamic_C_BootloaderInterfaceIsAtomicFieldCallback :: FunPtr C_BootloaderInterfaceIsAtomicFieldCallback -> C_BootloaderInterfaceIsAtomicFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BootloaderInterfaceIsAtomicFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_BootloaderInterfaceIsAtomicFieldCallback
    -> OSTree.Bootloader.Bootloader
    -> m Bool
dynamic_BootloaderInterfaceIsAtomicFieldCallback __funPtr self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- (__dynamic_C_BootloaderInterfaceIsAtomicFieldCallback __funPtr) self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

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

{- |
/No description available in the introspection data./
-}
type BootloaderInterfaceIsAtomicFieldCallback =
    OSTree.Bootloader.Bootloader
    -> IO Bool

-- | A convenience synonym for @`Nothing` :: `Maybe` `BootloaderInterfaceIsAtomicFieldCallback`@.
noBootloaderInterfaceIsAtomicFieldCallback :: Maybe BootloaderInterfaceIsAtomicFieldCallback
noBootloaderInterfaceIsAtomicFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_BootloaderInterfaceIsAtomicFieldCallback :: MonadIO m => BootloaderInterfaceIsAtomicFieldCallback -> m (GClosure C_BootloaderInterfaceIsAtomicFieldCallback)
genClosure_BootloaderInterfaceIsAtomicFieldCallback cb = liftIO $ do
    let cb' = wrap_BootloaderInterfaceIsAtomicFieldCallback Nothing cb
    mk_BootloaderInterfaceIsAtomicFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `BootloaderInterfaceIsAtomicFieldCallback` into a `C_BootloaderInterfaceIsAtomicFieldCallback`.
wrap_BootloaderInterfaceIsAtomicFieldCallback ::
    Maybe (Ptr (FunPtr C_BootloaderInterfaceIsAtomicFieldCallback)) ->
    BootloaderInterfaceIsAtomicFieldCallback ->
    C_BootloaderInterfaceIsAtomicFieldCallback
wrap_BootloaderInterfaceIsAtomicFieldCallback funptrptr _cb self = do
    self' <- (newPtr OSTree.Bootloader.Bootloader) self
    result <- _cb  self'
    maybeReleaseFunPtr funptrptr
    let result' = (fromIntegral . fromEnum) result
    return result'


-- callback BootloaderInterfaceGetNameFieldCallback
--          -> Callable {returnType = Just (TBasicType TUTF8), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_BootloaderInterfaceGetNameFieldCallback =
    Ptr OSTree.Bootloader.Bootloader ->
    IO CString

-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "OSTree", name = "Bootloader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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 "dynamic" __dynamic_C_BootloaderInterfaceGetNameFieldCallback :: FunPtr C_BootloaderInterfaceGetNameFieldCallback -> C_BootloaderInterfaceGetNameFieldCallback

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_BootloaderInterfaceGetNameFieldCallback ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    FunPtr C_BootloaderInterfaceGetNameFieldCallback
    -> OSTree.Bootloader.Bootloader
    -> m T.Text
dynamic_BootloaderInterfaceGetNameFieldCallback __funPtr self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- (__dynamic_C_BootloaderInterfaceGetNameFieldCallback __funPtr) self'
    checkUnexpectedReturnNULL "bootloaderInterfaceGetNameFieldCallback" result
    result' <- cstringToText result
    touchManagedPtr self
    return result'

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

{- |
/No description available in the introspection data./
-}
type BootloaderInterfaceGetNameFieldCallback =
    OSTree.Bootloader.Bootloader
    -> IO T.Text

-- | A convenience synonym for @`Nothing` :: `Maybe` `BootloaderInterfaceGetNameFieldCallback`@.
noBootloaderInterfaceGetNameFieldCallback :: Maybe BootloaderInterfaceGetNameFieldCallback
noBootloaderInterfaceGetNameFieldCallback = Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_BootloaderInterfaceGetNameFieldCallback :: MonadIO m => BootloaderInterfaceGetNameFieldCallback -> m (GClosure C_BootloaderInterfaceGetNameFieldCallback)
genClosure_BootloaderInterfaceGetNameFieldCallback cb = liftIO $ do
    let cb' = wrap_BootloaderInterfaceGetNameFieldCallback Nothing cb
    mk_BootloaderInterfaceGetNameFieldCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `BootloaderInterfaceGetNameFieldCallback` into a `C_BootloaderInterfaceGetNameFieldCallback`.
wrap_BootloaderInterfaceGetNameFieldCallback ::
    Maybe (Ptr (FunPtr C_BootloaderInterfaceGetNameFieldCallback)) ->
    BootloaderInterfaceGetNameFieldCallback ->
    C_BootloaderInterfaceGetNameFieldCallback
wrap_BootloaderInterfaceGetNameFieldCallback funptrptr _cb self = do
    self' <- (newPtr OSTree.Bootloader.Bootloader) self
    result <- _cb  self'
    maybeReleaseFunPtr funptrptr
    result' <- textToCString result
    return result'