{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.OSTree.Objects.Repo
    ( 
#if defined(ENABLE_OVERLOADING)
    RepoListCollectionRefsMethodInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoListCommitObjectsStartingWithMethodInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoListObjectsMethodInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoListRefsMethodInfo                  ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoListRefsExtMethodInfo               ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoRemoteListCollectionRefsMethodInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoRemoteListRefsMethodInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoTraverseCommitMethodInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoTraverseReachableRefsMethodInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoTraverseNewParentsMethodInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    RepoTraverseNewReachableMethodInfo      ,
#endif

-- * Exported types
    Repo(..)                                ,
    IsRepo                                  ,
    toRepo                                  ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [abortTransaction]("GI.OSTree.Objects.Repo#g:method:abortTransaction"), [addGpgSignatureSummary]("GI.OSTree.Objects.Repo#g:method:addGpgSignatureSummary"), [appendGpgSignature]("GI.OSTree.Objects.Repo#g:method:appendGpgSignature"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkoutAt]("GI.OSTree.Objects.Repo#g:method:checkoutAt"), [checkoutGc]("GI.OSTree.Objects.Repo#g:method:checkoutGc"), [checkoutTree]("GI.OSTree.Objects.Repo#g:method:checkoutTree"), [commitTransaction]("GI.OSTree.Objects.Repo#g:method:commitTransaction"), [copyConfig]("GI.OSTree.Objects.Repo#g:method:copyConfig"), [create]("GI.OSTree.Objects.Repo#g:method:create"), [deleteObject]("GI.OSTree.Objects.Repo#g:method:deleteObject"), [equal]("GI.OSTree.Objects.Repo#g:method:equal"), [findRemotesAsync]("GI.OSTree.Objects.Repo#g:method:findRemotesAsync"), [findRemotesFinish]("GI.OSTree.Objects.Repo#g:method:findRemotesFinish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [fsckObject]("GI.OSTree.Objects.Repo#g:method:fsckObject"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [gpgSignData]("GI.OSTree.Objects.Repo#g:method:gpgSignData"), [gpgVerifyData]("GI.OSTree.Objects.Repo#g:method:gpgVerifyData"), [hasObject]("GI.OSTree.Objects.Repo#g:method:hasObject"), [hash]("GI.OSTree.Objects.Repo#g:method:hash"), [importObjectFrom]("GI.OSTree.Objects.Repo#g:method:importObjectFrom"), [importObjectFromWithTrust]("GI.OSTree.Objects.Repo#g:method:importObjectFromWithTrust"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isSystem]("GI.OSTree.Objects.Repo#g:method:isSystem"), [isWritable]("GI.OSTree.Objects.Repo#g:method:isWritable"), [listCollectionRefs]("GI.OSTree.Objects.Repo#g:method:listCollectionRefs"), [listCommitObjectsStartingWith]("GI.OSTree.Objects.Repo#g:method:listCommitObjectsStartingWith"), [listObjects]("GI.OSTree.Objects.Repo#g:method:listObjects"), [listRefs]("GI.OSTree.Objects.Repo#g:method:listRefs"), [listRefsExt]("GI.OSTree.Objects.Repo#g:method:listRefsExt"), [listStaticDeltaIndexes]("GI.OSTree.Objects.Repo#g:method:listStaticDeltaIndexes"), [listStaticDeltaNames]("GI.OSTree.Objects.Repo#g:method:listStaticDeltaNames"), [loadCommit]("GI.OSTree.Objects.Repo#g:method:loadCommit"), [loadFile]("GI.OSTree.Objects.Repo#g:method:loadFile"), [loadObjectStream]("GI.OSTree.Objects.Repo#g:method:loadObjectStream"), [loadVariant]("GI.OSTree.Objects.Repo#g:method:loadVariant"), [loadVariantIfExists]("GI.OSTree.Objects.Repo#g:method:loadVariantIfExists"), [lockPop]("GI.OSTree.Objects.Repo#g:method:lockPop"), [lockPush]("GI.OSTree.Objects.Repo#g:method:lockPush"), [markCommitPartial]("GI.OSTree.Objects.Repo#g:method:markCommitPartial"), [markCommitPartialReason]("GI.OSTree.Objects.Repo#g:method:markCommitPartialReason"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [open]("GI.OSTree.Objects.Repo#g:method:open"), [prepareTransaction]("GI.OSTree.Objects.Repo#g:method:prepareTransaction"), [prune]("GI.OSTree.Objects.Repo#g:method:prune"), [pruneFromReachable]("GI.OSTree.Objects.Repo#g:method:pruneFromReachable"), [pruneStaticDeltas]("GI.OSTree.Objects.Repo#g:method:pruneStaticDeltas"), [pull]("GI.OSTree.Objects.Repo#g:method:pull"), [pullFromRemotesAsync]("GI.OSTree.Objects.Repo#g:method:pullFromRemotesAsync"), [pullFromRemotesFinish]("GI.OSTree.Objects.Repo#g:method:pullFromRemotesFinish"), [pullOneDir]("GI.OSTree.Objects.Repo#g:method:pullOneDir"), [pullWithOptions]("GI.OSTree.Objects.Repo#g:method:pullWithOptions"), [queryObjectStorageSize]("GI.OSTree.Objects.Repo#g:method:queryObjectStorageSize"), [readCommit]("GI.OSTree.Objects.Repo#g:method:readCommit"), [readCommitDetachedMetadata]("GI.OSTree.Objects.Repo#g:method:readCommitDetachedMetadata"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [regenerateSummary]("GI.OSTree.Objects.Repo#g:method:regenerateSummary"), [reloadConfig]("GI.OSTree.Objects.Repo#g:method:reloadConfig"), [remoteAdd]("GI.OSTree.Objects.Repo#g:method:remoteAdd"), [remoteChange]("GI.OSTree.Objects.Repo#g:method:remoteChange"), [remoteDelete]("GI.OSTree.Objects.Repo#g:method:remoteDelete"), [remoteFetchSummary]("GI.OSTree.Objects.Repo#g:method:remoteFetchSummary"), [remoteFetchSummaryWithOptions]("GI.OSTree.Objects.Repo#g:method:remoteFetchSummaryWithOptions"), [remoteGetGpgKeys]("GI.OSTree.Objects.Repo#g:method:remoteGetGpgKeys"), [remoteGetGpgVerify]("GI.OSTree.Objects.Repo#g:method:remoteGetGpgVerify"), [remoteGetGpgVerifySummary]("GI.OSTree.Objects.Repo#g:method:remoteGetGpgVerifySummary"), [remoteGetUrl]("GI.OSTree.Objects.Repo#g:method:remoteGetUrl"), [remoteGpgImport]("GI.OSTree.Objects.Repo#g:method:remoteGpgImport"), [remoteList]("GI.OSTree.Objects.Repo#g:method:remoteList"), [remoteListCollectionRefs]("GI.OSTree.Objects.Repo#g:method:remoteListCollectionRefs"), [remoteListRefs]("GI.OSTree.Objects.Repo#g:method:remoteListRefs"), [resolveCollectionRef]("GI.OSTree.Objects.Repo#g:method:resolveCollectionRef"), [resolveKeyringForCollection]("GI.OSTree.Objects.Repo#g:method:resolveKeyringForCollection"), [resolveRev]("GI.OSTree.Objects.Repo#g:method:resolveRev"), [resolveRevExt]("GI.OSTree.Objects.Repo#g:method:resolveRevExt"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [scanHardlinks]("GI.OSTree.Objects.Repo#g:method:scanHardlinks"), [signCommit]("GI.OSTree.Objects.Repo#g:method:signCommit"), [signDelta]("GI.OSTree.Objects.Repo#g:method:signDelta"), [signatureVerifyCommitData]("GI.OSTree.Objects.Repo#g:method:signatureVerifyCommitData"), [staticDeltaExecuteOffline]("GI.OSTree.Objects.Repo#g:method:staticDeltaExecuteOffline"), [staticDeltaExecuteOfflineWithSignature]("GI.OSTree.Objects.Repo#g:method:staticDeltaExecuteOfflineWithSignature"), [staticDeltaGenerate]("GI.OSTree.Objects.Repo#g:method:staticDeltaGenerate"), [staticDeltaReindex]("GI.OSTree.Objects.Repo#g:method:staticDeltaReindex"), [staticDeltaVerifySignature]("GI.OSTree.Objects.Repo#g:method:staticDeltaVerifySignature"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [transactionSetCollectionRef]("GI.OSTree.Objects.Repo#g:method:transactionSetCollectionRef"), [transactionSetRef]("GI.OSTree.Objects.Repo#g:method:transactionSetRef"), [transactionSetRefspec]("GI.OSTree.Objects.Repo#g:method:transactionSetRefspec"), [traverseCommit]("GI.OSTree.Objects.Repo#g:method:traverseCommit"), [traverseReachableRefs]("GI.OSTree.Objects.Repo#g:method:traverseReachableRefs"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [verifyCommit]("GI.OSTree.Objects.Repo#g:method:verifyCommit"), [verifyCommitExt]("GI.OSTree.Objects.Repo#g:method:verifyCommitExt"), [verifyCommitForRemote]("GI.OSTree.Objects.Repo#g:method:verifyCommitForRemote"), [verifySummary]("GI.OSTree.Objects.Repo#g:method:verifySummary"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"), [writeArchiveToMtree]("GI.OSTree.Objects.Repo#g:method:writeArchiveToMtree"), [writeArchiveToMtreeFromFd]("GI.OSTree.Objects.Repo#g:method:writeArchiveToMtreeFromFd"), [writeCommit]("GI.OSTree.Objects.Repo#g:method:writeCommit"), [writeCommitDetachedMetadata]("GI.OSTree.Objects.Repo#g:method:writeCommitDetachedMetadata"), [writeCommitWithTime]("GI.OSTree.Objects.Repo#g:method:writeCommitWithTime"), [writeConfig]("GI.OSTree.Objects.Repo#g:method:writeConfig"), [writeContent]("GI.OSTree.Objects.Repo#g:method:writeContent"), [writeContentAsync]("GI.OSTree.Objects.Repo#g:method:writeContentAsync"), [writeContentFinish]("GI.OSTree.Objects.Repo#g:method:writeContentFinish"), [writeContentTrusted]("GI.OSTree.Objects.Repo#g:method:writeContentTrusted"), [writeDfdToMtree]("GI.OSTree.Objects.Repo#g:method:writeDfdToMtree"), [writeDirectoryToMtree]("GI.OSTree.Objects.Repo#g:method:writeDirectoryToMtree"), [writeMetadata]("GI.OSTree.Objects.Repo#g:method:writeMetadata"), [writeMetadataAsync]("GI.OSTree.Objects.Repo#g:method:writeMetadataAsync"), [writeMetadataFinish]("GI.OSTree.Objects.Repo#g:method:writeMetadataFinish"), [writeMetadataStreamTrusted]("GI.OSTree.Objects.Repo#g:method:writeMetadataStreamTrusted"), [writeMetadataTrusted]("GI.OSTree.Objects.Repo#g:method:writeMetadataTrusted"), [writeMtree]("GI.OSTree.Objects.Repo#g:method:writeMtree"), [writeRegfile]("GI.OSTree.Objects.Repo#g:method:writeRegfile"), [writeRegfileInline]("GI.OSTree.Objects.Repo#g:method:writeRegfileInline"), [writeSymlink]("GI.OSTree.Objects.Repo#g:method:writeSymlink").
-- 
-- ==== Getters
-- [getBootloader]("GI.OSTree.Objects.Repo#g:method:getBootloader"), [getCollectionId]("GI.OSTree.Objects.Repo#g:method:getCollectionId"), [getConfig]("GI.OSTree.Objects.Repo#g:method:getConfig"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDefaultRepoFinders]("GI.OSTree.Objects.Repo#g:method:getDefaultRepoFinders"), [getDfd]("GI.OSTree.Objects.Repo#g:method:getDfd"), [getDisableFsync]("GI.OSTree.Objects.Repo#g:method:getDisableFsync"), [getMinFreeSpaceBytes]("GI.OSTree.Objects.Repo#g:method:getMinFreeSpaceBytes"), [getMode]("GI.OSTree.Objects.Repo#g:method:getMode"), [getParent]("GI.OSTree.Objects.Repo#g:method:getParent"), [getPath]("GI.OSTree.Objects.Repo#g:method:getPath"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRemoteBooleanOption]("GI.OSTree.Objects.Repo#g:method:getRemoteBooleanOption"), [getRemoteListOption]("GI.OSTree.Objects.Repo#g:method:getRemoteListOption"), [getRemoteOption]("GI.OSTree.Objects.Repo#g:method:getRemoteOption").
-- 
-- ==== Setters
-- [setAliasRefImmediate]("GI.OSTree.Objects.Repo#g:method:setAliasRefImmediate"), [setCacheDir]("GI.OSTree.Objects.Repo#g:method:setCacheDir"), [setCollectionId]("GI.OSTree.Objects.Repo#g:method:setCollectionId"), [setCollectionRefImmediate]("GI.OSTree.Objects.Repo#g:method:setCollectionRefImmediate"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDisableFsync]("GI.OSTree.Objects.Repo#g:method:setDisableFsync"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRefImmediate]("GI.OSTree.Objects.Repo#g:method:setRefImmediate").

#if defined(ENABLE_OVERLOADING)
    ResolveRepoMethod                       ,
#endif

-- ** abortTransaction #method:abortTransaction#

#if defined(ENABLE_OVERLOADING)
    RepoAbortTransactionMethodInfo          ,
#endif
    repoAbortTransaction                    ,


-- ** addGpgSignatureSummary #method:addGpgSignatureSummary#

#if defined(ENABLE_OVERLOADING)
    RepoAddGpgSignatureSummaryMethodInfo    ,
#endif
    repoAddGpgSignatureSummary              ,


-- ** appendGpgSignature #method:appendGpgSignature#

#if defined(ENABLE_OVERLOADING)
    RepoAppendGpgSignatureMethodInfo        ,
#endif
    repoAppendGpgSignature                  ,


-- ** checkoutAt #method:checkoutAt#

#if defined(ENABLE_OVERLOADING)
    RepoCheckoutAtMethodInfo                ,
#endif
    repoCheckoutAt                          ,


-- ** checkoutGc #method:checkoutGc#

#if defined(ENABLE_OVERLOADING)
    RepoCheckoutGcMethodInfo                ,
#endif
    repoCheckoutGc                          ,


-- ** checkoutTree #method:checkoutTree#

#if defined(ENABLE_OVERLOADING)
    RepoCheckoutTreeMethodInfo              ,
#endif
    repoCheckoutTree                        ,


-- ** commitTransaction #method:commitTransaction#

#if defined(ENABLE_OVERLOADING)
    RepoCommitTransactionMethodInfo         ,
#endif
    repoCommitTransaction                   ,


-- ** copyConfig #method:copyConfig#

#if defined(ENABLE_OVERLOADING)
    RepoCopyConfigMethodInfo                ,
#endif
    repoCopyConfig                          ,


-- ** create #method:create#

#if defined(ENABLE_OVERLOADING)
    RepoCreateMethodInfo                    ,
#endif
    repoCreate                              ,


-- ** createAt #method:createAt#

    repoCreateAt                            ,


-- ** deleteObject #method:deleteObject#

#if defined(ENABLE_OVERLOADING)
    RepoDeleteObjectMethodInfo              ,
#endif
    repoDeleteObject                        ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    RepoEqualMethodInfo                     ,
#endif
    repoEqual                               ,


-- ** findRemotesAsync #method:findRemotesAsync#

#if defined(ENABLE_OVERLOADING)
    RepoFindRemotesAsyncMethodInfo          ,
#endif
    repoFindRemotesAsync                    ,


-- ** findRemotesFinish #method:findRemotesFinish#

#if defined(ENABLE_OVERLOADING)
    RepoFindRemotesFinishMethodInfo         ,
#endif
    repoFindRemotesFinish                   ,


-- ** fsckObject #method:fsckObject#

#if defined(ENABLE_OVERLOADING)
    RepoFsckObjectMethodInfo                ,
#endif
    repoFsckObject                          ,


-- ** getBootloader #method:getBootloader#

#if defined(ENABLE_OVERLOADING)
    RepoGetBootloaderMethodInfo             ,
#endif
    repoGetBootloader                       ,


-- ** getCollectionId #method:getCollectionId#

#if defined(ENABLE_OVERLOADING)
    RepoGetCollectionIdMethodInfo           ,
#endif
    repoGetCollectionId                     ,


-- ** getConfig #method:getConfig#

#if defined(ENABLE_OVERLOADING)
    RepoGetConfigMethodInfo                 ,
#endif
    repoGetConfig                           ,


-- ** getDefaultRepoFinders #method:getDefaultRepoFinders#

#if defined(ENABLE_OVERLOADING)
    RepoGetDefaultRepoFindersMethodInfo     ,
#endif
    repoGetDefaultRepoFinders               ,


-- ** getDfd #method:getDfd#

#if defined(ENABLE_OVERLOADING)
    RepoGetDfdMethodInfo                    ,
#endif
    repoGetDfd                              ,


-- ** getDisableFsync #method:getDisableFsync#

#if defined(ENABLE_OVERLOADING)
    RepoGetDisableFsyncMethodInfo           ,
#endif
    repoGetDisableFsync                     ,


-- ** getMinFreeSpaceBytes #method:getMinFreeSpaceBytes#

#if defined(ENABLE_OVERLOADING)
    RepoGetMinFreeSpaceBytesMethodInfo      ,
#endif
    repoGetMinFreeSpaceBytes                ,


-- ** getMode #method:getMode#

#if defined(ENABLE_OVERLOADING)
    RepoGetModeMethodInfo                   ,
#endif
    repoGetMode                             ,


-- ** getParent #method:getParent#

#if defined(ENABLE_OVERLOADING)
    RepoGetParentMethodInfo                 ,
#endif
    repoGetParent                           ,


-- ** getPath #method:getPath#

#if defined(ENABLE_OVERLOADING)
    RepoGetPathMethodInfo                   ,
#endif
    repoGetPath                             ,


-- ** getRemoteBooleanOption #method:getRemoteBooleanOption#

#if defined(ENABLE_OVERLOADING)
    RepoGetRemoteBooleanOptionMethodInfo    ,
#endif
    repoGetRemoteBooleanOption              ,


-- ** getRemoteListOption #method:getRemoteListOption#

#if defined(ENABLE_OVERLOADING)
    RepoGetRemoteListOptionMethodInfo       ,
#endif
    repoGetRemoteListOption                 ,


-- ** getRemoteOption #method:getRemoteOption#

#if defined(ENABLE_OVERLOADING)
    RepoGetRemoteOptionMethodInfo           ,
#endif
    repoGetRemoteOption                     ,


-- ** gpgSignData #method:gpgSignData#

#if defined(ENABLE_OVERLOADING)
    RepoGpgSignDataMethodInfo               ,
#endif
    repoGpgSignData                         ,


-- ** gpgVerifyData #method:gpgVerifyData#

#if defined(ENABLE_OVERLOADING)
    RepoGpgVerifyDataMethodInfo             ,
#endif
    repoGpgVerifyData                       ,


-- ** hasObject #method:hasObject#

#if defined(ENABLE_OVERLOADING)
    RepoHasObjectMethodInfo                 ,
#endif
    repoHasObject                           ,


-- ** hash #method:hash#

#if defined(ENABLE_OVERLOADING)
    RepoHashMethodInfo                      ,
#endif
    repoHash                                ,


-- ** importObjectFrom #method:importObjectFrom#

#if defined(ENABLE_OVERLOADING)
    RepoImportObjectFromMethodInfo          ,
#endif
    repoImportObjectFrom                    ,


-- ** importObjectFromWithTrust #method:importObjectFromWithTrust#

#if defined(ENABLE_OVERLOADING)
    RepoImportObjectFromWithTrustMethodInfo ,
#endif
    repoImportObjectFromWithTrust           ,


-- ** isSystem #method:isSystem#

#if defined(ENABLE_OVERLOADING)
    RepoIsSystemMethodInfo                  ,
#endif
    repoIsSystem                            ,


-- ** isWritable #method:isWritable#

#if defined(ENABLE_OVERLOADING)
    RepoIsWritableMethodInfo                ,
#endif
    repoIsWritable                          ,


-- ** listStaticDeltaIndexes #method:listStaticDeltaIndexes#

#if defined(ENABLE_OVERLOADING)
    RepoListStaticDeltaIndexesMethodInfo    ,
#endif
    repoListStaticDeltaIndexes              ,


-- ** listStaticDeltaNames #method:listStaticDeltaNames#

#if defined(ENABLE_OVERLOADING)
    RepoListStaticDeltaNamesMethodInfo      ,
#endif
    repoListStaticDeltaNames                ,


-- ** loadCommit #method:loadCommit#

#if defined(ENABLE_OVERLOADING)
    RepoLoadCommitMethodInfo                ,
#endif
    repoLoadCommit                          ,


-- ** loadFile #method:loadFile#

#if defined(ENABLE_OVERLOADING)
    RepoLoadFileMethodInfo                  ,
#endif
    repoLoadFile                            ,


-- ** loadObjectStream #method:loadObjectStream#

#if defined(ENABLE_OVERLOADING)
    RepoLoadObjectStreamMethodInfo          ,
#endif
    repoLoadObjectStream                    ,


-- ** loadVariant #method:loadVariant#

#if defined(ENABLE_OVERLOADING)
    RepoLoadVariantMethodInfo               ,
#endif
    repoLoadVariant                         ,


-- ** loadVariantIfExists #method:loadVariantIfExists#

#if defined(ENABLE_OVERLOADING)
    RepoLoadVariantIfExistsMethodInfo       ,
#endif
    repoLoadVariantIfExists                 ,


-- ** lockPop #method:lockPop#

#if defined(ENABLE_OVERLOADING)
    RepoLockPopMethodInfo                   ,
#endif
    repoLockPop                             ,


-- ** lockPush #method:lockPush#

#if defined(ENABLE_OVERLOADING)
    RepoLockPushMethodInfo                  ,
#endif
    repoLockPush                            ,


-- ** markCommitPartial #method:markCommitPartial#

#if defined(ENABLE_OVERLOADING)
    RepoMarkCommitPartialMethodInfo         ,
#endif
    repoMarkCommitPartial                   ,


-- ** markCommitPartialReason #method:markCommitPartialReason#

#if defined(ENABLE_OVERLOADING)
    RepoMarkCommitPartialReasonMethodInfo   ,
#endif
    repoMarkCommitPartialReason             ,


-- ** modeFromString #method:modeFromString#

    repoModeFromString                      ,


-- ** new #method:new#

    repoNew                                 ,


-- ** newDefault #method:newDefault#

    repoNewDefault                          ,


-- ** newForSysrootPath #method:newForSysrootPath#

    repoNewForSysrootPath                   ,


-- ** open #method:open#

#if defined(ENABLE_OVERLOADING)
    RepoOpenMethodInfo                      ,
#endif
    repoOpen                                ,


-- ** openAt #method:openAt#

    repoOpenAt                              ,


-- ** prepareTransaction #method:prepareTransaction#

#if defined(ENABLE_OVERLOADING)
    RepoPrepareTransactionMethodInfo        ,
#endif
    repoPrepareTransaction                  ,


-- ** prune #method:prune#

#if defined(ENABLE_OVERLOADING)
    RepoPruneMethodInfo                     ,
#endif
    repoPrune                               ,


-- ** pruneFromReachable #method:pruneFromReachable#

#if defined(ENABLE_OVERLOADING)
    RepoPruneFromReachableMethodInfo        ,
#endif
    repoPruneFromReachable                  ,


-- ** pruneStaticDeltas #method:pruneStaticDeltas#

#if defined(ENABLE_OVERLOADING)
    RepoPruneStaticDeltasMethodInfo         ,
#endif
    repoPruneStaticDeltas                   ,


-- ** pull #method:pull#

#if defined(ENABLE_OVERLOADING)
    RepoPullMethodInfo                      ,
#endif
    repoPull                                ,


-- ** pullDefaultConsoleProgressChanged #method:pullDefaultConsoleProgressChanged#

    repoPullDefaultConsoleProgressChanged   ,


-- ** pullFromRemotesAsync #method:pullFromRemotesAsync#

#if defined(ENABLE_OVERLOADING)
    RepoPullFromRemotesAsyncMethodInfo      ,
#endif
    repoPullFromRemotesAsync                ,


-- ** pullFromRemotesFinish #method:pullFromRemotesFinish#

#if defined(ENABLE_OVERLOADING)
    RepoPullFromRemotesFinishMethodInfo     ,
#endif
    repoPullFromRemotesFinish               ,


-- ** pullOneDir #method:pullOneDir#

#if defined(ENABLE_OVERLOADING)
    RepoPullOneDirMethodInfo                ,
#endif
    repoPullOneDir                          ,


-- ** pullWithOptions #method:pullWithOptions#

#if defined(ENABLE_OVERLOADING)
    RepoPullWithOptionsMethodInfo           ,
#endif
    repoPullWithOptions                     ,


-- ** queryObjectStorageSize #method:queryObjectStorageSize#

#if defined(ENABLE_OVERLOADING)
    RepoQueryObjectStorageSizeMethodInfo    ,
#endif
    repoQueryObjectStorageSize              ,


-- ** readCommit #method:readCommit#

#if defined(ENABLE_OVERLOADING)
    RepoReadCommitMethodInfo                ,
#endif
    repoReadCommit                          ,


-- ** readCommitDetachedMetadata #method:readCommitDetachedMetadata#

#if defined(ENABLE_OVERLOADING)
    RepoReadCommitDetachedMetadataMethodInfo,
#endif
    repoReadCommitDetachedMetadata          ,


-- ** regenerateSummary #method:regenerateSummary#

#if defined(ENABLE_OVERLOADING)
    RepoRegenerateSummaryMethodInfo         ,
#endif
    repoRegenerateSummary                   ,


-- ** reloadConfig #method:reloadConfig#

#if defined(ENABLE_OVERLOADING)
    RepoReloadConfigMethodInfo              ,
#endif
    repoReloadConfig                        ,


-- ** remoteAdd #method:remoteAdd#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteAddMethodInfo                 ,
#endif
    repoRemoteAdd                           ,


-- ** remoteChange #method:remoteChange#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteChangeMethodInfo              ,
#endif
    repoRemoteChange                        ,


-- ** remoteDelete #method:remoteDelete#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteDeleteMethodInfo              ,
#endif
    repoRemoteDelete                        ,


-- ** remoteFetchSummary #method:remoteFetchSummary#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteFetchSummaryMethodInfo        ,
#endif
    repoRemoteFetchSummary                  ,


-- ** remoteFetchSummaryWithOptions #method:remoteFetchSummaryWithOptions#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteFetchSummaryWithOptionsMethodInfo,
#endif
    repoRemoteFetchSummaryWithOptions       ,


-- ** remoteGetGpgKeys #method:remoteGetGpgKeys#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteGetGpgKeysMethodInfo          ,
#endif
    repoRemoteGetGpgKeys                    ,


-- ** remoteGetGpgVerify #method:remoteGetGpgVerify#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteGetGpgVerifyMethodInfo        ,
#endif
    repoRemoteGetGpgVerify                  ,


-- ** remoteGetGpgVerifySummary #method:remoteGetGpgVerifySummary#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteGetGpgVerifySummaryMethodInfo ,
#endif
    repoRemoteGetGpgVerifySummary           ,


-- ** remoteGetUrl #method:remoteGetUrl#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteGetUrlMethodInfo              ,
#endif
    repoRemoteGetUrl                        ,


-- ** remoteGpgImport #method:remoteGpgImport#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteGpgImportMethodInfo           ,
#endif
    repoRemoteGpgImport                     ,


-- ** remoteList #method:remoteList#

#if defined(ENABLE_OVERLOADING)
    RepoRemoteListMethodInfo                ,
#endif
    repoRemoteList                          ,


-- ** resolveCollectionRef #method:resolveCollectionRef#

#if defined(ENABLE_OVERLOADING)
    RepoResolveCollectionRefMethodInfo      ,
#endif
    repoResolveCollectionRef                ,


-- ** resolveKeyringForCollection #method:resolveKeyringForCollection#

#if defined(ENABLE_OVERLOADING)
    RepoResolveKeyringForCollectionMethodInfo,
#endif
    repoResolveKeyringForCollection         ,


-- ** resolveRev #method:resolveRev#

#if defined(ENABLE_OVERLOADING)
    RepoResolveRevMethodInfo                ,
#endif
    repoResolveRev                          ,


-- ** resolveRevExt #method:resolveRevExt#

#if defined(ENABLE_OVERLOADING)
    RepoResolveRevExtMethodInfo             ,
#endif
    repoResolveRevExt                       ,


-- ** scanHardlinks #method:scanHardlinks#

#if defined(ENABLE_OVERLOADING)
    RepoScanHardlinksMethodInfo             ,
#endif
    repoScanHardlinks                       ,


-- ** setAliasRefImmediate #method:setAliasRefImmediate#

#if defined(ENABLE_OVERLOADING)
    RepoSetAliasRefImmediateMethodInfo      ,
#endif
    repoSetAliasRefImmediate                ,


-- ** setCacheDir #method:setCacheDir#

#if defined(ENABLE_OVERLOADING)
    RepoSetCacheDirMethodInfo               ,
#endif
    repoSetCacheDir                         ,


-- ** setCollectionId #method:setCollectionId#

#if defined(ENABLE_OVERLOADING)
    RepoSetCollectionIdMethodInfo           ,
#endif
    repoSetCollectionId                     ,


-- ** setCollectionRefImmediate #method:setCollectionRefImmediate#

#if defined(ENABLE_OVERLOADING)
    RepoSetCollectionRefImmediateMethodInfo ,
#endif
    repoSetCollectionRefImmediate           ,


-- ** setDisableFsync #method:setDisableFsync#

#if defined(ENABLE_OVERLOADING)
    RepoSetDisableFsyncMethodInfo           ,
#endif
    repoSetDisableFsync                     ,


-- ** setRefImmediate #method:setRefImmediate#

#if defined(ENABLE_OVERLOADING)
    RepoSetRefImmediateMethodInfo           ,
#endif
    repoSetRefImmediate                     ,


-- ** signCommit #method:signCommit#

#if defined(ENABLE_OVERLOADING)
    RepoSignCommitMethodInfo                ,
#endif
    repoSignCommit                          ,


-- ** signDelta #method:signDelta#

#if defined(ENABLE_OVERLOADING)
    RepoSignDeltaMethodInfo                 ,
#endif
    repoSignDelta                           ,


-- ** signatureVerifyCommitData #method:signatureVerifyCommitData#

#if defined(ENABLE_OVERLOADING)
    RepoSignatureVerifyCommitDataMethodInfo ,
#endif
    repoSignatureVerifyCommitData           ,


-- ** staticDeltaExecuteOffline #method:staticDeltaExecuteOffline#

#if defined(ENABLE_OVERLOADING)
    RepoStaticDeltaExecuteOfflineMethodInfo ,
#endif
    repoStaticDeltaExecuteOffline           ,


-- ** staticDeltaExecuteOfflineWithSignature #method:staticDeltaExecuteOfflineWithSignature#

#if defined(ENABLE_OVERLOADING)
    RepoStaticDeltaExecuteOfflineWithSignatureMethodInfo,
#endif
    repoStaticDeltaExecuteOfflineWithSignature,


-- ** staticDeltaGenerate #method:staticDeltaGenerate#

#if defined(ENABLE_OVERLOADING)
    RepoStaticDeltaGenerateMethodInfo       ,
#endif
    repoStaticDeltaGenerate                 ,


-- ** staticDeltaReindex #method:staticDeltaReindex#

#if defined(ENABLE_OVERLOADING)
    RepoStaticDeltaReindexMethodInfo        ,
#endif
    repoStaticDeltaReindex                  ,


-- ** staticDeltaVerifySignature #method:staticDeltaVerifySignature#

#if defined(ENABLE_OVERLOADING)
    RepoStaticDeltaVerifySignatureMethodInfo,
#endif
    repoStaticDeltaVerifySignature          ,


-- ** transactionSetCollectionRef #method:transactionSetCollectionRef#

#if defined(ENABLE_OVERLOADING)
    RepoTransactionSetCollectionRefMethodInfo,
#endif
    repoTransactionSetCollectionRef         ,


-- ** transactionSetRef #method:transactionSetRef#

#if defined(ENABLE_OVERLOADING)
    RepoTransactionSetRefMethodInfo         ,
#endif
    repoTransactionSetRef                   ,


-- ** transactionSetRefspec #method:transactionSetRefspec#

#if defined(ENABLE_OVERLOADING)
    RepoTransactionSetRefspecMethodInfo     ,
#endif
    repoTransactionSetRefspec               ,


-- ** traverseParentsGetCommits #method:traverseParentsGetCommits#

    repoTraverseParentsGetCommits           ,


-- ** verifyCommit #method:verifyCommit#

#if defined(ENABLE_OVERLOADING)
    RepoVerifyCommitMethodInfo              ,
#endif
    repoVerifyCommit                        ,


-- ** verifyCommitExt #method:verifyCommitExt#

#if defined(ENABLE_OVERLOADING)
    RepoVerifyCommitExtMethodInfo           ,
#endif
    repoVerifyCommitExt                     ,


-- ** verifyCommitForRemote #method:verifyCommitForRemote#

#if defined(ENABLE_OVERLOADING)
    RepoVerifyCommitForRemoteMethodInfo     ,
#endif
    repoVerifyCommitForRemote               ,


-- ** verifySummary #method:verifySummary#

#if defined(ENABLE_OVERLOADING)
    RepoVerifySummaryMethodInfo             ,
#endif
    repoVerifySummary                       ,


-- ** writeArchiveToMtree #method:writeArchiveToMtree#

#if defined(ENABLE_OVERLOADING)
    RepoWriteArchiveToMtreeMethodInfo       ,
#endif
    repoWriteArchiveToMtree                 ,


-- ** writeArchiveToMtreeFromFd #method:writeArchiveToMtreeFromFd#

#if defined(ENABLE_OVERLOADING)
    RepoWriteArchiveToMtreeFromFdMethodInfo ,
#endif
    repoWriteArchiveToMtreeFromFd           ,


-- ** writeCommit #method:writeCommit#

#if defined(ENABLE_OVERLOADING)
    RepoWriteCommitMethodInfo               ,
#endif
    repoWriteCommit                         ,


-- ** writeCommitDetachedMetadata #method:writeCommitDetachedMetadata#

#if defined(ENABLE_OVERLOADING)
    RepoWriteCommitDetachedMetadataMethodInfo,
#endif
    repoWriteCommitDetachedMetadata         ,


-- ** writeCommitWithTime #method:writeCommitWithTime#

#if defined(ENABLE_OVERLOADING)
    RepoWriteCommitWithTimeMethodInfo       ,
#endif
    repoWriteCommitWithTime                 ,


-- ** writeConfig #method:writeConfig#

#if defined(ENABLE_OVERLOADING)
    RepoWriteConfigMethodInfo               ,
#endif
    repoWriteConfig                         ,


-- ** writeContent #method:writeContent#

#if defined(ENABLE_OVERLOADING)
    RepoWriteContentMethodInfo              ,
#endif
    repoWriteContent                        ,


-- ** writeContentAsync #method:writeContentAsync#

#if defined(ENABLE_OVERLOADING)
    RepoWriteContentAsyncMethodInfo         ,
#endif
    repoWriteContentAsync                   ,


-- ** writeContentFinish #method:writeContentFinish#

#if defined(ENABLE_OVERLOADING)
    RepoWriteContentFinishMethodInfo        ,
#endif
    repoWriteContentFinish                  ,


-- ** writeContentTrusted #method:writeContentTrusted#

#if defined(ENABLE_OVERLOADING)
    RepoWriteContentTrustedMethodInfo       ,
#endif
    repoWriteContentTrusted                 ,


-- ** writeDfdToMtree #method:writeDfdToMtree#

#if defined(ENABLE_OVERLOADING)
    RepoWriteDfdToMtreeMethodInfo           ,
#endif
    repoWriteDfdToMtree                     ,


-- ** writeDirectoryToMtree #method:writeDirectoryToMtree#

#if defined(ENABLE_OVERLOADING)
    RepoWriteDirectoryToMtreeMethodInfo     ,
#endif
    repoWriteDirectoryToMtree               ,


-- ** writeMetadata #method:writeMetadata#

#if defined(ENABLE_OVERLOADING)
    RepoWriteMetadataMethodInfo             ,
#endif
    repoWriteMetadata                       ,


-- ** writeMetadataAsync #method:writeMetadataAsync#

#if defined(ENABLE_OVERLOADING)
    RepoWriteMetadataAsyncMethodInfo        ,
#endif
    repoWriteMetadataAsync                  ,


-- ** writeMetadataFinish #method:writeMetadataFinish#

#if defined(ENABLE_OVERLOADING)
    RepoWriteMetadataFinishMethodInfo       ,
#endif
    repoWriteMetadataFinish                 ,


-- ** writeMetadataStreamTrusted #method:writeMetadataStreamTrusted#

#if defined(ENABLE_OVERLOADING)
    RepoWriteMetadataStreamTrustedMethodInfo,
#endif
    repoWriteMetadataStreamTrusted          ,


-- ** writeMetadataTrusted #method:writeMetadataTrusted#

#if defined(ENABLE_OVERLOADING)
    RepoWriteMetadataTrustedMethodInfo      ,
#endif
    repoWriteMetadataTrusted                ,


-- ** writeMtree #method:writeMtree#

#if defined(ENABLE_OVERLOADING)
    RepoWriteMtreeMethodInfo                ,
#endif
    repoWriteMtree                          ,


-- ** writeRegfile #method:writeRegfile#

#if defined(ENABLE_OVERLOADING)
    RepoWriteRegfileMethodInfo              ,
#endif
    repoWriteRegfile                        ,


-- ** writeRegfileInline #method:writeRegfileInline#

#if defined(ENABLE_OVERLOADING)
    RepoWriteRegfileInlineMethodInfo        ,
#endif
    repoWriteRegfileInline                  ,


-- ** writeSymlink #method:writeSymlink#

#if defined(ENABLE_OVERLOADING)
    RepoWriteSymlinkMethodInfo              ,
#endif
    repoWriteSymlink                        ,




 -- * Properties


-- ** path #attr:path#
-- | Path to repository.  Note that if this repository was created
-- via @ostree_repo_new_at()@, this value will refer to a value in
-- the Linux kernel\'s @\/proc\/self\/fd@ directory.  Generally, you
-- should avoid using this property at all; you can gain a reference
-- to the repository\'s directory fd via @ostree_repo_get_dfd()@ and
-- use file-descriptor relative operations.

#if defined(ENABLE_OVERLOADING)
    RepoPathPropertyInfo                    ,
#endif
    constructRepoPath                       ,
    getRepoPath                             ,
#if defined(ENABLE_OVERLOADING)
    repoPath                                ,
#endif


-- ** remotesConfigDir #attr:remotesConfigDir#
-- | Path to directory containing remote definitions.  The default is @NULL@.
-- If a @sysroot-path@ property is defined, this value will default to
-- @${sysroot_path}\/etc\/ostree\/remotes.d@.
-- 
-- This value will only be used for system repositories.

#if defined(ENABLE_OVERLOADING)
    RepoRemotesConfigDirPropertyInfo        ,
#endif
    constructRepoRemotesConfigDir           ,
    getRepoRemotesConfigDir                 ,
#if defined(ENABLE_OVERLOADING)
    repoRemotesConfigDir                    ,
#endif


-- ** sysrootPath #attr:sysrootPath#
-- | A system using libostree for the host has a \"system\" repository; this
-- property will be set for repositories referenced via
-- @ostree_sysroot_repo()@ for example.
-- 
-- You should avoid using this property; if your code is operating
-- on a system repository, use @OstreeSysroot@ and access the repository
-- object via @ostree_sysroot_repo()@.

#if defined(ENABLE_OVERLOADING)
    RepoSysrootPathPropertyInfo             ,
#endif
    constructRepoSysrootPath                ,
    getRepoSysrootPath                      ,
#if defined(ENABLE_OVERLOADING)
    repoSysrootPath                         ,
#endif




 -- * Signals


-- ** gpgVerifyResult #signal:gpgVerifyResult#

    RepoGpgVerifyResultCallback             ,
#if defined(ENABLE_OVERLOADING)
    RepoGpgVerifyResultSignalInfo           ,
#endif
    afterRepoGpgVerifyResult                ,
    onRepoGpgVerifyResult                   ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R

import qualified GI.GLib.Structs.Bytes as GLib.Bytes
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 qualified GI.Gio.Objects.FileInfo as Gio.FileInfo
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.OSTree.Enums as OSTree.Enums
import {-# SOURCE #-} qualified GI.OSTree.Flags as OSTree.Flags
import {-# SOURCE #-} qualified GI.OSTree.Interfaces.RepoFinder as OSTree.RepoFinder
import {-# SOURCE #-} qualified GI.OSTree.Interfaces.Sign as OSTree.Sign
import {-# SOURCE #-} qualified GI.OSTree.Objects.AsyncProgress as OSTree.AsyncProgress
import {-# SOURCE #-} qualified GI.OSTree.Objects.ContentWriter as OSTree.ContentWriter
import {-# SOURCE #-} qualified GI.OSTree.Objects.GpgVerifyResult as OSTree.GpgVerifyResult
import {-# SOURCE #-} qualified GI.OSTree.Objects.MutableTree as OSTree.MutableTree
import {-# SOURCE #-} qualified GI.OSTree.Objects.RepoFile as OSTree.RepoFile
import {-# SOURCE #-} qualified GI.OSTree.Structs.CollectionRef as OSTree.CollectionRef
import {-# SOURCE #-} qualified GI.OSTree.Structs.Remote as OSTree.Remote
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCheckoutAtOptions as OSTree.RepoCheckoutAtOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoCommitModifier as OSTree.RepoCommitModifier
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoFinderResult as OSTree.RepoFinderResult
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoPruneOptions as OSTree.RepoPruneOptions
import {-# SOURCE #-} qualified GI.OSTree.Structs.RepoTransactionStats as OSTree.RepoTransactionStats

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

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

foreign import ccall "ostree_repo_get_type"
    c_ostree_repo_get_type :: IO B.Types.GType

instance B.Types.TypedObject Repo where
    glibType :: IO GType
glibType = IO GType
c_ostree_repo_get_type

instance B.Types.GObject Repo

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

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

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

-- | Convert 'Repo' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Repo) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ostree_repo_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Repo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Repo
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Repo)
    gvalueSet_ Ptr GValue
gv (P.Just Repo
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Repo
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Repo)
gvalueGet_ Ptr GValue
gv = do
        Ptr Repo
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Repo)
        if Ptr Repo
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
        then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Repo -> Repo
Repo Ptr Repo
ptr
        else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveRepoMethod (t :: Symbol) (o :: *) :: * where
    ResolveRepoMethod "abortTransaction" o = RepoAbortTransactionMethodInfo
    ResolveRepoMethod "addGpgSignatureSummary" o = RepoAddGpgSignatureSummaryMethodInfo
    ResolveRepoMethod "appendGpgSignature" o = RepoAppendGpgSignatureMethodInfo
    ResolveRepoMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveRepoMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveRepoMethod "checkoutAt" o = RepoCheckoutAtMethodInfo
    ResolveRepoMethod "checkoutGc" o = RepoCheckoutGcMethodInfo
    ResolveRepoMethod "checkoutTree" o = RepoCheckoutTreeMethodInfo
    ResolveRepoMethod "commitTransaction" o = RepoCommitTransactionMethodInfo
    ResolveRepoMethod "copyConfig" o = RepoCopyConfigMethodInfo
    ResolveRepoMethod "create" o = RepoCreateMethodInfo
    ResolveRepoMethod "deleteObject" o = RepoDeleteObjectMethodInfo
    ResolveRepoMethod "equal" o = RepoEqualMethodInfo
    ResolveRepoMethod "findRemotesAsync" o = RepoFindRemotesAsyncMethodInfo
    ResolveRepoMethod "findRemotesFinish" o = RepoFindRemotesFinishMethodInfo
    ResolveRepoMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveRepoMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveRepoMethod "fsckObject" o = RepoFsckObjectMethodInfo
    ResolveRepoMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveRepoMethod "gpgSignData" o = RepoGpgSignDataMethodInfo
    ResolveRepoMethod "gpgVerifyData" o = RepoGpgVerifyDataMethodInfo
    ResolveRepoMethod "hasObject" o = RepoHasObjectMethodInfo
    ResolveRepoMethod "hash" o = RepoHashMethodInfo
    ResolveRepoMethod "importObjectFrom" o = RepoImportObjectFromMethodInfo
    ResolveRepoMethod "importObjectFromWithTrust" o = RepoImportObjectFromWithTrustMethodInfo
    ResolveRepoMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveRepoMethod "isSystem" o = RepoIsSystemMethodInfo
    ResolveRepoMethod "isWritable" o = RepoIsWritableMethodInfo
    ResolveRepoMethod "listCollectionRefs" o = RepoListCollectionRefsMethodInfo
    ResolveRepoMethod "listCommitObjectsStartingWith" o = RepoListCommitObjectsStartingWithMethodInfo
    ResolveRepoMethod "listObjects" o = RepoListObjectsMethodInfo
    ResolveRepoMethod "listRefs" o = RepoListRefsMethodInfo
    ResolveRepoMethod "listRefsExt" o = RepoListRefsExtMethodInfo
    ResolveRepoMethod "listStaticDeltaIndexes" o = RepoListStaticDeltaIndexesMethodInfo
    ResolveRepoMethod "listStaticDeltaNames" o = RepoListStaticDeltaNamesMethodInfo
    ResolveRepoMethod "loadCommit" o = RepoLoadCommitMethodInfo
    ResolveRepoMethod "loadFile" o = RepoLoadFileMethodInfo
    ResolveRepoMethod "loadObjectStream" o = RepoLoadObjectStreamMethodInfo
    ResolveRepoMethod "loadVariant" o = RepoLoadVariantMethodInfo
    ResolveRepoMethod "loadVariantIfExists" o = RepoLoadVariantIfExistsMethodInfo
    ResolveRepoMethod "lockPop" o = RepoLockPopMethodInfo
    ResolveRepoMethod "lockPush" o = RepoLockPushMethodInfo
    ResolveRepoMethod "markCommitPartial" o = RepoMarkCommitPartialMethodInfo
    ResolveRepoMethod "markCommitPartialReason" o = RepoMarkCommitPartialReasonMethodInfo
    ResolveRepoMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveRepoMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveRepoMethod "open" o = RepoOpenMethodInfo
    ResolveRepoMethod "prepareTransaction" o = RepoPrepareTransactionMethodInfo
    ResolveRepoMethod "prune" o = RepoPruneMethodInfo
    ResolveRepoMethod "pruneFromReachable" o = RepoPruneFromReachableMethodInfo
    ResolveRepoMethod "pruneStaticDeltas" o = RepoPruneStaticDeltasMethodInfo
    ResolveRepoMethod "pull" o = RepoPullMethodInfo
    ResolveRepoMethod "pullFromRemotesAsync" o = RepoPullFromRemotesAsyncMethodInfo
    ResolveRepoMethod "pullFromRemotesFinish" o = RepoPullFromRemotesFinishMethodInfo
    ResolveRepoMethod "pullOneDir" o = RepoPullOneDirMethodInfo
    ResolveRepoMethod "pullWithOptions" o = RepoPullWithOptionsMethodInfo
    ResolveRepoMethod "queryObjectStorageSize" o = RepoQueryObjectStorageSizeMethodInfo
    ResolveRepoMethod "readCommit" o = RepoReadCommitMethodInfo
    ResolveRepoMethod "readCommitDetachedMetadata" o = RepoReadCommitDetachedMetadataMethodInfo
    ResolveRepoMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveRepoMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveRepoMethod "regenerateSummary" o = RepoRegenerateSummaryMethodInfo
    ResolveRepoMethod "reloadConfig" o = RepoReloadConfigMethodInfo
    ResolveRepoMethod "remoteAdd" o = RepoRemoteAddMethodInfo
    ResolveRepoMethod "remoteChange" o = RepoRemoteChangeMethodInfo
    ResolveRepoMethod "remoteDelete" o = RepoRemoteDeleteMethodInfo
    ResolveRepoMethod "remoteFetchSummary" o = RepoRemoteFetchSummaryMethodInfo
    ResolveRepoMethod "remoteFetchSummaryWithOptions" o = RepoRemoteFetchSummaryWithOptionsMethodInfo
    ResolveRepoMethod "remoteGetGpgKeys" o = RepoRemoteGetGpgKeysMethodInfo
    ResolveRepoMethod "remoteGetGpgVerify" o = RepoRemoteGetGpgVerifyMethodInfo
    ResolveRepoMethod "remoteGetGpgVerifySummary" o = RepoRemoteGetGpgVerifySummaryMethodInfo
    ResolveRepoMethod "remoteGetUrl" o = RepoRemoteGetUrlMethodInfo
    ResolveRepoMethod "remoteGpgImport" o = RepoRemoteGpgImportMethodInfo
    ResolveRepoMethod "remoteList" o = RepoRemoteListMethodInfo
    ResolveRepoMethod "remoteListCollectionRefs" o = RepoRemoteListCollectionRefsMethodInfo
    ResolveRepoMethod "remoteListRefs" o = RepoRemoteListRefsMethodInfo
    ResolveRepoMethod "resolveCollectionRef" o = RepoResolveCollectionRefMethodInfo
    ResolveRepoMethod "resolveKeyringForCollection" o = RepoResolveKeyringForCollectionMethodInfo
    ResolveRepoMethod "resolveRev" o = RepoResolveRevMethodInfo
    ResolveRepoMethod "resolveRevExt" o = RepoResolveRevExtMethodInfo
    ResolveRepoMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveRepoMethod "scanHardlinks" o = RepoScanHardlinksMethodInfo
    ResolveRepoMethod "signCommit" o = RepoSignCommitMethodInfo
    ResolveRepoMethod "signDelta" o = RepoSignDeltaMethodInfo
    ResolveRepoMethod "signatureVerifyCommitData" o = RepoSignatureVerifyCommitDataMethodInfo
    ResolveRepoMethod "staticDeltaExecuteOffline" o = RepoStaticDeltaExecuteOfflineMethodInfo
    ResolveRepoMethod "staticDeltaExecuteOfflineWithSignature" o = RepoStaticDeltaExecuteOfflineWithSignatureMethodInfo
    ResolveRepoMethod "staticDeltaGenerate" o = RepoStaticDeltaGenerateMethodInfo
    ResolveRepoMethod "staticDeltaReindex" o = RepoStaticDeltaReindexMethodInfo
    ResolveRepoMethod "staticDeltaVerifySignature" o = RepoStaticDeltaVerifySignatureMethodInfo
    ResolveRepoMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveRepoMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveRepoMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveRepoMethod "transactionSetCollectionRef" o = RepoTransactionSetCollectionRefMethodInfo
    ResolveRepoMethod "transactionSetRef" o = RepoTransactionSetRefMethodInfo
    ResolveRepoMethod "transactionSetRefspec" o = RepoTransactionSetRefspecMethodInfo
    ResolveRepoMethod "traverseCommit" o = RepoTraverseCommitMethodInfo
    ResolveRepoMethod "traverseReachableRefs" o = RepoTraverseReachableRefsMethodInfo
    ResolveRepoMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveRepoMethod "verifyCommit" o = RepoVerifyCommitMethodInfo
    ResolveRepoMethod "verifyCommitExt" o = RepoVerifyCommitExtMethodInfo
    ResolveRepoMethod "verifyCommitForRemote" o = RepoVerifyCommitForRemoteMethodInfo
    ResolveRepoMethod "verifySummary" o = RepoVerifySummaryMethodInfo
    ResolveRepoMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveRepoMethod "writeArchiveToMtree" o = RepoWriteArchiveToMtreeMethodInfo
    ResolveRepoMethod "writeArchiveToMtreeFromFd" o = RepoWriteArchiveToMtreeFromFdMethodInfo
    ResolveRepoMethod "writeCommit" o = RepoWriteCommitMethodInfo
    ResolveRepoMethod "writeCommitDetachedMetadata" o = RepoWriteCommitDetachedMetadataMethodInfo
    ResolveRepoMethod "writeCommitWithTime" o = RepoWriteCommitWithTimeMethodInfo
    ResolveRepoMethod "writeConfig" o = RepoWriteConfigMethodInfo
    ResolveRepoMethod "writeContent" o = RepoWriteContentMethodInfo
    ResolveRepoMethod "writeContentAsync" o = RepoWriteContentAsyncMethodInfo
    ResolveRepoMethod "writeContentFinish" o = RepoWriteContentFinishMethodInfo
    ResolveRepoMethod "writeContentTrusted" o = RepoWriteContentTrustedMethodInfo
    ResolveRepoMethod "writeDfdToMtree" o = RepoWriteDfdToMtreeMethodInfo
    ResolveRepoMethod "writeDirectoryToMtree" o = RepoWriteDirectoryToMtreeMethodInfo
    ResolveRepoMethod "writeMetadata" o = RepoWriteMetadataMethodInfo
    ResolveRepoMethod "writeMetadataAsync" o = RepoWriteMetadataAsyncMethodInfo
    ResolveRepoMethod "writeMetadataFinish" o = RepoWriteMetadataFinishMethodInfo
    ResolveRepoMethod "writeMetadataStreamTrusted" o = RepoWriteMetadataStreamTrustedMethodInfo
    ResolveRepoMethod "writeMetadataTrusted" o = RepoWriteMetadataTrustedMethodInfo
    ResolveRepoMethod "writeMtree" o = RepoWriteMtreeMethodInfo
    ResolveRepoMethod "writeRegfile" o = RepoWriteRegfileMethodInfo
    ResolveRepoMethod "writeRegfileInline" o = RepoWriteRegfileInlineMethodInfo
    ResolveRepoMethod "writeSymlink" o = RepoWriteSymlinkMethodInfo
    ResolveRepoMethod "getBootloader" o = RepoGetBootloaderMethodInfo
    ResolveRepoMethod "getCollectionId" o = RepoGetCollectionIdMethodInfo
    ResolveRepoMethod "getConfig" o = RepoGetConfigMethodInfo
    ResolveRepoMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveRepoMethod "getDefaultRepoFinders" o = RepoGetDefaultRepoFindersMethodInfo
    ResolveRepoMethod "getDfd" o = RepoGetDfdMethodInfo
    ResolveRepoMethod "getDisableFsync" o = RepoGetDisableFsyncMethodInfo
    ResolveRepoMethod "getMinFreeSpaceBytes" o = RepoGetMinFreeSpaceBytesMethodInfo
    ResolveRepoMethod "getMode" o = RepoGetModeMethodInfo
    ResolveRepoMethod "getParent" o = RepoGetParentMethodInfo
    ResolveRepoMethod "getPath" o = RepoGetPathMethodInfo
    ResolveRepoMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveRepoMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveRepoMethod "getRemoteBooleanOption" o = RepoGetRemoteBooleanOptionMethodInfo
    ResolveRepoMethod "getRemoteListOption" o = RepoGetRemoteListOptionMethodInfo
    ResolveRepoMethod "getRemoteOption" o = RepoGetRemoteOptionMethodInfo
    ResolveRepoMethod "setAliasRefImmediate" o = RepoSetAliasRefImmediateMethodInfo
    ResolveRepoMethod "setCacheDir" o = RepoSetCacheDirMethodInfo
    ResolveRepoMethod "setCollectionId" o = RepoSetCollectionIdMethodInfo
    ResolveRepoMethod "setCollectionRefImmediate" o = RepoSetCollectionRefImmediateMethodInfo
    ResolveRepoMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveRepoMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveRepoMethod "setDisableFsync" o = RepoSetDisableFsyncMethodInfo
    ResolveRepoMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveRepoMethod "setRefImmediate" o = RepoSetRefImmediateMethodInfo
    ResolveRepoMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveRepoMethod t Repo, O.OverloadedMethod info Repo p, R.HasField t Repo p) => R.HasField t Repo p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveRepoMethod t Repo, O.OverloadedMethodInfo info Repo) => OL.IsLabel t (O.MethodProxy info Repo) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal Repo::gpg-verify-result
-- | Emitted during a pull operation upon GPG verification (if enabled).
-- Applications can connect to this signal to output the verification
-- results if desired.
-- 
-- The signal will be emitted from whichever t'GI.GLib.Structs.MainContext.MainContext' is the
-- thread-default at the point when 'GI.OSTree.Objects.Repo.repoPullWithOptions'
-- is called.
type RepoGpgVerifyResultCallback =
    T.Text
    -- ^ /@checksum@/: checksum of the signed object
    -> OSTree.GpgVerifyResult.GpgVerifyResult
    -- ^ /@result@/: an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'
    -> IO ()

type C_RepoGpgVerifyResultCallback =
    Ptr Repo ->                             -- object
    CString ->
    Ptr OSTree.GpgVerifyResult.GpgVerifyResult ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_RepoGpgVerifyResultCallback :: 
    GObject a => (a -> RepoGpgVerifyResultCallback) ->
    C_RepoGpgVerifyResultCallback
wrap_RepoGpgVerifyResultCallback :: forall a.
GObject a =>
(a -> RepoGpgVerifyResultCallback) -> C_RepoGpgVerifyResultCallback
wrap_RepoGpgVerifyResultCallback a -> RepoGpgVerifyResultCallback
gi'cb Ptr Repo
gi'selfPtr CString
checksum Ptr GpgVerifyResult
result_ Ptr ()
_ = do
    Text
checksum' <- HasCallStack => CString -> IO Text
cstringToText CString
checksum
    GpgVerifyResult
result_' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr GpgVerifyResult -> GpgVerifyResult
OSTree.GpgVerifyResult.GpgVerifyResult) Ptr GpgVerifyResult
result_
    forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Repo
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Repo
gi'self -> a -> RepoGpgVerifyResultCallback
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Repo
gi'self)  Text
checksum' GpgVerifyResult
result_'


-- | Connect a signal handler for the [gpgVerifyResult](#signal:gpgVerifyResult) 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' repo #gpgVerifyResult callback
-- @
-- 
-- 
onRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> ((?self :: a) => RepoGpgVerifyResultCallback) -> m SignalHandlerId
onRepoGpgVerifyResult :: forall a (m :: * -> *).
(IsRepo a, MonadIO m) =>
a
-> ((?self::a) => RepoGpgVerifyResultCallback) -> m SignalHandlerId
onRepoGpgVerifyResult a
obj (?self::a) => RepoGpgVerifyResultCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> RepoGpgVerifyResultCallback
wrapped a
self = let ?self = a
self in (?self::a) => RepoGpgVerifyResultCallback
cb
    let wrapped' :: C_RepoGpgVerifyResultCallback
wrapped' = forall a.
GObject a =>
(a -> RepoGpgVerifyResultCallback) -> C_RepoGpgVerifyResultCallback
wrap_RepoGpgVerifyResultCallback a -> RepoGpgVerifyResultCallback
wrapped
    FunPtr C_RepoGpgVerifyResultCallback
wrapped'' <- C_RepoGpgVerifyResultCallback
-> IO (FunPtr C_RepoGpgVerifyResultCallback)
mk_RepoGpgVerifyResultCallback C_RepoGpgVerifyResultCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"gpg-verify-result" FunPtr C_RepoGpgVerifyResultCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gpgVerifyResult](#signal:gpgVerifyResult) 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' repo #gpgVerifyResult callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> ((?self :: a) => RepoGpgVerifyResultCallback) -> m SignalHandlerId
afterRepoGpgVerifyResult :: forall a (m :: * -> *).
(IsRepo a, MonadIO m) =>
a
-> ((?self::a) => RepoGpgVerifyResultCallback) -> m SignalHandlerId
afterRepoGpgVerifyResult a
obj (?self::a) => RepoGpgVerifyResultCallback
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> RepoGpgVerifyResultCallback
wrapped a
self = let ?self = a
self in (?self::a) => RepoGpgVerifyResultCallback
cb
    let wrapped' :: C_RepoGpgVerifyResultCallback
wrapped' = forall a.
GObject a =>
(a -> RepoGpgVerifyResultCallback) -> C_RepoGpgVerifyResultCallback
wrap_RepoGpgVerifyResultCallback a -> RepoGpgVerifyResultCallback
wrapped
    FunPtr C_RepoGpgVerifyResultCallback
wrapped'' <- C_RepoGpgVerifyResultCallback
-> IO (FunPtr C_RepoGpgVerifyResultCallback)
mk_RepoGpgVerifyResultCallback C_RepoGpgVerifyResultCallback
wrapped'
    forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"gpg-verify-result" FunPtr C_RepoGpgVerifyResultCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data RepoGpgVerifyResultSignalInfo
instance SignalInfo RepoGpgVerifyResultSignalInfo where
    type HaskellCallbackType RepoGpgVerifyResultSignalInfo = RepoGpgVerifyResultCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_RepoGpgVerifyResultCallback cb
        cb'' <- mk_RepoGpgVerifyResultCallback cb'
        connectSignalFunPtr obj "gpg-verify-result" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo::gpg-verify-result"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#g:signal:gpgVerifyResult"})

#endif

-- 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' repo #path
-- @
getRepoPath :: (MonadIO m, IsRepo o) => o -> m Gio.File.File
getRepoPath :: forall (m :: * -> *) o. (MonadIO m, IsRepo o) => o -> m File
getRepoPath o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getRepoPath" forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"path" ManagedPtr File -> File
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`.
constructRepoPath :: (IsRepo o, MIO.MonadIO m, Gio.File.IsFile a) => a -> m (GValueConstruct o)
constructRepoPath :: forall o (m :: * -> *) a.
(IsRepo o, MonadIO m, IsFile a) =>
a -> m (GValueConstruct o)
constructRepoPath a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"path" (forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data RepoPathPropertyInfo
instance AttrInfo RepoPathPropertyInfo where
    type AttrAllowedOps RepoPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint RepoPathPropertyInfo = IsRepo
    type AttrSetTypeConstraint RepoPathPropertyInfo = Gio.File.IsFile
    type AttrTransferTypeConstraint RepoPathPropertyInfo = Gio.File.IsFile
    type AttrTransferType RepoPathPropertyInfo = Gio.File.File
    type AttrGetType RepoPathPropertyInfo = Gio.File.File
    type AttrLabel RepoPathPropertyInfo = "path"
    type AttrOrigin RepoPathPropertyInfo = Repo
    attrGet = getRepoPath
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Gio.File.File v
    attrConstruct = constructRepoPath
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.path"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#g:attr:path"
        })
#endif

-- VVV Prop "remotes-config-dir"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@remotes-config-dir@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' repo #remotesConfigDir
-- @
getRepoRemotesConfigDir :: (MonadIO m, IsRepo o) => o -> m (Maybe T.Text)
getRepoRemotesConfigDir :: forall (m :: * -> *) o.
(MonadIO m, IsRepo o) =>
o -> m (Maybe Text)
getRepoRemotesConfigDir o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"remotes-config-dir"

-- | Construct a `GValueConstruct` with valid value for the “@remotes-config-dir@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructRepoRemotesConfigDir :: (IsRepo o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructRepoRemotesConfigDir :: forall o (m :: * -> *).
(IsRepo o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructRepoRemotesConfigDir Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"remotes-config-dir" (forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data RepoRemotesConfigDirPropertyInfo
instance AttrInfo RepoRemotesConfigDirPropertyInfo where
    type AttrAllowedOps RepoRemotesConfigDirPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint RepoRemotesConfigDirPropertyInfo = IsRepo
    type AttrSetTypeConstraint RepoRemotesConfigDirPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint RepoRemotesConfigDirPropertyInfo = (~) T.Text
    type AttrTransferType RepoRemotesConfigDirPropertyInfo = T.Text
    type AttrGetType RepoRemotesConfigDirPropertyInfo = (Maybe T.Text)
    type AttrLabel RepoRemotesConfigDirPropertyInfo = "remotes-config-dir"
    type AttrOrigin RepoRemotesConfigDirPropertyInfo = Repo
    attrGet = getRepoRemotesConfigDir
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructRepoRemotesConfigDir
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.remotesConfigDir"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#g:attr:remotesConfigDir"
        })
#endif

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

-- | Get the value of the “@sysroot-path@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' repo #sysrootPath
-- @
getRepoSysrootPath :: (MonadIO m, IsRepo o) => o -> m (Maybe Gio.File.File)
getRepoSysrootPath :: forall (m :: * -> *) o.
(MonadIO m, IsRepo o) =>
o -> m (Maybe File)
getRepoSysrootPath o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"sysroot-path" ManagedPtr File -> File
Gio.File.File

-- | Construct a `GValueConstruct` with valid value for the “@sysroot-path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructRepoSysrootPath :: (IsRepo o, MIO.MonadIO m, Gio.File.IsFile a) => a -> m (GValueConstruct o)
constructRepoSysrootPath :: forall o (m :: * -> *) a.
(IsRepo o, MonadIO m, IsFile a) =>
a -> m (GValueConstruct o)
constructRepoSysrootPath a
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"sysroot-path" (forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data RepoSysrootPathPropertyInfo
instance AttrInfo RepoSysrootPathPropertyInfo where
    type AttrAllowedOps RepoSysrootPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint RepoSysrootPathPropertyInfo = IsRepo
    type AttrSetTypeConstraint RepoSysrootPathPropertyInfo = Gio.File.IsFile
    type AttrTransferTypeConstraint RepoSysrootPathPropertyInfo = Gio.File.IsFile
    type AttrTransferType RepoSysrootPathPropertyInfo = Gio.File.File
    type AttrGetType RepoSysrootPathPropertyInfo = (Maybe Gio.File.File)
    type AttrLabel RepoSysrootPathPropertyInfo = "sysroot-path"
    type AttrOrigin RepoSysrootPathPropertyInfo = Repo
    attrGet = getRepoSysrootPath
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Gio.File.File v
    attrConstruct = constructRepoSysrootPath
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.sysrootPath"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#g:attr:sysrootPath"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Repo
type instance O.AttributeList Repo = RepoAttributeList
type RepoAttributeList = ('[ '("path", RepoPathPropertyInfo), '("remotesConfigDir", RepoRemotesConfigDirPropertyInfo), '("sysrootPath", RepoSysrootPathPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
repoPath :: AttrLabelProxy "path"
repoPath = AttrLabelProxy

repoRemotesConfigDir :: AttrLabelProxy "remotesConfigDir"
repoRemotesConfigDir = AttrLabelProxy

repoSysrootPath :: AttrLabelProxy "sysrootPath"
repoSysrootPath = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Repo = RepoSignalList
type RepoSignalList = ('[ '("gpgVerifyResult", RepoGpgVerifyResultSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Repo::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "path"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path to a repository"
--                 , 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_repo_new" ostree_repo_new :: 
    Ptr Gio.File.File ->                    -- path : TInterface (Name {namespace = "Gio", name = "File"})
    IO (Ptr Repo)

-- | /No description available in the introspection data./
repoNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a) =>
    a
    -- ^ /@path@/: Path to a repository
    -> m Repo
    -- ^ __Returns:__ An accessor object for an OSTree repository located at /@path@/
repoNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFile a) =>
a -> m Repo
repoNew a
path = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr File
path' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
path
    Ptr Repo
result <- Ptr File -> IO (Ptr Repo)
ostree_repo_new Ptr File
path'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoNew" Ptr Repo
result
    Repo
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Repo -> Repo
Repo) Ptr Repo
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
path
    forall (m :: * -> *) a. Monad m => a -> m a
return Repo
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "ostree_repo_new_default" ostree_repo_new_default :: 
    IO (Ptr Repo)

-- | If the current working directory appears to be an OSTree
-- repository, create a new t'GI.OSTree.Objects.Repo.Repo' object for accessing it.
-- Otherwise use the path in the OSTREE_REPO environment variable
-- (if defined) or else the default system repository located at
-- \/ostree\/repo.
repoNewDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Repo
    -- ^ __Returns:__ An accessor object for an OSTree repository located at \/ostree\/repo
repoNewDefault :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Repo
repoNewDefault  = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
result <- IO (Ptr Repo)
ostree_repo_new_default
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoNewDefault" Ptr Repo
result
    Repo
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Repo -> Repo
Repo) Ptr Repo
result
    forall (m :: * -> *) a. Monad m => a -> m a
return Repo
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Repo::new_for_sysroot_path
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "repo_path"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path to a repository"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sysroot_path"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path to the system root"
--                 , 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_repo_new_for_sysroot_path" ostree_repo_new_for_sysroot_path :: 
    Ptr Gio.File.File ->                    -- repo_path : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.File.File ->                    -- sysroot_path : TInterface (Name {namespace = "Gio", name = "File"})
    IO (Ptr Repo)

-- | Creates a new t'GI.OSTree.Objects.Repo.Repo' instance, taking the system root path explicitly
-- instead of assuming \"\/\".
repoNewForSysrootPath ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.File.IsFile b) =>
    a
    -- ^ /@repoPath@/: Path to a repository
    -> b
    -- ^ /@sysrootPath@/: Path to the system root
    -> m Repo
    -- ^ __Returns:__ An accessor object for the OSTree repository located at /@repoPath@/.
repoNewForSysrootPath :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFile a, IsFile b) =>
a -> b -> m Repo
repoNewForSysrootPath a
repoPath b
sysrootPath = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr File
repoPath' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repoPath
    Ptr File
sysrootPath' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sysrootPath
    Ptr Repo
result <- Ptr File -> Ptr File -> IO (Ptr Repo)
ostree_repo_new_for_sysroot_path Ptr File
repoPath' Ptr File
sysrootPath'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoNewForSysrootPath" Ptr Repo
result
    Repo
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Repo -> Repo
Repo) Ptr Repo
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repoPath
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sysrootPath
    forall (m :: * -> *) a. Monad m => a -> m a
return Repo
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Repo::abort_transaction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , 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_repo_abort_transaction" ostree_repo_abort_transaction :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Abort the active transaction; any staged objects and ref changes will be
-- discarded. You *must* invoke this if you have chosen not to invoke
-- 'GI.OSTree.Objects.Repo.repoCommitTransaction'. Calling this function when not in a
-- transaction will do nothing and return successfully.
repoAbortTransaction ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoAbortTransaction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m ()
repoAbortTransaction a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_abort_transaction Ptr Repo
self' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoAbortTransactionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoAbortTransactionMethodInfo a signature where
    overloadedMethod = repoAbortTransaction

instance O.OverloadedMethodInfo RepoAbortTransactionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoAbortTransaction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoAbortTransaction"
        })


#endif

-- method Repo::add_gpg_signature_summary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_id"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "NULL-terminated array of GPG keys."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "homedir"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GPG home directory, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable" , 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_repo_add_gpg_signature_summary" ostree_repo_add_gpg_signature_summary :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr CString ->                          -- key_id : TCArray True (-1) (-1) (TBasicType TUTF8)
    CString ->                              -- homedir : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Add a GPG signature to a summary file.
repoAddGpgSignatureSummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Self
    -> [T.Text]
    -- ^ /@keyId@/: NULL-terminated array of GPG keys.
    -> Maybe (T.Text)
    -- ^ /@homedir@/: GPG home directory, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoAddGpgSignatureSummary :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> [Text] -> Maybe Text -> Maybe b -> m ()
repoAddGpgSignatureSummary a
self [Text]
keyId Maybe Text
homedir Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CString
keyId' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
keyId
    CString
maybeHomedir <- case Maybe Text
homedir of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jHomedir -> do
            CString
jHomedir' <- Text -> IO CString
textToCString Text
jHomedir
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jHomedir'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_add_gpg_signature_summary Ptr Repo
self' Ptr CString
keyId' CString
maybeHomedir Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
maybeHomedir
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
maybeHomedir
     )

#if defined(ENABLE_OVERLOADING)
data RepoAddGpgSignatureSummaryMethodInfo
instance (signature ~ ([T.Text] -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoAddGpgSignatureSummaryMethodInfo a signature where
    overloadedMethod = repoAddGpgSignatureSummary

instance O.OverloadedMethodInfo RepoAddGpgSignatureSummaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoAddGpgSignatureSummary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoAddGpgSignatureSummary"
        })


#endif

-- method Repo::append_gpg_signature
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "SHA256 of given commit to sign"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signature_bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Signature data" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable" , 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_repo_append_gpg_signature" ostree_repo_append_gpg_signature :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- commit_checksum : TBasicType TUTF8
    Ptr GLib.Bytes.Bytes ->                 -- signature_bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Append a GPG signature to a commit.
repoAppendGpgSignature ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Self
    -> T.Text
    -- ^ /@commitChecksum@/: SHA256 of given commit to sign
    -> GLib.Bytes.Bytes
    -- ^ /@signatureBytes@/: Signature data
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoAppendGpgSignature :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Bytes -> Maybe b -> m ()
repoAppendGpgSignature a
self Text
commitChecksum Bytes
signatureBytes Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
commitChecksum' <- Text -> IO CString
textToCString Text
commitChecksum
    Ptr Bytes
signatureBytes' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
signatureBytes
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr Bytes
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_append_gpg_signature Ptr Repo
self' CString
commitChecksum' Ptr Bytes
signatureBytes' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
signatureBytes
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoAppendGpgSignatureMethodInfo
instance (signature ~ (T.Text -> GLib.Bytes.Bytes -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoAppendGpgSignatureMethodInfo a signature where
    overloadedMethod = repoAppendGpgSignature

instance O.OverloadedMethodInfo RepoAppendGpgSignatureMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoAppendGpgSignature",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoAppendGpgSignature"
        })


#endif

-- method Repo::checkout_at
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "options"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCheckoutAtOptions" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Options" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destination_dfd"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Directory FD for destination"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destination_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Directory for destination"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum for commit"
--                 , 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_repo_checkout_at" ostree_repo_checkout_at :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr OSTree.RepoCheckoutAtOptions.RepoCheckoutAtOptions -> -- options : TInterface (Name {namespace = "OSTree", name = "RepoCheckoutAtOptions"})
    Int32 ->                                -- destination_dfd : TBasicType TInt
    CString ->                              -- destination_path : TBasicType TUTF8
    CString ->                              -- commit : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Similar to 'GI.OSTree.Objects.Repo.repoCheckoutTree', but uses directory-relative
-- paths for the destination, uses a new @OstreeRepoCheckoutAtOptions@,
-- and takes a commit checksum and optional subpath pair, rather than
-- requiring use of @GFile@ APIs for the caller.
-- 
-- It also replaces 'GI.OSTree.Objects.Repo.repoCheckoutAt' which was not safe to
-- use with GObject introspection.
-- 
-- Note in addition that unlike 'GI.OSTree.Objects.Repo.repoCheckoutTree', the
-- default is not to use the repository-internal uncompressed objects
-- cache.
-- 
-- /Since: 2016.8/
repoCheckoutAt ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (OSTree.RepoCheckoutAtOptions.RepoCheckoutAtOptions)
    -- ^ /@options@/: Options
    -> Int32
    -- ^ /@destinationDfd@/: Directory FD for destination
    -> T.Text
    -- ^ /@destinationPath@/: Directory for destination
    -> T.Text
    -- ^ /@commit@/: Checksum for commit
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCheckoutAt :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> Maybe RepoCheckoutAtOptions
-> Int32
-> Text
-> Text
-> Maybe b
-> m ()
repoCheckoutAt a
self Maybe RepoCheckoutAtOptions
options Int32
destinationDfd Text
destinationPath Text
commit Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr RepoCheckoutAtOptions
maybeOptions <- case Maybe RepoCheckoutAtOptions
options of
        Maybe RepoCheckoutAtOptions
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just RepoCheckoutAtOptions
jOptions -> do
            Ptr RepoCheckoutAtOptions
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCheckoutAtOptions
jOptions
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RepoCheckoutAtOptions
jOptions'
    CString
destinationPath' <- Text -> IO CString
textToCString Text
destinationPath
    CString
commit' <- Text -> IO CString
textToCString Text
commit
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr RepoCheckoutAtOptions
-> Int32
-> CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_checkout_at Ptr Repo
self' Ptr RepoCheckoutAtOptions
maybeOptions Int32
destinationDfd CString
destinationPath' CString
commit' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RepoCheckoutAtOptions
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
destinationPath'
        forall a. Ptr a -> IO ()
freeMem CString
commit'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
destinationPath'
        forall a. Ptr a -> IO ()
freeMem CString
commit'
     )

#if defined(ENABLE_OVERLOADING)
data RepoCheckoutAtMethodInfo
instance (signature ~ (Maybe (OSTree.RepoCheckoutAtOptions.RepoCheckoutAtOptions) -> Int32 -> T.Text -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoCheckoutAtMethodInfo a signature where
    overloadedMethod = repoCheckoutAt

instance O.OverloadedMethodInfo RepoCheckoutAtMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoCheckoutAt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoCheckoutAt"
        })


#endif

-- method Repo::checkout_gc
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "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_repo_checkout_gc" ostree_repo_checkout_gc :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Call this after finishing a succession of checkout operations; it
-- will delete any currently-unused uncompressed objects from the
-- cache.
repoCheckoutGc ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCheckoutGc :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m ()
repoCheckoutGc a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_checkout_gc Ptr Repo
self' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoCheckoutGcMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoCheckoutGcMethodInfo a signature where
    overloadedMethod = repoCheckoutGc

instance O.OverloadedMethodInfo RepoCheckoutGcMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoCheckoutGc",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoCheckoutGc"
        })


#endif

-- method Repo::checkout_tree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "mode"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCheckoutMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Options controlling all files"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "overwrite_mode"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCheckoutOverwriteMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether or not to overwrite files"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destination"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Place tree here" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Source tree" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source_info"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "FileInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Source info" , 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_repo_checkout_tree" ostree_repo_checkout_tree :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "OSTree", name = "RepoCheckoutMode"})
    CUInt ->                                -- overwrite_mode : TInterface (Name {namespace = "OSTree", name = "RepoCheckoutOverwriteMode"})
    Ptr Gio.File.File ->                    -- destination : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr OSTree.RepoFile.RepoFile ->         -- source : TInterface (Name {namespace = "OSTree", name = "RepoFile"})
    Ptr Gio.FileInfo.FileInfo ->            -- source_info : TInterface (Name {namespace = "Gio", name = "FileInfo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Check out /@source@/ into /@destination@/, which must live on the
-- physical filesystem.  /@source@/ may be any subdirectory of a given
-- commit.  The /@mode@/ and /@overwriteMode@/ allow control over how the
-- files are checked out.
repoCheckoutTree ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.RepoFile.IsRepoFile c, Gio.FileInfo.IsFileInfo d, Gio.Cancellable.IsCancellable e) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.RepoCheckoutMode
    -- ^ /@mode@/: Options controlling all files
    -> OSTree.Enums.RepoCheckoutOverwriteMode
    -- ^ /@overwriteMode@/: Whether or not to overwrite files
    -> b
    -- ^ /@destination@/: Place tree here
    -> c
    -- ^ /@source@/: Source tree
    -> d
    -- ^ /@sourceInfo@/: Source info
    -> Maybe (e)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCheckoutTree :: forall (m :: * -> *) a b c d e.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsRepoFile c,
 IsFileInfo d, IsCancellable e) =>
a
-> RepoCheckoutMode
-> RepoCheckoutOverwriteMode
-> b
-> c
-> d
-> Maybe e
-> m ()
repoCheckoutTree a
self RepoCheckoutMode
mode RepoCheckoutOverwriteMode
overwriteMode b
destination c
source d
sourceInfo Maybe e
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mode' :: CUInt
mode' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoCheckoutMode
mode
    let overwriteMode' :: CUInt
overwriteMode' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoCheckoutOverwriteMode
overwriteMode
    Ptr File
destination' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
destination
    Ptr RepoFile
source' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
source
    Ptr FileInfo
sourceInfo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
sourceInfo
    Ptr Cancellable
maybeCancellable <- case Maybe e
cancellable of
        Maybe e
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just e
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr e
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CUInt
-> Ptr File
-> Ptr RepoFile
-> Ptr FileInfo
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_checkout_tree Ptr Repo
self' CUInt
mode' CUInt
overwriteMode' Ptr File
destination' Ptr RepoFile
source' Ptr FileInfo
sourceInfo' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
destination
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
source
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr d
sourceInfo
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe e
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoCheckoutTreeMethodInfo
instance (signature ~ (OSTree.Enums.RepoCheckoutMode -> OSTree.Enums.RepoCheckoutOverwriteMode -> b -> c -> d -> Maybe (e) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.RepoFile.IsRepoFile c, Gio.FileInfo.IsFileInfo d, Gio.Cancellable.IsCancellable e) => O.OverloadedMethod RepoCheckoutTreeMethodInfo a signature where
    overloadedMethod = repoCheckoutTree

instance O.OverloadedMethodInfo RepoCheckoutTreeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoCheckoutTree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoCheckoutTree"
        })


#endif

-- method Repo::commit_transaction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_stats"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoTransactionStats" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A set of statistics of things\nthat happened during this transaction."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , 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_repo_commit_transaction" ostree_repo_commit_transaction :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr OSTree.RepoTransactionStats.RepoTransactionStats -> -- out_stats : TInterface (Name {namespace = "OSTree", name = "RepoTransactionStats"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Complete the transaction. Any refs set with
-- 'GI.OSTree.Objects.Repo.repoTransactionSetRef' or
-- 'GI.OSTree.Objects.Repo.repoTransactionSetRefspec' will be written out.
-- 
-- Note that if multiple threads are performing writes, all such threads must
-- have terminated before this function is invoked.
-- 
-- Locking: Releases @shared@ lock acquired by @ostree_repo_prepare_transaction()@
-- Multithreading: This function is *not* MT safe; only one transaction can be
-- active at a time.
repoCommitTransaction ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m (OSTree.RepoTransactionStats.RepoTransactionStats)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCommitTransaction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m RepoTransactionStats
repoCommitTransaction a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr RepoTransactionStats
outStats <- forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
56 :: IO (Ptr OSTree.RepoTransactionStats.RepoTransactionStats)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr RepoTransactionStats
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_commit_transaction Ptr Repo
self' Ptr RepoTransactionStats
outStats Ptr Cancellable
maybeCancellable
        RepoTransactionStats
outStats' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RepoTransactionStats -> RepoTransactionStats
OSTree.RepoTransactionStats.RepoTransactionStats) Ptr RepoTransactionStats
outStats
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return RepoTransactionStats
outStats'
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr RepoTransactionStats
outStats
     )

#if defined(ENABLE_OVERLOADING)
data RepoCommitTransactionMethodInfo
instance (signature ~ (Maybe (b) -> m (OSTree.RepoTransactionStats.RepoTransactionStats)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoCommitTransactionMethodInfo a signature where
    overloadedMethod = repoCommitTransaction

instance O.OverloadedMethodInfo RepoCommitTransactionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoCommitTransaction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoCommitTransaction"
        })


#endif

-- method Repo::copy_config
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "KeyFile" })
-- throws : False
-- Skip return : False

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

-- | /No description available in the introspection data./
repoCopyConfig ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -> m GLib.KeyFile.KeyFile
    -- ^ __Returns:__ A newly-allocated copy of the repository config
repoCopyConfig :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m KeyFile
repoCopyConfig a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr KeyFile
result <- Ptr Repo -> IO (Ptr KeyFile)
ostree_repo_copy_config Ptr Repo
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoCopyConfig" Ptr KeyFile
result
    KeyFile
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr KeyFile -> KeyFile
GLib.KeyFile.KeyFile) Ptr KeyFile
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return KeyFile
result'

#if defined(ENABLE_OVERLOADING)
data RepoCopyConfigMethodInfo
instance (signature ~ (m GLib.KeyFile.KeyFile), MonadIO m, IsRepo a) => O.OverloadedMethod RepoCopyConfigMethodInfo a signature where
    overloadedMethod = repoCopyConfig

instance O.OverloadedMethodInfo RepoCopyConfigMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoCopyConfig",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoCopyConfig"
        })


#endif

-- method Repo::create
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The mode to store the repository in"
--                 , 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_repo_create" ostree_repo_create :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "OSTree", name = "RepoMode"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Create the underlying structure on disk for the repository, and call
-- 'GI.OSTree.Objects.Repo.repoOpen' on the result, preparing it for use.
-- 
-- Since version 2016.8, this function will succeed on an existing
-- repository, and finish creating any necessary files in a partially
-- created repository.  However, this function cannot change the mode
-- of an existing repository, and will silently ignore an attempt to
-- do so.
-- 
-- Since 2017.9, \"existing repository\" is defined by the existence of an
-- @objects@ subdirectory.
-- 
-- This function predates 'GI.OSTree.Objects.Repo.repoCreateAt'. It is an error to call
-- this function on a repository initialized via 'GI.OSTree.Objects.Repo.repoOpenAt'.
repoCreate ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> OSTree.Enums.RepoMode
    -- ^ /@mode@/: The mode to store the repository in
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoCreate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> RepoMode -> Maybe b -> m ()
repoCreate a
self RepoMode
mode Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mode' :: CUInt
mode' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoMode
mode
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_create Ptr Repo
self' CUInt
mode' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoCreateMethodInfo
instance (signature ~ (OSTree.Enums.RepoMode -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoCreateMethodInfo a signature where
    overloadedMethod = repoCreate

instance O.OverloadedMethodInfo RepoCreateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoCreate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoCreate"
        })


#endif

-- method Repo::delete_object
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sha256"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum" , 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_repo_delete_object" ostree_repo_delete_object :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- sha256 : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Remove the object of type /@objtype@/ with checksum /@sha256@/
-- from the repository.  An error of type 'GI.Gio.Enums.IOErrorEnumNotFound'
-- is thrown if the object does not exist.
repoDeleteObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@sha256@/: Checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoDeleteObject :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> ObjectType -> Text -> Maybe b -> m ()
repoDeleteObject a
self ObjectType
objtype Text
sha256 Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
sha256' <- Text -> IO CString
textToCString Text
sha256
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_delete_object Ptr Repo
self' CUInt
objtype' CString
sha256' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
     )

#if defined(ENABLE_OVERLOADING)
data RepoDeleteObjectMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoDeleteObjectMethodInfo a signature where
    overloadedMethod = repoDeleteObject

instance O.OverloadedMethodInfo RepoDeleteObjectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoDeleteObject",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoDeleteObject"
        })


#endif

-- method Repo::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "a"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "b"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , 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 "ostree_repo_equal" ostree_repo_equal :: 
    Ptr Repo ->                             -- a : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Repo ->                             -- b : TInterface (Name {namespace = "OSTree", name = "Repo"})
    IO CInt

-- | Check whether two opened repositories are the same on disk: if their root
-- directories are the same inode. If /@a@/ or /@b@/ are not open yet (due to
-- 'GI.OSTree.Objects.Repo.repoOpen' not being called on them yet), 'P.False' will be returned.
-- 
-- /Since: 2017.12/
repoEqual ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, IsRepo b) =>
    a
    -- ^ /@a@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> b
    -- ^ /@b@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@a@/ and /@b@/ are the same repository on disk, 'P.False' otherwise
repoEqual :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsRepo b) =>
a -> b -> m Bool
repoEqual a
a b
b = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
a' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
a
    Ptr Repo
b' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
b
    CInt
result <- Ptr Repo -> Ptr Repo -> IO CInt
ostree_repo_equal Ptr Repo
a' Ptr Repo
b'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
a
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
b
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data RepoEqualMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsRepo a, IsRepo b) => O.OverloadedMethod RepoEqualMethodInfo a signature where
    overloadedMethod = repoEqual

instance O.OverloadedMethodInfo RepoEqualMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoEqual"
        })


#endif

-- method Repo::find_remotes_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "refs"
--           , argType =
--               TCArray
--                 True
--                 (-1)
--                 (-1)
--                 (TInterface Name { namespace = "OSTree" , name = "CollectionRef" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "non-empty array of collection\8211ref pairs to find remotes for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a GVariant `a{sv}` with an extensible set of flags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "finders"
--           , argType =
--               TCArray
--                 True
--                 (-1)
--                 (-1)
--                 (TInterface Name { namespace = "OSTree" , name = "RepoFinder" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "non-empty array of\n   #OstreeRepoFinder instances to use, or %NULL to use the system defaults"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "progress"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "AsyncProgress" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "an #OstreeAsyncProgress to update with the operation\8217s\n   progress, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "asynchronous completion callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 7
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to pass to @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_find_remotes_async" ostree_repo_find_remotes_async :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr (Ptr OSTree.CollectionRef.CollectionRef) -> -- refs : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "CollectionRef"}))
    Ptr GVariant ->                         -- options : TVariant
    Ptr (Ptr OSTree.RepoFinder.RepoFinder) -> -- finders : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinder"}))
    Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    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 ()

-- | Find reachable remote URIs which claim to provide any of the given named
-- /@refs@/. This will search for configured remotes (t'GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig'),
-- mounted volumes (t'GI.OSTree.Objects.RepoFinderMount.RepoFinderMount') and (if enabled at compile time)
-- local network peers (t'GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi'). In order to use a custom
-- configuration of t'GI.OSTree.Interfaces.RepoFinder.RepoFinder' instances, call
-- 'GI.OSTree.Functions.repoFinderResolveAllAsync' on them individually.
-- 
-- Any remote which is found and which claims to support any of the given /@refs@/
-- will be returned in the results. It is possible that a remote claims to
-- support a given ref, but turns out not to — it is not possible to verify this
-- until 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' is called.
-- 
-- The returned results will be sorted with the most useful first — this is
-- typically the remote which claims to provide the most of /@refs@/, at the lowest
-- latency.
-- 
-- Each result contains a list of the subset of /@refs@/ it claims to provide. It
-- is possible for a non-empty list of results to be returned, but for some of
-- /@refs@/ to not be listed in any of the results. Callers must check for this.
-- 
-- Pass the results to 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' to pull the given /@refs@/
-- from those remotes.
-- 
-- The following /@options@/ are currently defined:
-- 
--   * @override-commit-ids@ (@as@): Array of specific commit IDs to fetch. The nth
--   commit ID applies to the nth ref, so this must be the same length as /@refs@/, if
--   provided.
--   * @n-network-retries@ (@u@): Number of times to retry each download on
--   receiving a transient network error, such as a socket timeout; default is
--   5, 0 means return errors without retrying. Since: 2018.6
-- 
-- /@finders@/ must be a non-empty 'P.Nothing'-terminated array of the t'GI.OSTree.Interfaces.RepoFinder.RepoFinder'
-- instances to use, or 'P.Nothing' to use the system default set of finders, which
-- will typically be all available finders using their default options (but
-- this is not guaranteed).
-- 
-- GPG verification of commits will be used unconditionally.
-- 
-- This will use the thread-default t'GI.GLib.Structs.MainContext.MainContext', but will not iterate it.
-- 
-- /Since: 2018.6/
repoFindRemotesAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> [OSTree.CollectionRef.CollectionRef]
    -- ^ /@refs@/: non-empty array of collection–ref pairs to find remotes for
    -> Maybe (GVariant)
    -- ^ /@options@/: a GVariant @a{sv}@ with an extensible set of flags
    -> [OSTree.RepoFinder.RepoFinder]
    -- ^ /@finders@/: non-empty array of
    --    t'GI.OSTree.Interfaces.RepoFinder.RepoFinder' instances to use, or 'P.Nothing' to use the system defaults
    -> Maybe (b)
    -- ^ /@progress@/: an t'GI.OSTree.Objects.AsyncProgress.AsyncProgress' to update with the operation’s
    --    progress, or 'P.Nothing'
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: asynchronous completion callback
    -> m ()
repoFindRemotesAsync :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b,
 IsCancellable c) =>
a
-> [CollectionRef]
-> Maybe GVariant
-> [RepoFinder]
-> Maybe b
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
repoFindRemotesAsync a
self [CollectionRef]
refs Maybe GVariant
options [RepoFinder]
finders Maybe b
progress Maybe c
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    [Ptr CollectionRef]
refs' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [CollectionRef]
refs
    Ptr (Ptr CollectionRef)
refs'' <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray [Ptr CollectionRef]
refs'
    Ptr GVariant
maybeOptions <- case Maybe GVariant
options of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jOptions -> do
            Ptr GVariant
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jOptions
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jOptions'
    [Ptr RepoFinder]
finders' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [RepoFinder]
finders
    Ptr (Ptr RepoFinder)
finders'' <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray [Ptr RepoFinder]
finders'
    Ptr AsyncProgress
maybeProgress <- case Maybe b
progress of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jProgress -> do
            Ptr AsyncProgress
jProgress' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jProgress
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AsyncProgress
jProgress'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
    Ptr Repo
-> Ptr (Ptr CollectionRef)
-> Ptr GVariant
-> Ptr (Ptr RepoFinder)
-> Ptr AsyncProgress
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ostree_repo_find_remotes_async Ptr Repo
self' Ptr (Ptr CollectionRef)
refs'' Ptr GVariant
maybeOptions Ptr (Ptr RepoFinder)
finders'' Ptr AsyncProgress
maybeProgress Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [CollectionRef]
refs
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [RepoFinder]
finders
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
progress forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CollectionRef)
refs''
    forall a. Ptr a -> IO ()
freeMem Ptr (Ptr RepoFinder)
finders''
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoFindRemotesAsyncMethodInfo
instance (signature ~ ([OSTree.CollectionRef.CollectionRef] -> Maybe (GVariant) -> [OSTree.RepoFinder.RepoFinder] -> Maybe (b) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoFindRemotesAsyncMethodInfo a signature where
    overloadedMethod = repoFindRemotesAsync

instance O.OverloadedMethodInfo RepoFindRemotesAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoFindRemotesAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoFindRemotesAsync"
        })


#endif

-- method Repo::find_remotes_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , 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 "the asynchronous result"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TCArray
--                  True
--                  (-1)
--                  (-1)
--                  (TInterface
--                     Name { namespace = "OSTree" , name = "RepoFinderResult" }))
-- throws : True
-- Skip return : False

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

-- | Finish an asynchronous pull operation started with
-- 'GI.OSTree.Objects.Repo.repoFindRemotesAsync'.
-- 
-- /Since: 2018.6/
repoFindRemotesFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> b
    -- ^ /@result@/: the asynchronous result
    -> m [OSTree.RepoFinderResult.RepoFinderResult]
    -- ^ __Returns:__ a potentially empty array
    --    of @/OstreeRepoFinderResults/@, followed by a 'P.Nothing' terminator element; or
    --    'P.Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/
repoFindRemotesFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) =>
a -> b -> m [RepoFinderResult]
repoFindRemotesFinish a
self b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (Ptr RepoFinderResult)
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr AsyncResult
-> Ptr (Ptr GError)
-> IO (Ptr (Ptr RepoFinderResult))
ostree_repo_find_remotes_finish Ptr Repo
self' Ptr AsyncResult
result_'
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoFindRemotesFinish" Ptr (Ptr RepoFinderResult)
result
        [Ptr RepoFinderResult]
result' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr RepoFinderResult)
result
        [RepoFinderResult]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RepoFinderResult -> RepoFinderResult
OSTree.RepoFinderResult.RepoFinderResult) [Ptr RepoFinderResult]
result'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr RepoFinderResult)
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        forall (m :: * -> *) a. Monad m => a -> m a
return [RepoFinderResult]
result''
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoFindRemotesFinishMethodInfo
instance (signature ~ (b -> m [OSTree.RepoFinderResult.RepoFinderResult]), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod RepoFindRemotesFinishMethodInfo a signature where
    overloadedMethod = repoFindRemotesFinish

instance O.OverloadedMethodInfo RepoFindRemotesFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoFindRemotesFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoFindRemotesFinish"
        })


#endif

-- method Repo::fsck_object
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sha256"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum" , 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_repo_fsck_object" ostree_repo_fsck_object :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- sha256 : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Verify consistency of the object; this performs checks only relevant to the
-- immediate object itself, such as checksumming. This API call will not itself
-- traverse metadata objects for example.
-- 
-- /Since: 2017.15/
repoFsckObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@sha256@/: Checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoFsckObject :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> ObjectType -> Text -> Maybe b -> m ()
repoFsckObject a
self ObjectType
objtype Text
sha256 Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
sha256' <- Text -> IO CString
textToCString Text
sha256
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_fsck_object Ptr Repo
self' CUInt
objtype' CString
sha256' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
     )

#if defined(ENABLE_OVERLOADING)
data RepoFsckObjectMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoFsckObjectMethodInfo a signature where
    overloadedMethod = repoFsckObject

instance O.OverloadedMethodInfo RepoFsckObjectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoFsckObject",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoFsckObject"
        })


#endif

-- method Repo::get_bootloader
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , 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_repo_get_bootloader" ostree_repo_get_bootloader :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    IO CString

-- | Get the bootloader configured. See the documentation for the
-- \"sysroot.bootloader\" config key.
-- 
-- /Since: 2019.2/
repoGetBootloader ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> m T.Text
    -- ^ __Returns:__ bootloader configuration for the sysroot
repoGetBootloader :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m Text
repoGetBootloader a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Repo -> IO CString
ostree_repo_get_bootloader Ptr Repo
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoGetBootloader" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data RepoGetBootloaderMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetBootloaderMethodInfo a signature where
    overloadedMethod = repoGetBootloader

instance O.OverloadedMethodInfo RepoGetBootloaderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetBootloader",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetBootloader"
        })


#endif

-- method Repo::get_collection_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , 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_repo_get_collection_id" ostree_repo_get_collection_id :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    IO CString

-- | Get the collection ID of this repository. See [collection IDs][collection-ids].
-- 
-- /Since: 2018.6/
repoGetCollectionId ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ collection ID for the repository
repoGetCollectionId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m (Maybe Text)
repoGetCollectionId a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Repo -> IO CString
ostree_repo_get_collection_id Ptr Repo
self'
    Maybe Text
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data RepoGetCollectionIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetCollectionIdMethodInfo a signature where
    overloadedMethod = repoGetCollectionId

instance O.OverloadedMethodInfo RepoGetCollectionIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetCollectionId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetCollectionId"
        })


#endif

-- method Repo::get_config
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "KeyFile" })
-- throws : False
-- Skip return : False

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

-- | /No description available in the introspection data./
repoGetConfig ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -> m GLib.KeyFile.KeyFile
    -- ^ __Returns:__ The repository configuration; do not modify
repoGetConfig :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m KeyFile
repoGetConfig a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr KeyFile
result <- Ptr Repo -> IO (Ptr KeyFile)
ostree_repo_get_config Ptr Repo
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoGetConfig" Ptr KeyFile
result
    KeyFile
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr KeyFile -> KeyFile
GLib.KeyFile.KeyFile) Ptr KeyFile
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return KeyFile
result'

#if defined(ENABLE_OVERLOADING)
data RepoGetConfigMethodInfo
instance (signature ~ (m GLib.KeyFile.KeyFile), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetConfigMethodInfo a signature where
    overloadedMethod = repoGetConfig

instance O.OverloadedMethodInfo RepoGetConfigMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetConfig",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetConfig"
        })


#endif

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

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

-- | Get the set of default repo finders configured. See the documentation for
-- the \"core.default-repo-finders\" config key.
-- 
-- /Since: 2018.9/
repoGetDefaultRepoFinders ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> m [T.Text]
    -- ^ __Returns:__ 
    --    'P.Nothing'-terminated array of strings.
repoGetDefaultRepoFinders :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m [Text]
repoGetDefaultRepoFinders a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CString
result <- Ptr Repo -> IO (Ptr CString)
ostree_repo_get_default_repo_finders Ptr Repo
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoGetDefaultRepoFinders" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data RepoGetDefaultRepoFindersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetDefaultRepoFindersMethodInfo a signature where
    overloadedMethod = repoGetDefaultRepoFinders

instance O.OverloadedMethodInfo RepoGetDefaultRepoFindersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetDefaultRepoFinders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetDefaultRepoFinders"
        })


#endif

-- method Repo::get_dfd
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

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

-- | In some cases it\'s useful for applications to access the repository
-- directly; for example, writing content into @repo\/tmp@ ensures it\'s
-- on the same filesystem.  Another case is detecting the mtime on the
-- repository (to see whether a ref was written).
-- 
-- /Since: 2016.4/
repoGetDfd ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> m Int32
    -- ^ __Returns:__ File descriptor for repository root - owned by /@self@/
repoGetDfd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m Int32
repoGetDfd a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr Repo -> IO Int32
ostree_repo_get_dfd Ptr Repo
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data RepoGetDfdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetDfdMethodInfo a signature where
    overloadedMethod = repoGetDfd

instance O.OverloadedMethodInfo RepoGetDfdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetDfd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetDfd"
        })


#endif

-- method Repo::get_disable_fsync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , 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 "ostree_repo_get_disable_fsync" ostree_repo_get_disable_fsync :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    IO CInt

-- | For more information see 'GI.OSTree.Objects.Repo.repoSetDisableFsync'.
repoGetDisableFsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> m Bool
    -- ^ __Returns:__ Whether or not @/fsync()/@ is enabled for this repo.
repoGetDisableFsync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m Bool
repoGetDisableFsync a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Repo -> IO CInt
ostree_repo_get_disable_fsync Ptr Repo
self'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data RepoGetDisableFsyncMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetDisableFsyncMethodInfo a signature where
    overloadedMethod = repoGetDisableFsync

instance O.OverloadedMethodInfo RepoGetDisableFsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetDisableFsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetDisableFsync"
        })


#endif

-- method Repo::get_min_free_space_bytes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "out_reserved_bytes"
--           , argType = TBasicType TUInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Location to store the result"
--                 , 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_repo_get_min_free_space_bytes" ostree_repo_get_min_free_space_bytes :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Word64 ->                           -- out_reserved_bytes : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Determine the number of bytes of free disk space that are reserved according
-- to the repo config and return that number in /@outReservedBytes@/. See the
-- documentation for the core.min-free-space-size and
-- core.min-free-space-percent repo config options.
-- 
-- /Since: 2018.9/
repoGetMinFreeSpaceBytes ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> m (Word64)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoGetMinFreeSpaceBytes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m Word64
repoGetMinFreeSpaceBytes a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Word64
outReservedBytes <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr Word64 -> Ptr (Ptr GError) -> IO CInt
ostree_repo_get_min_free_space_bytes Ptr Repo
self' Ptr Word64
outReservedBytes
        Word64
outReservedBytes' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outReservedBytes
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outReservedBytes
        forall (m :: * -> *) a. Monad m => a -> m a
return Word64
outReservedBytes'
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outReservedBytes
     )

#if defined(ENABLE_OVERLOADING)
data RepoGetMinFreeSpaceBytesMethodInfo
instance (signature ~ (m (Word64)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetMinFreeSpaceBytesMethodInfo a signature where
    overloadedMethod = repoGetMinFreeSpaceBytes

instance O.OverloadedMethodInfo RepoGetMinFreeSpaceBytesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetMinFreeSpaceBytes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetMinFreeSpaceBytes"
        })


#endif

-- method Repo::get_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "OSTree" , name = "RepoMode" })
-- throws : False
-- Skip return : False

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

-- | /No description available in the introspection data./
repoGetMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -> m OSTree.Enums.RepoMode
repoGetMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m RepoMode
repoGetMode a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Repo -> IO CUInt
ostree_repo_get_mode Ptr Repo
self'
    let result' :: RepoMode
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return RepoMode
result'

#if defined(ENABLE_OVERLOADING)
data RepoGetModeMethodInfo
instance (signature ~ (m OSTree.Enums.RepoMode), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetModeMethodInfo a signature where
    overloadedMethod = repoGetMode

instance O.OverloadedMethodInfo RepoGetModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetMode"
        })


#endif

-- method Repo::get_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "OSTree" , name = "Repo" })
-- throws : False
-- Skip return : False

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

-- | Before this function can be used, @/ostree_repo_init()/@ must have been
-- called.
repoGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> m Repo
    -- ^ __Returns:__ Parent repository, or 'P.Nothing' if none
repoGetParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m Repo
repoGetParent a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Repo
result <- Ptr Repo -> IO (Ptr Repo)
ostree_repo_get_parent Ptr Repo
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoGetParent" Ptr Repo
result
    Repo
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Repo -> Repo
Repo) Ptr Repo
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Repo
result'

#if defined(ENABLE_OVERLOADING)
data RepoGetParentMethodInfo
instance (signature ~ (m Repo), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetParentMethodInfo a signature where
    overloadedMethod = repoGetParent

instance O.OverloadedMethodInfo RepoGetParentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetParent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetParent"
        })


#endif

-- method Repo::get_path
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "File" })
-- throws : False
-- Skip return : False

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

-- | Note that since the introduction of 'GI.OSTree.Objects.Repo.repoOpenAt', this function may
-- return a process-specific path in @\/proc@ if the repository was created using
-- that API. In general, you should avoid use of this API.
repoGetPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> m Gio.File.File
    -- ^ __Returns:__ Path to repo
repoGetPath :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m File
repoGetPath a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
result <- Ptr Repo -> IO (Ptr File)
ostree_repo_get_path Ptr Repo
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoGetPath" Ptr File
result
    File
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr File -> File
Gio.File.File) Ptr File
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return File
result'

#if defined(ENABLE_OVERLOADING)
data RepoGetPathMethodInfo
instance (signature ~ (m Gio.File.File), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetPathMethodInfo a signature where
    overloadedMethod = repoGetPath

instance O.OverloadedMethodInfo RepoGetPathMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetPath",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetPath"
        })


#endif

-- method Repo::get_remote_boolean_option
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "option_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Option" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "default_value"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Value returned if @option_name is not present"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_value"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store the result."
--                 , 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_repo_get_remote_boolean_option" ostree_repo_get_remote_boolean_option :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    CString ->                              -- option_name : TBasicType TUTF8
    CInt ->                                 -- default_value : TBasicType TBoolean
    Ptr CInt ->                             -- out_value : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | OSTree remotes are represented by keyfile groups, formatted like:
-- @[remote \"remotename\"]@. This function returns a value named /@optionName@/
-- underneath that group, and returns it as a boolean.
-- If the option is not set, /@outValue@/ will be set to /@defaultValue@/. If an
-- error is returned, /@outValue@/ will be set to 'P.False'.
-- 
-- /Since: 2016.5/
repoGetRemoteBooleanOption ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: A OstreeRepo
    -> T.Text
    -- ^ /@remoteName@/: Name
    -> T.Text
    -- ^ /@optionName@/: Option
    -> Bool
    -- ^ /@defaultValue@/: Value returned if /@optionName@/ is not present
    -> m (Bool)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoGetRemoteBooleanOption :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Text -> Bool -> m Bool
repoGetRemoteBooleanOption a
self Text
remoteName Text
optionName Bool
defaultValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    CString
optionName' <- Text -> IO CString
textToCString Text
optionName
    let defaultValue' :: CInt
defaultValue' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
defaultValue
    Ptr CInt
outValue <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CInt
-> Ptr CInt
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_get_remote_boolean_option Ptr Repo
self' CString
remoteName' CString
optionName' CInt
defaultValue' Ptr CInt
outValue
        CInt
outValue' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
outValue
        let outValue'' :: Bool
outValue'' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
outValue'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
optionName'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outValue
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
outValue''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
optionName'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outValue
     )

#if defined(ENABLE_OVERLOADING)
data RepoGetRemoteBooleanOptionMethodInfo
instance (signature ~ (T.Text -> T.Text -> Bool -> m (Bool)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetRemoteBooleanOptionMethodInfo a signature where
    overloadedMethod = repoGetRemoteBooleanOption

instance O.OverloadedMethodInfo RepoGetRemoteBooleanOptionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetRemoteBooleanOption",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetRemoteBooleanOption"
        })


#endif

-- method Repo::get_remote_list_option
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "option_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Option" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_value"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "location to store the list\n           of strings. The list should be freed with\n           g_strfreev()."
--                 , 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_repo_get_remote_list_option" ostree_repo_get_remote_list_option :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    CString ->                              -- option_name : TBasicType TUTF8
    Ptr (Ptr CString) ->                    -- out_value : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | OSTree remotes are represented by keyfile groups, formatted like:
-- @[remote \"remotename\"]@. This function returns a value named /@optionName@/
-- underneath that group, and returns it as a zero terminated array of strings.
-- If the option is not set, or if an error is returned, /@outValue@/ will be set
-- to 'P.Nothing'.
-- 
-- /Since: 2016.5/
repoGetRemoteListOption ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: A OstreeRepo
    -> T.Text
    -- ^ /@remoteName@/: Name
    -> T.Text
    -- ^ /@optionName@/: Option
    -> m ([T.Text])
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoGetRemoteListOption :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Text -> m [Text]
repoGetRemoteListOption a
self Text
remoteName Text
optionName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    CString
optionName' <- Text -> IO CString
textToCString Text
optionName
    Ptr (Ptr CString)
outValue <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr CString))
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> Ptr (Ptr CString)
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_get_remote_list_option Ptr Repo
self' CString
remoteName' CString
optionName' Ptr (Ptr CString)
outValue
        Ptr CString
outValue' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CString)
outValue
        [Text]
outValue'' <- HasCallStack => Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
outValue'
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
outValue'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outValue'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
optionName'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CString)
outValue
        forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
outValue''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
optionName'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CString)
outValue
     )

#if defined(ENABLE_OVERLOADING)
data RepoGetRemoteListOptionMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ([T.Text])), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetRemoteListOptionMethodInfo a signature where
    overloadedMethod = repoGetRemoteListOption

instance O.OverloadedMethodInfo RepoGetRemoteListOptionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetRemoteListOption",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetRemoteListOption"
        })


#endif

-- method Repo::get_remote_option
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "option_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Option" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "default_value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Value returned if @option_name is not present"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Return location for value"
--                 , 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_repo_get_remote_option" ostree_repo_get_remote_option :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    CString ->                              -- option_name : TBasicType TUTF8
    CString ->                              -- default_value : TBasicType TUTF8
    Ptr CString ->                          -- out_value : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | OSTree remotes are represented by keyfile groups, formatted like:
-- @[remote \"remotename\"]@. This function returns a value named /@optionName@/
-- underneath that group, or /@defaultValue@/ if the remote exists but not the
-- option name.  If an error is returned, /@outValue@/ will be set to 'P.Nothing'.
-- 
-- /Since: 2016.5/
repoGetRemoteOption ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: A OstreeRepo
    -> T.Text
    -- ^ /@remoteName@/: Name
    -> T.Text
    -- ^ /@optionName@/: Option
    -> Maybe (T.Text)
    -- ^ /@defaultValue@/: Value returned if /@optionName@/ is not present
    -> m (T.Text)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoGetRemoteOption :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Text -> Maybe Text -> m Text
repoGetRemoteOption a
self Text
remoteName Text
optionName Maybe Text
defaultValue = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    CString
optionName' <- Text -> IO CString
textToCString Text
optionName
    CString
maybeDefaultValue <- case Maybe Text
defaultValue of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jDefaultValue -> do
            CString
jDefaultValue' <- Text -> IO CString
textToCString Text
jDefaultValue
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jDefaultValue'
    Ptr CString
outValue <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CString
-> Ptr CString
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_get_remote_option Ptr Repo
self' CString
remoteName' CString
optionName' CString
maybeDefaultValue Ptr CString
outValue
        CString
outValue' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outValue
        Text
outValue'' <- HasCallStack => CString -> IO Text
cstringToText CString
outValue'
        forall a. Ptr a -> IO ()
freeMem CString
outValue'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
optionName'
        forall a. Ptr a -> IO ()
freeMem CString
maybeDefaultValue
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outValue
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
outValue''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
optionName'
        forall a. Ptr a -> IO ()
freeMem CString
maybeDefaultValue
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outValue
     )

#if defined(ENABLE_OVERLOADING)
data RepoGetRemoteOptionMethodInfo
instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> m (T.Text)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoGetRemoteOptionMethodInfo a signature where
    overloadedMethod = repoGetRemoteOption

instance O.OverloadedMethodInfo RepoGetRemoteOptionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGetRemoteOption",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGetRemoteOption"
        })


#endif

-- method Repo::gpg_sign_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Data as a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "old_signatures"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Existing signatures to append to (or %NULL)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_id"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "NULL-terminated array of GPG keys."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "homedir"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GPG home directory, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_signatures"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "in case of success will contain signature"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable" , 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_repo_gpg_sign_data" ostree_repo_gpg_sign_data :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr GLib.Bytes.Bytes ->                 -- data : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr GLib.Bytes.Bytes ->                 -- old_signatures : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr CString ->                          -- key_id : TCArray True (-1) (-1) (TBasicType TUTF8)
    CString ->                              -- homedir : TBasicType TUTF8
    Ptr (Ptr GLib.Bytes.Bytes) ->           -- out_signatures : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Sign the given /@data@/ with the specified keys in /@keyId@/. Similar to
-- 'GI.OSTree.Objects.Repo.repoAddGpgSignatureSummary' but can be used on any
-- data.
-- 
-- You can use 'GI.OSTree.Objects.Repo.repoGpgVerifyData' to verify the signatures.
-- 
-- /Since: 2020.8/
repoGpgSignData ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Self
    -> GLib.Bytes.Bytes
    -- ^ /@data@/: Data as a t'GI.GLib.Structs.Bytes.Bytes'
    -> GLib.Bytes.Bytes
    -- ^ /@oldSignatures@/: Existing signatures to append to (or 'P.Nothing')
    -> [T.Text]
    -- ^ /@keyId@/: NULL-terminated array of GPG keys.
    -> Maybe (T.Text)
    -- ^ /@homedir@/: GPG home directory, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m (GLib.Bytes.Bytes)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoGpgSignData :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Bytes -> Bytes -> [Text] -> Maybe Text -> Maybe b -> m Bytes
repoGpgSignData a
self Bytes
data_ Bytes
oldSignatures [Text]
keyId Maybe Text
homedir Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Bytes
data_' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
data_
    Ptr Bytes
oldSignatures' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
oldSignatures
    Ptr CString
keyId' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
keyId
    CString
maybeHomedir <- case Maybe Text
homedir of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jHomedir -> do
            CString
jHomedir' <- Text -> IO CString
textToCString Text
jHomedir
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jHomedir'
    Ptr (Ptr Bytes)
outSignatures <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr Bytes
-> Ptr Bytes
-> Ptr CString
-> CString
-> Ptr (Ptr Bytes)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_gpg_sign_data Ptr Repo
self' Ptr Bytes
data_' Ptr Bytes
oldSignatures' Ptr CString
keyId' CString
maybeHomedir Ptr (Ptr Bytes)
outSignatures Ptr Cancellable
maybeCancellable
        Ptr Bytes
outSignatures' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Bytes)
outSignatures
        Bytes
outSignatures'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
outSignatures'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
data_
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
oldSignatures
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
maybeHomedir
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSignatures
        forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
outSignatures''
     ) (do
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
maybeHomedir
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSignatures
     )

#if defined(ENABLE_OVERLOADING)
data RepoGpgSignDataMethodInfo
instance (signature ~ (GLib.Bytes.Bytes -> GLib.Bytes.Bytes -> [T.Text] -> Maybe (T.Text) -> Maybe (b) -> m (GLib.Bytes.Bytes)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoGpgSignDataMethodInfo a signature where
    overloadedMethod = repoGpgSignData

instance O.OverloadedMethodInfo RepoGpgSignDataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGpgSignData",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGpgSignData"
        })


#endif

-- method Repo::gpg_verify_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Repository" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Data as a #GBytes" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signatures"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Signatures as a #GBytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyringdir"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Path to directory GPG keyrings; overrides built-in default if given"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "extra_keyring"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Path to additional keyring file (not a directory)"
--                 , 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
--               (TInterface
--                  Name { namespace = "OSTree" , name = "GpgVerifyResult" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_gpg_verify_data" ostree_repo_gpg_verify_data :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    Ptr GLib.Bytes.Bytes ->                 -- data : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr GLib.Bytes.Bytes ->                 -- signatures : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Gio.File.File ->                    -- keyringdir : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.File.File ->                    -- extra_keyring : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult)

-- | Verify /@signatures@/ for /@data@/ using GPG keys in the keyring for
-- /@remoteName@/, and return an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'.
-- 
-- The /@remoteName@/ parameter can be 'P.Nothing'. In that case it will do
-- the verifications using GPG keys in the keyrings of all remotes.
-- 
-- /Since: 2016.6/
repoGpgVerifyData ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) =>
    a
    -- ^ /@self@/: Repository
    -> Maybe (T.Text)
    -- ^ /@remoteName@/: Name of remote
    -> GLib.Bytes.Bytes
    -- ^ /@data@/: Data as a t'GI.GLib.Structs.Bytes.Bytes'
    -> GLib.Bytes.Bytes
    -- ^ /@signatures@/: Signatures as a t'GI.GLib.Structs.Bytes.Bytes'
    -> Maybe (b)
    -- ^ /@keyringdir@/: Path to directory GPG keyrings; overrides built-in default if given
    -> Maybe (c)
    -- ^ /@extraKeyring@/: Path to additional keyring file (not a directory)
    -> Maybe (d)
    -- ^ /@cancellable@/: Cancellable
    -> m OSTree.GpgVerifyResult.GpgVerifyResult
    -- ^ __Returns:__ an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'P.Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/
repoGpgVerifyData :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c,
 IsCancellable d) =>
a
-> Maybe Text
-> Bytes
-> Bytes
-> Maybe b
-> Maybe c
-> Maybe d
-> m GpgVerifyResult
repoGpgVerifyData a
self Maybe Text
remoteName Bytes
data_ Bytes
signatures Maybe b
keyringdir Maybe c
extraKeyring Maybe d
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeRemoteName <- case Maybe Text
remoteName of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jRemoteName -> do
            CString
jRemoteName' <- Text -> IO CString
textToCString Text
jRemoteName
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jRemoteName'
    Ptr Bytes
data_' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
data_
    Ptr Bytes
signatures' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
signatures
    Ptr File
maybeKeyringdir <- case Maybe b
keyringdir of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jKeyringdir -> do
            Ptr File
jKeyringdir' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jKeyringdir
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jKeyringdir'
    Ptr File
maybeExtraKeyring <- case Maybe c
extraKeyring of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jExtraKeyring -> do
            Ptr File
jExtraKeyring' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jExtraKeyring
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jExtraKeyring'
    Ptr Cancellable
maybeCancellable <- case Maybe d
cancellable of
        Maybe d
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just d
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr GpgVerifyResult
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr Bytes
-> Ptr Bytes
-> Ptr File
-> Ptr File
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr GpgVerifyResult)
ostree_repo_gpg_verify_data Ptr Repo
self' CString
maybeRemoteName Ptr Bytes
data_' Ptr Bytes
signatures' Ptr File
maybeKeyringdir Ptr File
maybeExtraKeyring Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoGpgVerifyData" Ptr GpgVerifyResult
result
        GpgVerifyResult
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr GpgVerifyResult -> GpgVerifyResult
OSTree.GpgVerifyResult.GpgVerifyResult) Ptr GpgVerifyResult
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
data_
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
signatures
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
keyringdir forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
extraKeyring forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe d
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeRemoteName
        forall (m :: * -> *) a. Monad m => a -> m a
return GpgVerifyResult
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeRemoteName
     )

#if defined(ENABLE_OVERLOADING)
data RepoGpgVerifyDataMethodInfo
instance (signature ~ (Maybe (T.Text) -> GLib.Bytes.Bytes -> GLib.Bytes.Bytes -> Maybe (b) -> Maybe (c) -> Maybe (d) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => O.OverloadedMethod RepoGpgVerifyDataMethodInfo a signature where
    overloadedMethod = repoGpgVerifyData

instance O.OverloadedMethodInfo RepoGpgVerifyDataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoGpgVerifyData",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoGpgVerifyData"
        })


#endif

-- method Repo::has_object
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_have_object"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if repository contains object"
--                 , 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_repo_has_object" ostree_repo_has_object :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr CInt ->                             -- out_have_object : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Set /@outHaveObject@/ to 'P.True' if /@self@/ contains the given object;
-- 'P.False' otherwise.
repoHasObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@checksum@/: ASCII SHA256 checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m (Bool)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoHasObject :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> ObjectType -> Text -> Maybe b -> m Bool
repoHasObject a
self ObjectType
objtype Text
checksum Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr CInt
outHaveObject <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr CInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_has_object Ptr Repo
self' CUInt
objtype' CString
checksum' Ptr CInt
outHaveObject Ptr Cancellable
maybeCancellable
        CInt
outHaveObject' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
outHaveObject
        let outHaveObject'' :: Bool
outHaveObject'' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
outHaveObject'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outHaveObject
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
outHaveObject''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outHaveObject
     )

#if defined(ENABLE_OVERLOADING)
data RepoHasObjectMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m (Bool)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoHasObjectMethodInfo a signature where
    overloadedMethod = repoHasObject

instance O.OverloadedMethodInfo RepoHasObjectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoHasObject",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoHasObject"
        })


#endif

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

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

-- | Calculate a hash value for the given open repository, suitable for use when
-- putting it into a hash table. It is an error to call this on an t'GI.OSTree.Objects.Repo.Repo'
-- which is not yet open, as a persistent hash value cannot be calculated until
-- the repository is open and the inode of its root directory has been loaded.
-- 
-- This function does no I\/O.
-- 
-- /Since: 2017.12/
repoHash ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> m Word32
    -- ^ __Returns:__ hash value for the t'GI.OSTree.Objects.Repo.Repo'
repoHash :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m Word32
repoHash a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Repo -> IO Word32
ostree_repo_hash Ptr Repo
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data RepoHashMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsRepo a) => O.OverloadedMethod RepoHashMethodInfo a signature where
    overloadedMethod = repoHash

instance O.OverloadedMethodInfo RepoHashMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoHash",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoHash"
        })


#endif

-- method Repo::import_object_from
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Destination repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Source repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "checksum" , 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_repo_import_object_from" ostree_repo_import_object_from :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Repo ->                             -- source : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Copy object named by /@objtype@/ and /@checksum@/ into /@self@/ from the
-- source repository /@source@/.  If both repositories are of the same
-- type and on the same filesystem, this will simply be a fast Unix
-- hard link operation.
-- 
-- Otherwise, a copy will be performed.
repoImportObjectFrom ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Destination repo
    -> b
    -- ^ /@source@/: Source repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@checksum@/: checksum
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoImportObjectFrom :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsRepo b, IsCancellable c) =>
a -> b -> ObjectType -> Text -> Maybe c -> m ()
repoImportObjectFrom a
self b
source ObjectType
objtype Text
checksum Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Repo
source' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
source
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr Repo
-> CUInt
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_import_object_from Ptr Repo
self' Ptr Repo
source' CUInt
objtype' CString
checksum' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
source
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoImportObjectFromMethodInfo
instance (signature ~ (b -> OSTree.Enums.ObjectType -> T.Text -> Maybe (c) -> m ()), MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoImportObjectFromMethodInfo a signature where
    overloadedMethod = repoImportObjectFrom

instance O.OverloadedMethodInfo RepoImportObjectFromMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoImportObjectFrom",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoImportObjectFrom"
        })


#endif

-- method Repo::import_object_from_with_trust
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Destination repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Source repo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "checksum" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "trusted"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "If %TRUE, assume the source repo is valid and trusted"
--                 , 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_repo_import_object_from_with_trust" ostree_repo_import_object_from_with_trust :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Repo ->                             -- source : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- checksum : TBasicType TUTF8
    CInt ->                                 -- trusted : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Copy object named by /@objtype@/ and /@checksum@/ into /@self@/ from the
-- source repository /@source@/. If /@trusted@/ is 'P.True' and both
-- repositories are of the same type and on the same filesystem,
-- this will simply be a fast Unix hard link operation.
-- 
-- Otherwise, a copy will be performed.
-- 
-- /Since: 2016.5/
repoImportObjectFromWithTrust ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Destination repo
    -> b
    -- ^ /@source@/: Source repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@checksum@/: checksum
    -> Bool
    -- ^ /@trusted@/: If 'P.True', assume the source repo is valid and trusted
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoImportObjectFromWithTrust :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsRepo b, IsCancellable c) =>
a -> b -> ObjectType -> Text -> Bool -> Maybe c -> m ()
repoImportObjectFromWithTrust a
self b
source ObjectType
objtype Text
checksum Bool
trusted Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Repo
source' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
source
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    let trusted' :: CInt
trusted' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
trusted
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr Repo
-> CUInt
-> CString
-> CInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_import_object_from_with_trust Ptr Repo
self' Ptr Repo
source' CUInt
objtype' CString
checksum' CInt
trusted' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
source
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoImportObjectFromWithTrustMethodInfo
instance (signature ~ (b -> OSTree.Enums.ObjectType -> T.Text -> Bool -> Maybe (c) -> m ()), MonadIO m, IsRepo a, IsRepo b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoImportObjectFromWithTrustMethodInfo a signature where
    overloadedMethod = repoImportObjectFromWithTrust

instance O.OverloadedMethodInfo RepoImportObjectFromWithTrustMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoImportObjectFromWithTrust",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoImportObjectFromWithTrust"
        })


#endif

-- method Repo::is_system
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "repo"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Repository" , 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 "ostree_repo_is_system" ostree_repo_is_system :: 
    Ptr Repo ->                             -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"})
    IO CInt

-- | /No description available in the introspection data./
repoIsSystem ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@repo@/: Repository
    -> m Bool
    -- ^ __Returns:__ 'P.True' if this repository is the root-owned system global repository
repoIsSystem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m Bool
repoIsSystem a
repo = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    CInt
result <- Ptr Repo -> IO CInt
ostree_repo_is_system Ptr Repo
repo'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data RepoIsSystemMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsRepo a) => O.OverloadedMethod RepoIsSystemMethodInfo a signature where
    overloadedMethod = repoIsSystem

instance O.OverloadedMethodInfo RepoIsSystemMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoIsSystem",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoIsSystem"
        })


#endif

-- method Repo::is_writable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

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

-- | Returns whether the repository is writable by the current user.
-- If the repository is not writable, the /@error@/ indicates why.
repoIsWritable ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoIsWritable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m ()
repoIsWritable a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr (Ptr GError) -> IO CInt
ostree_repo_is_writable Ptr Repo
self'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoIsWritableMethodInfo
instance (signature ~ (m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoIsWritableMethodInfo a signature where
    overloadedMethod = repoIsWritable

instance O.OverloadedMethodInfo RepoIsWritableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoIsWritable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoIsWritable"
        })


#endif

-- XXX Could not generate method Repo::list_collection_refs
-- Not implemented: GHashTable element of type TInterface (Name {namespace = "OSTree", name = "CollectionRef"}) unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoListCollectionRefsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "listCollectionRefs" Repo) => O.OverloadedMethod RepoListCollectionRefsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "listCollectionRefs" Repo) => O.OverloadedMethodInfo RepoListCollectionRefsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Repo::list_commit_objects_starting_with
-- Not implemented: GHashTable element of type TVariant unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoListCommitObjectsStartingWithMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "listCommitObjectsStartingWith" Repo) => O.OverloadedMethod RepoListCommitObjectsStartingWithMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "listCommitObjectsStartingWith" Repo) => O.OverloadedMethodInfo RepoListCommitObjectsStartingWithMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Repo::list_objects
-- Not implemented: GHashTable element of type TVariant unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoListObjectsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "listObjects" Repo) => O.OverloadedMethod RepoListObjectsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "listObjects" Repo) => O.OverloadedMethodInfo RepoListObjectsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Repo::list_refs
-- Not implemented: Hash table argument with transfer = Container? outAllRefs'
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoListRefsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "listRefs" Repo) => O.OverloadedMethod RepoListRefsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "listRefs" Repo) => O.OverloadedMethodInfo RepoListRefsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Repo::list_refs_ext
-- Not implemented: Hash table argument with transfer = Container? outAllRefs'
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoListRefsExtMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "listRefsExt" Repo) => O.OverloadedMethod RepoListRefsExtMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "listRefsExt" Repo) => O.OverloadedMethodInfo RepoListRefsExtMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Repo::list_static_delta_indexes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "out_indexes"
--           , argType = TPtrArray (TBasicType TUTF8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "String name of delta indexes (checksum)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferContainer
--           }
--       , 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_repo_list_static_delta_indexes" ostree_repo_list_static_delta_indexes :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr (Ptr (GPtrArray CString)) ->        -- out_indexes : TPtrArray (TBasicType TUTF8)
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function synchronously enumerates all static delta indexes in the
-- repository, returning its result in /@outIndexes@/.
-- 
-- /Since: 2020.8/
repoListStaticDeltaIndexes ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ([T.Text])
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoListStaticDeltaIndexes :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m [Text]
repoListStaticDeltaIndexes a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr (Ptr (GPtrArray CString))
outIndexes <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GPtrArray CString)))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr (Ptr (GPtrArray CString))
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_list_static_delta_indexes Ptr Repo
self' Ptr (Ptr (GPtrArray CString))
outIndexes Ptr Cancellable
maybeCancellable
        Ptr (GPtrArray CString)
outIndexes' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GPtrArray CString))
outIndexes
        [CString]
outIndexes'' <- forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray CString)
outIndexes'
        [Text]
outIndexes''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
cstringToText [CString]
outIndexes''
        forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray CString)
outIndexes'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray CString))
outIndexes
        forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
outIndexes'''
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray CString))
outIndexes
     )

#if defined(ENABLE_OVERLOADING)
data RepoListStaticDeltaIndexesMethodInfo
instance (signature ~ (Maybe (b) -> m ([T.Text])), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoListStaticDeltaIndexesMethodInfo a signature where
    overloadedMethod = repoListStaticDeltaIndexes

instance O.OverloadedMethodInfo RepoListStaticDeltaIndexesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoListStaticDeltaIndexes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoListStaticDeltaIndexes"
        })


#endif

-- method Repo::list_static_delta_names
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "out_deltas"
--           , argType = TPtrArray (TBasicType TUTF8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "String name of deltas (checksum-checksum.delta)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferContainer
--           }
--       , 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_repo_list_static_delta_names" ostree_repo_list_static_delta_names :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr (Ptr (GPtrArray CString)) ->        -- out_deltas : TPtrArray (TBasicType TUTF8)
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function synchronously enumerates all static deltas in the
-- repository, returning its result in /@outDeltas@/.
repoListStaticDeltaNames ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ([T.Text])
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoListStaticDeltaNames :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m [Text]
repoListStaticDeltaNames a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr (Ptr (GPtrArray CString))
outDeltas <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GPtrArray CString)))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr (Ptr (GPtrArray CString))
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_list_static_delta_names Ptr Repo
self' Ptr (Ptr (GPtrArray CString))
outDeltas Ptr Cancellable
maybeCancellable
        Ptr (GPtrArray CString)
outDeltas' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GPtrArray CString))
outDeltas
        [CString]
outDeltas'' <- forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray CString)
outDeltas'
        [Text]
outDeltas''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
cstringToText [CString]
outDeltas''
        forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray CString)
outDeltas'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray CString))
outDeltas
        forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
outDeltas'''
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray CString))
outDeltas
     )

#if defined(ENABLE_OVERLOADING)
data RepoListStaticDeltaNamesMethodInfo
instance (signature ~ (Maybe (b) -> m ([T.Text])), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoListStaticDeltaNamesMethodInfo a signature where
    overloadedMethod = repoListStaticDeltaNames

instance O.OverloadedMethodInfo RepoListStaticDeltaNamesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoListStaticDeltaNames",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoListStaticDeltaNames"
        })


#endif

-- method Repo::load_commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Commit checksum" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_commit"
--           , argType = TVariant
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Commit" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_state"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoCommitState" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Commit state" , 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_repo_load_commit" ostree_repo_load_commit :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr (Ptr GVariant) ->                   -- out_commit : TVariant
    Ptr CUInt ->                            -- out_state : TInterface (Name {namespace = "OSTree", name = "RepoCommitState"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | A version of 'GI.OSTree.Objects.Repo.repoLoadVariant' specialized to commits,
-- capable of returning extended state information.  Currently
-- the only extended state is 'GI.OSTree.Flags.RepoCommitStatePartial', which
-- means that only a sub-path of the commit is available.
repoLoadCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@checksum@/: Commit checksum
    -> m ((GVariant, [OSTree.Flags.RepoCommitState]))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoLoadCommit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> m (GVariant, [RepoCommitState])
repoLoadCommit a
self Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr (Ptr GVariant)
outCommit <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
    Ptr CUInt
outState <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr (Ptr GVariant)
-> Ptr CUInt
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_load_commit Ptr Repo
self' CString
checksum' Ptr (Ptr GVariant)
outCommit Ptr CUInt
outState
        Ptr GVariant
outCommit' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outCommit
        GVariant
outCommit'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outCommit'
        CUInt
outState' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
outState
        let outState'' :: [RepoCommitState]
outState'' = forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
outState'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outCommit
        forall a. Ptr a -> IO ()
freeMem Ptr CUInt
outState
        forall (m :: * -> *) a. Monad m => a -> m a
return (GVariant
outCommit'', [RepoCommitState]
outState'')
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outCommit
        forall a. Ptr a -> IO ()
freeMem Ptr CUInt
outState
     )

#if defined(ENABLE_OVERLOADING)
data RepoLoadCommitMethodInfo
instance (signature ~ (T.Text -> m ((GVariant, [OSTree.Flags.RepoCommitState]))), MonadIO m, IsRepo a) => O.OverloadedMethod RepoLoadCommitMethodInfo a signature where
    overloadedMethod = repoLoadCommit

instance O.OverloadedMethodInfo RepoLoadCommitMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoLoadCommit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoLoadCommit"
        })


#endif

-- method Repo::load_file
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_input"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "File content" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_file_info"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "FileInfo" }
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "File information" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_xattrs"
--           , argType = TVariant
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Extended attributes"
--                 , 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_repo_load_file" ostree_repo_load_file :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Ptr (Ptr Gio.FileInfo.FileInfo) ->      -- out_file_info : TInterface (Name {namespace = "Gio", name = "FileInfo"})
    Ptr (Ptr GVariant) ->                   -- out_xattrs : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Load content object, decomposing it into three parts: the actual
-- content (for regular files), the metadata, and extended attributes.
repoLoadFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@checksum@/: ASCII SHA256 checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ((Maybe Gio.InputStream.InputStream, Maybe Gio.FileInfo.FileInfo, Maybe GVariant))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoLoadFile :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> Text
-> Maybe b
-> m (Maybe InputStream, Maybe FileInfo, Maybe GVariant)
repoLoadFile a
self Text
checksum Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
    Ptr (Ptr FileInfo)
outFileInfo <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.FileInfo.FileInfo))
    Ptr (Ptr GVariant)
outXattrs <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr (Ptr InputStream)
-> Ptr (Ptr FileInfo)
-> Ptr (Ptr GVariant)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_load_file Ptr Repo
self' CString
checksum' Ptr (Ptr InputStream)
outInput Ptr (Ptr FileInfo)
outFileInfo Ptr (Ptr GVariant)
outXattrs Ptr Cancellable
maybeCancellable
        Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
        Maybe InputStream
maybeOutInput' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr InputStream
outInput' forall a b. (a -> b) -> a -> b
$ \Ptr InputStream
outInput'' -> do
            InputStream
outInput''' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput''
            forall (m :: * -> *) a. Monad m => a -> m a
return InputStream
outInput'''
        Ptr FileInfo
outFileInfo' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr FileInfo)
outFileInfo
        Maybe FileInfo
maybeOutFileInfo' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr FileInfo
outFileInfo' forall a b. (a -> b) -> a -> b
$ \Ptr FileInfo
outFileInfo'' -> do
            FileInfo
outFileInfo''' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr FileInfo -> FileInfo
Gio.FileInfo.FileInfo) Ptr FileInfo
outFileInfo''
            forall (m :: * -> *) a. Monad m => a -> m a
return FileInfo
outFileInfo'''
        Ptr GVariant
outXattrs' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outXattrs
        Maybe GVariant
maybeOutXattrs' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
outXattrs' forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
outXattrs'' -> do
            GVariant
outXattrs''' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outXattrs''
            forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
outXattrs'''
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
        forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe InputStream
maybeOutInput', Maybe FileInfo
maybeOutFileInfo', Maybe GVariant
maybeOutXattrs')
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr FileInfo)
outFileInfo
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outXattrs
     )

#if defined(ENABLE_OVERLOADING)
data RepoLoadFileMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ((Maybe Gio.InputStream.InputStream, Maybe Gio.FileInfo.FileInfo, Maybe GVariant))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoLoadFileMethodInfo a signature where
    overloadedMethod = repoLoadFile

instance O.OverloadedMethodInfo RepoLoadFileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoLoadFile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoLoadFile"
        })


#endif

-- method Repo::load_object_stream
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_input"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Stream for object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_size"
--           , argType = TBasicType TUInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Length of @out_input"
--                 , 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_repo_load_object_stream" ostree_repo_load_object_stream :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr (Ptr Gio.InputStream.InputStream) -> -- out_input : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Ptr Word64 ->                           -- out_size : TBasicType TUInt64
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Load object as a stream; useful when copying objects between
-- repositories.
repoLoadObjectStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@checksum@/: ASCII SHA256 checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ((Gio.InputStream.InputStream, Word64))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoLoadObjectStream :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> ObjectType -> Text -> Maybe b -> m (InputStream, Word64)
repoLoadObjectStream a
self ObjectType
objtype Text
checksum Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr (Ptr InputStream)
outInput <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.InputStream.InputStream))
    Ptr Word64
outSize <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr (Ptr InputStream)
-> Ptr Word64
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_load_object_stream Ptr Repo
self' CUInt
objtype' CString
checksum' Ptr (Ptr InputStream)
outInput Ptr Word64
outSize Ptr Cancellable
maybeCancellable
        Ptr InputStream
outInput' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr InputStream)
outInput
        InputStream
outInput'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
outInput'
        Word64
outSize' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outSize
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outSize
        forall (m :: * -> *) a. Monad m => a -> m a
return (InputStream
outInput'', Word64
outSize')
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr InputStream)
outInput
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outSize
     )

#if defined(ENABLE_OVERLOADING)
data RepoLoadObjectStreamMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m ((Gio.InputStream.InputStream, Word64))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoLoadObjectStreamMethodInfo a signature where
    overloadedMethod = repoLoadObjectStream

instance O.OverloadedMethodInfo RepoLoadObjectStreamMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoLoadObjectStream",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoLoadObjectStream"
        })


#endif

-- method Repo::load_variant
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Expected object type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sha256"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum string" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_variant"
--           , argType = TVariant
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Metadata object" , 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_repo_load_variant" ostree_repo_load_variant :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- sha256 : TBasicType TUTF8
    Ptr (Ptr GVariant) ->                   -- out_variant : TVariant
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Load the metadata object /@sha256@/ of type /@objtype@/, storing the
-- result in /@outVariant@/.
repoLoadVariant ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Expected object type
    -> T.Text
    -- ^ /@sha256@/: Checksum string
    -> m (GVariant)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoLoadVariant :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> ObjectType -> Text -> m GVariant
repoLoadVariant a
self ObjectType
objtype Text
sha256 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
sha256' <- Text -> IO CString
textToCString Text
sha256
    Ptr (Ptr GVariant)
outVariant <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr (Ptr GVariant)
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_load_variant Ptr Repo
self' CUInt
objtype' CString
sha256' Ptr (Ptr GVariant)
outVariant
        Ptr GVariant
outVariant' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outVariant
        GVariant
outVariant'' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outVariant'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outVariant
        forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
outVariant''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outVariant
     )

#if defined(ENABLE_OVERLOADING)
data RepoLoadVariantMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> m (GVariant)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoLoadVariantMethodInfo a signature where
    overloadedMethod = repoLoadVariant

instance O.OverloadedMethodInfo RepoLoadVariantMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoLoadVariant",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoLoadVariant"
        })


#endif

-- method Repo::load_variant_if_exists
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sha256"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII checksum" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_variant"
--           , argType = TVariant
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Metadata" , 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_repo_load_variant_if_exists" ostree_repo_load_variant_if_exists :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- sha256 : TBasicType TUTF8
    Ptr (Ptr GVariant) ->                   -- out_variant : TVariant
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Attempt to load the metadata object /@sha256@/ of type /@objtype@/ if it
-- exists, storing the result in /@outVariant@/.  If it doesn\'t exist,
-- /@outVariant@/ will be set to 'P.Nothing' and the function will still
-- return TRUE.
repoLoadVariantIfExists ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@sha256@/: ASCII checksum
    -> m ((Maybe GVariant))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoLoadVariantIfExists :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> ObjectType -> Text -> m (Maybe GVariant)
repoLoadVariantIfExists a
self ObjectType
objtype Text
sha256 = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
sha256' <- Text -> IO CString
textToCString Text
sha256
    Ptr (Ptr GVariant)
outVariant <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr (Ptr GVariant)
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_load_variant_if_exists Ptr Repo
self' CUInt
objtype' CString
sha256' Ptr (Ptr GVariant)
outVariant
        Ptr GVariant
outVariant' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outVariant
        Maybe GVariant
maybeOutVariant' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
outVariant' forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
outVariant'' -> do
            GVariant
outVariant''' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outVariant''
            forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
outVariant'''
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outVariant
        forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeOutVariant'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outVariant
     )

#if defined(ENABLE_OVERLOADING)
data RepoLoadVariantIfExistsMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> m ((Maybe GVariant))), MonadIO m, IsRepo a) => O.OverloadedMethod RepoLoadVariantIfExistsMethodInfo a signature where
    overloadedMethod = repoLoadVariantIfExists

instance O.OverloadedMethodInfo RepoLoadVariantIfExistsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoLoadVariantIfExists",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoLoadVariantIfExists"
        })


#endif

-- method Repo::lock_pop
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "lock_type"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoLockType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the type of lock to release"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , 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_repo_lock_pop" ostree_repo_lock_pop :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- lock_type : TInterface (Name {namespace = "OSTree", name = "RepoLockType"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Release a lock of type /@lockType@/ from the lock state. If the lock state
-- becomes empty, the repository is unlocked. Otherwise, the lock state only
-- changes when transitioning from an exclusive lock back to a shared lock. The
-- requested /@lockType@/ must be the same type that was requested in the call to
-- 'GI.OSTree.Objects.Repo.repoLockPush'. It is a programmer error if these do not match and
-- the program may abort if the lock would reach an invalid state.
-- 
-- 'GI.OSTree.Objects.Repo.repoLockPop' waits for the lock depending on the repository\'s
-- lock-timeout-secs configuration. When lock-timeout-secs is -1, a blocking lock is
-- attempted. Otherwise, the lock is removed non-blocking and
-- 'GI.OSTree.Objects.Repo.repoLockPop' will sleep synchronously up to lock-timeout-secs seconds
-- attempting to remove the lock. If the lock cannot be removed within the
-- timeout, a 'GI.Gio.Enums.IOErrorEnumWouldBlock' error is returned.
-- 
-- If /@self@/ is not writable by the user, then no unlocking is attempted and
-- 'P.True' is returned.
-- 
-- /Since: 2021.3/
repoLockPop ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: a t'GI.OSTree.Objects.Repo.Repo'
    -> OSTree.Enums.RepoLockType
    -- ^ /@lockType@/: the type of lock to release
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoLockPop :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> RepoLockType -> Maybe b -> m ()
repoLockPop a
self RepoLockType
lockType Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let lockType' :: CUInt
lockType' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoLockType
lockType
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_lock_pop Ptr Repo
self' CUInt
lockType' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoLockPopMethodInfo
instance (signature ~ (OSTree.Enums.RepoLockType -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoLockPopMethodInfo a signature where
    overloadedMethod = repoLockPop

instance O.OverloadedMethodInfo RepoLockPopMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoLockPop",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoLockPop"
        })


#endif

-- method Repo::lock_push
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "lock_type"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoLockType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the type of lock to acquire"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , 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_repo_lock_push" ostree_repo_lock_push :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- lock_type : TInterface (Name {namespace = "OSTree", name = "RepoLockType"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Takes a lock on the repository and adds it to the lock state. If /@lockType@/
-- is 'GI.OSTree.Enums.RepoLockTypeShared', a shared lock is taken. If /@lockType@/ is
-- 'GI.OSTree.Enums.RepoLockTypeExclusive', an exclusive lock is taken. The actual lock
-- state is only changed when locking a previously unlocked repository or
-- upgrading the lock from shared to exclusive. If the requested lock type is
-- unchanged or would represent a downgrade (exclusive to shared), the lock
-- state is not changed.
-- 
-- 'GI.OSTree.Objects.Repo.repoLockPush' waits for the lock depending on the repository\'s
-- lock-timeout-secs configuration. When lock-timeout-secs is -1, a blocking lock is
-- attempted. Otherwise, the lock is taken non-blocking and
-- 'GI.OSTree.Objects.Repo.repoLockPush' will sleep synchronously up to lock-timeout-secs seconds
-- attempting to acquire the lock. If the lock cannot be acquired within the
-- timeout, a 'GI.Gio.Enums.IOErrorEnumWouldBlock' error is returned.
-- 
-- If /@self@/ is not writable by the user, then no locking is attempted and
-- 'P.True' is returned.
-- 
-- /Since: 2021.3/
repoLockPush ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: a t'GI.OSTree.Objects.Repo.Repo'
    -> OSTree.Enums.RepoLockType
    -- ^ /@lockType@/: the type of lock to acquire
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoLockPush :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> RepoLockType -> Maybe b -> m ()
repoLockPush a
self RepoLockType
lockType Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let lockType' :: CUInt
lockType' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoLockType
lockType
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_lock_push Ptr Repo
self' CUInt
lockType' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoLockPushMethodInfo
instance (signature ~ (OSTree.Enums.RepoLockType -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoLockPushMethodInfo a signature where
    overloadedMethod = repoLockPush

instance O.OverloadedMethodInfo RepoLockPushMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoLockPush",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoLockPush"
        })


#endif

-- method Repo::mark_commit_partial
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Commit SHA-256" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_partial"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether or not this commit is partial"
--                 , 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_repo_mark_commit_partial" ostree_repo_mark_commit_partial :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- checksum : TBasicType TUTF8
    CInt ->                                 -- is_partial : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Commits in the \"partial\" state do not have all their child objects
-- written.  This occurs in various situations, such as during a pull,
-- but also if a \"subpath\" pull is used, as well as \"commit only\"
-- pulls.
-- 
-- This function is used by 'GI.OSTree.Objects.Repo.repoPullWithOptions'; you
-- should use this if you are implementing a different type of transport.
-- 
-- /Since: 2017.15/
repoMarkCommitPartial ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@checksum@/: Commit SHA-256
    -> Bool
    -- ^ /@isPartial@/: Whether or not this commit is partial
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoMarkCommitPartial :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Bool -> m ()
repoMarkCommitPartial a
self Text
checksum Bool
isPartial = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    let isPartial' :: CInt
isPartial' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
isPartial
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CString -> CInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_mark_commit_partial Ptr Repo
self' CString
checksum' CInt
isPartial'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoMarkCommitPartialMethodInfo
instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoMarkCommitPartialMethodInfo a signature where
    overloadedMethod = repoMarkCommitPartial

instance O.OverloadedMethodInfo RepoMarkCommitPartialMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoMarkCommitPartial",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoMarkCommitPartial"
        })


#endif

-- method Repo::mark_commit_partial_reason
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Commit SHA-256" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_partial"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether or not this commit is partial"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "in_state"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoCommitState" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Reason bitmask for partial commit"
--                 , 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_repo_mark_commit_partial_reason" ostree_repo_mark_commit_partial_reason :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- checksum : TBasicType TUTF8
    CInt ->                                 -- is_partial : TBasicType TBoolean
    CUInt ->                                -- in_state : TInterface (Name {namespace = "OSTree", name = "RepoCommitState"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Allows the setting of a reason code for a partial commit. Presently
-- it only supports setting reason bitmask to
-- OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL, or
-- OSTREE_REPO_COMMIT_STATE_NORMAL.  This will allow successive ostree
-- fsck operations to exit properly with an error code if the
-- repository has been truncated as a result of fsck trying to repair
-- it.
-- 
-- /Since: 2019.4/
repoMarkCommitPartialReason ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@checksum@/: Commit SHA-256
    -> Bool
    -- ^ /@isPartial@/: Whether or not this commit is partial
    -> [OSTree.Flags.RepoCommitState]
    -- ^ /@inState@/: Reason bitmask for partial commit
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoMarkCommitPartialReason :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Bool -> [RepoCommitState] -> m ()
repoMarkCommitPartialReason a
self Text
checksum Bool
isPartial [RepoCommitState]
inState = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    let isPartial' :: CInt
isPartial' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
isPartial
    let inState' :: CUInt
inState' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoCommitState]
inState
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CString -> CInt -> CUInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_mark_commit_partial_reason Ptr Repo
self' CString
checksum' CInt
isPartial' CUInt
inState'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoMarkCommitPartialReasonMethodInfo
instance (signature ~ (T.Text -> Bool -> [OSTree.Flags.RepoCommitState] -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoMarkCommitPartialReasonMethodInfo a signature where
    overloadedMethod = repoMarkCommitPartialReason

instance O.OverloadedMethodInfo RepoMarkCommitPartialReasonMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoMarkCommitPartialReason",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoMarkCommitPartialReason"
        })


#endif

-- method Repo::open
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "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_repo_open" ostree_repo_open :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | /No description available in the introspection data./
repoOpen ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -> Maybe (b)
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoOpen :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m ()
repoOpen a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_open Ptr Repo
self' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoOpenMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoOpenMethodInfo a signature where
    overloadedMethod = repoOpen

instance O.OverloadedMethodInfo RepoOpenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoOpen",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoOpen"
        })


#endif

-- method Repo::prepare_transaction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_transaction_resume"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Whether this transaction\nis resuming from a previous one.  This is a legacy state, now OSTree\npulls use per-commit `state/.commitpartial` files."
--                 , 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_repo_prepare_transaction" ostree_repo_prepare_transaction :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr CInt ->                             -- out_transaction_resume : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Starts or resumes a transaction. In order to write to a repo, you
-- need to start a transaction. You can complete the transaction with
-- 'GI.OSTree.Objects.Repo.repoCommitTransaction', or abort the transaction with
-- 'GI.OSTree.Objects.Repo.repoAbortTransaction'.
-- 
-- Currently, transactions may result in partial commits or data in the target
-- repository if interrupted during 'GI.OSTree.Objects.Repo.repoCommitTransaction', and
-- further writing refs is also not currently atomic.
-- 
-- There can be at most one transaction active on a repo at a time per instance
-- of @OstreeRepo@; however, it is safe to have multiple threads writing objects
-- on a single @OstreeRepo@ instance as long as their lifetime is bounded by the
-- transaction.
-- 
-- Locking: Acquires a @shared@ lock; release via commit or abort
-- Multithreading: This function is *not* MT safe; only one transaction can be
-- active at a time.
repoPrepareTransaction ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m (Bool)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPrepareTransaction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m Bool
repoPrepareTransaction a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CInt
outTransactionResume <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr CInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_prepare_transaction Ptr Repo
self' Ptr CInt
outTransactionResume Ptr Cancellable
maybeCancellable
        CInt
outTransactionResume' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
outTransactionResume
        let outTransactionResume'' :: Bool
outTransactionResume'' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
outTransactionResume'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outTransactionResume
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
outTransactionResume''
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outTransactionResume
     )

#if defined(ENABLE_OVERLOADING)
data RepoPrepareTransactionMethodInfo
instance (signature ~ (Maybe (b) -> m (Bool)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoPrepareTransactionMethodInfo a signature where
    overloadedMethod = repoPrepareTransaction

instance O.OverloadedMethodInfo RepoPrepareTransactionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPrepareTransaction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPrepareTransaction"
        })


#endif

-- method Repo::prune
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "flags"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoPruneFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Options controlling prune process"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "depth"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Stop traversal after this many iterations (-1 for unlimited)"
--                 , 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_repo_prune" ostree_repo_prune :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPruneFlags"})
    Int32 ->                                -- depth : TBasicType TInt
    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

-- | Delete content from the repository.  By default, this function will
-- only delete \"orphaned\" objects not referred to by any commit.  This
-- can happen during a local commit operation, when we have written
-- content objects but not saved the commit referencing them.
-- 
-- However, if 'GI.OSTree.Flags.RepoPruneFlagsRefsOnly' is provided, instead
-- of traversing all commits, only refs will be used.  Particularly
-- when combined with /@depth@/, this is a convenient way to delete
-- history from the repository.
-- 
-- Use the 'GI.OSTree.Flags.RepoPruneFlagsNoPrune' to just determine
-- statistics on objects that would be deleted, without actually
-- deleting them.
-- 
-- Locking: exclusive
repoPrune ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> [OSTree.Flags.RepoPruneFlags]
    -- ^ /@flags@/: Options controlling prune process
    -> Int32
    -- ^ /@depth@/: Stop traversal after this many iterations (-1 for unlimited)
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ((Int32, Int32, Word64))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPrune :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> [RepoPruneFlags] -> Int32 -> Maybe b -> m (Int32, Int32, Word64)
repoPrune a
self [RepoPruneFlags]
flags Int32
depth Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoPruneFlags]
flags
    Ptr Int32
outObjectsTotal <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
outObjectsPruned <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Word64
outPrunedObjectSizeTotal <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> Int32
-> Ptr Int32
-> Ptr Int32
-> Ptr Word64
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_prune Ptr Repo
self' CUInt
flags' Int32
depth Ptr Int32
outObjectsTotal Ptr Int32
outObjectsPruned Ptr Word64
outPrunedObjectSizeTotal Ptr Cancellable
maybeCancellable
        Int32
outObjectsTotal' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
outObjectsTotal
        Int32
outObjectsPruned' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
outObjectsPruned
        Word64
outPrunedObjectSizeTotal' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outPrunedObjectSizeTotal
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsTotal
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsPruned
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outPrunedObjectSizeTotal
        forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
outObjectsTotal', Int32
outObjectsPruned', Word64
outPrunedObjectSizeTotal')
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsTotal
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsPruned
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outPrunedObjectSizeTotal
     )

#if defined(ENABLE_OVERLOADING)
data RepoPruneMethodInfo
instance (signature ~ ([OSTree.Flags.RepoPruneFlags] -> Int32 -> Maybe (b) -> m ((Int32, Int32, Word64))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoPruneMethodInfo a signature where
    overloadedMethod = repoPrune

instance O.OverloadedMethodInfo RepoPruneMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPrune",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPrune"
        })


#endif

-- method Repo::prune_from_reachable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "options"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoPruneOptions" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Options controlling prune process"
--                 , 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_repo_prune_from_reachable" ostree_repo_prune_from_reachable :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    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

-- | Delete content from the repository.  This function is the \"backend\"
-- half of the higher level 'GI.OSTree.Objects.Repo.repoPrune'.  To use this function,
-- you determine the root set yourself, and this function finds all other
-- unreferenced objects and deletes them.
-- 
-- Use this API when you want to perform more selective pruning - for example,
-- retain all commits from a production branch, but just GC some history from
-- your dev branch.
-- 
-- The 'GI.OSTree.Flags.RepoPruneFlagsNoPrune' flag may be specified to just determine
-- statistics on objects that would be deleted, without actually deleting them.
-- 
-- Locking: exclusive
-- 
-- /Since: 2017.1/
repoPruneFromReachable ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.RepoPruneOptions.RepoPruneOptions
    -- ^ /@options@/: Options controlling prune process
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ((Int32, Int32, Word64))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPruneFromReachable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> RepoPruneOptions -> Maybe b -> m (Int32, Int32, Word64)
repoPruneFromReachable a
self RepoPruneOptions
options Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr RepoPruneOptions
options' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoPruneOptions
options
    Ptr Int32
outObjectsTotal <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
outObjectsPruned <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Word64
outPrunedObjectSizeTotal <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr RepoPruneOptions
-> Ptr Int32
-> Ptr Int32
-> Ptr Word64
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_prune_from_reachable Ptr Repo
self' Ptr RepoPruneOptions
options' Ptr Int32
outObjectsTotal Ptr Int32
outObjectsPruned Ptr Word64
outPrunedObjectSizeTotal Ptr Cancellable
maybeCancellable
        Int32
outObjectsTotal' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
outObjectsTotal
        Int32
outObjectsPruned' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
outObjectsPruned
        Word64
outPrunedObjectSizeTotal' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outPrunedObjectSizeTotal
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RepoPruneOptions
options
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsTotal
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsPruned
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outPrunedObjectSizeTotal
        forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
outObjectsTotal', Int32
outObjectsPruned', Word64
outPrunedObjectSizeTotal')
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsTotal
        forall a. Ptr a -> IO ()
freeMem Ptr Int32
outObjectsPruned
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outPrunedObjectSizeTotal
     )

#if defined(ENABLE_OVERLOADING)
data RepoPruneFromReachableMethodInfo
instance (signature ~ (OSTree.RepoPruneOptions.RepoPruneOptions -> Maybe (b) -> m ((Int32, Int32, Word64))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoPruneFromReachableMethodInfo a signature where
    overloadedMethod = repoPruneFromReachable

instance O.OverloadedMethodInfo RepoPruneFromReachableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPruneFromReachable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPruneFromReachable"
        })


#endif

-- method Repo::prune_static_deltas
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "ASCII SHA256 checksum for commit, or %NULL for each\nnon existing commit"
--                 , 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_repo_prune_static_deltas" ostree_repo_prune_static_deltas :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- commit : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Prune static deltas, if COMMIT is specified then delete static delta files only
-- targeting that commit; otherwise any static delta of non existing commits are
-- deleted.
-- 
-- Locking: exclusive
repoPruneStaticDeltas ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (T.Text)
    -- ^ /@commit@/: ASCII SHA256 checksum for commit, or 'P.Nothing' for each
    -- non existing commit
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPruneStaticDeltas :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe Text -> Maybe b -> m ()
repoPruneStaticDeltas a
self Maybe Text
commit Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeCommit <- case Maybe Text
commit of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jCommit -> do
            CString
jCommit' <- Text -> IO CString
textToCString Text
jCommit
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCommit'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_prune_static_deltas Ptr Repo
self' CString
maybeCommit Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeCommit
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeCommit
     )

#if defined(ENABLE_OVERLOADING)
data RepoPruneStaticDeltasMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoPruneStaticDeltasMethodInfo a signature where
    overloadedMethod = repoPruneStaticDeltas

instance O.OverloadedMethodInfo RepoPruneStaticDeltasMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPruneStaticDeltas",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPruneStaticDeltas"
        })


#endif

-- method Repo::pull
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "refs_to_fetch"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Optional list of refs; if %NULL, fetch all configured refs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoPullFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Options controlling fetch behavior"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "progress"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "AsyncProgress" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Progress" , 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_repo_pull" ostree_repo_pull :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    Ptr CString ->                          -- refs_to_fetch : TCArray True (-1) (-1) (TBasicType TUTF8)
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"})
    Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Connect to the remote repository, fetching the specified set of
-- refs /@refsToFetch@/.  For each ref that is changed, download the
-- commit, all metadata, and all content objects, storing them safely
-- on disk in /@self@/.
-- 
-- If /@flags@/ contains 'GI.OSTree.Flags.RepoPullFlagsMirror', and
-- the /@refsToFetch@/ is 'P.Nothing', and the remote repository contains a
-- summary file, then all refs will be fetched.
-- 
-- If /@flags@/ contains 'GI.OSTree.Flags.RepoPullFlagsCommitOnly', then only the
-- metadata for the commits in /@refsToFetch@/ is pulled.
-- 
-- Warning: This API will iterate the thread default main context,
-- which is a bug, but kept for compatibility reasons.  If you want to
-- avoid this, use 'GI.GLib.Structs.MainContext.mainContextPushThreadDefault' to push a new
-- one around this call.
repoPull ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@remoteName@/: Name of remote
    -> Maybe ([T.Text])
    -- ^ /@refsToFetch@/: Optional list of refs; if 'P.Nothing', fetch all configured refs
    -> [OSTree.Flags.RepoPullFlags]
    -- ^ /@flags@/: Options controlling fetch behavior
    -> Maybe (b)
    -- ^ /@progress@/: Progress
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPull :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b,
 IsCancellable c) =>
a
-> Text
-> Maybe [Text]
-> [RepoPullFlags]
-> Maybe b
-> Maybe c
-> m ()
repoPull a
self Text
remoteName Maybe [Text]
refsToFetch [RepoPullFlags]
flags Maybe b
progress Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    Ptr CString
maybeRefsToFetch <- case Maybe [Text]
refsToFetch of
        Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just [Text]
jRefsToFetch -> do
            Ptr CString
jRefsToFetch' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jRefsToFetch
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jRefsToFetch'
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoPullFlags]
flags
    Ptr AsyncProgress
maybeProgress <- case Maybe b
progress of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jProgress -> do
            Ptr AsyncProgress
jProgress' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jProgress
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AsyncProgress
jProgress'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr CString
-> CUInt
-> Ptr AsyncProgress
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_pull Ptr Repo
self' CString
remoteName' Ptr CString
maybeRefsToFetch CUInt
flags' Ptr AsyncProgress
maybeProgress Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
progress forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
     )

#if defined(ENABLE_OVERLOADING)
data RepoPullMethodInfo
instance (signature ~ (T.Text -> Maybe ([T.Text]) -> [OSTree.Flags.RepoPullFlags] -> Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoPullMethodInfo a signature where
    overloadedMethod = repoPull

instance O.OverloadedMethodInfo RepoPullMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPull",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPull"
        })


#endif

-- method Repo::pull_from_remotes_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "results"
--           , argType =
--               TCArray
--                 True
--                 (-1)
--                 (-1)
--                 (TInterface
--                    Name { namespace = "OSTree" , name = "RepoFinderResult" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%NULL-terminated array of remotes to\n   pull from, including the refs to pull from each"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A GVariant `a{sv}` with an extensible set of flags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "progress"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "AsyncProgress" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "an #OstreeAsyncProgress to update with the operation\8217s\n   progress, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "asynchronous completion callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 6
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to pass to @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_pull_from_remotes_async" ostree_repo_pull_from_remotes_async :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr (Ptr OSTree.RepoFinderResult.RepoFinderResult) -> -- results : TCArray True (-1) (-1) (TInterface (Name {namespace = "OSTree", name = "RepoFinderResult"}))
    Ptr GVariant ->                         -- options : TVariant
    Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    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 ()

-- | Pull refs from multiple remotes which have been found using
-- 'GI.OSTree.Objects.Repo.repoFindRemotesAsync'.
-- 
-- /@results@/ are expected to be in priority order, with the best remotes to pull
-- from listed first. 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync' will generally pull
-- from the remotes in order, but may parallelise its downloads.
-- 
-- If an error is encountered when pulling from a given remote, that remote will
-- be ignored and another will be tried instead. If any refs have not been
-- downloaded successfully after all remotes have been tried, 'GI.Gio.Enums.IOErrorEnumFailed'
-- will be returned. The results of any successful downloads will remain cached
-- in the local repository.
-- 
-- If /@cancellable@/ is cancelled, 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned
-- immediately. The results of any successfully completed downloads at that
-- point will remain cached in the local repository.
-- 
-- GPG verification of commits will be used unconditionally.
-- 
-- The following /@options@/ are currently defined:
-- 
--   * @flags@ (@i@): t'GI.OSTree.Flags.RepoPullFlags' to apply to the pull operation
--   * @inherit-transaction@ (@b@): 'P.True' to inherit an ongoing transaction on
--     the t'GI.OSTree.Objects.Repo.Repo', rather than encapsulating the pull in a new one
--   * @depth@ (@i@): How far in the history to traverse; default is 0, -1 means infinite
--   * @disable-static-deltas@ (@b@): Do not use static deltas
--   * @http-headers@ (@a(ss)@): Additional headers to add to all HTTP requests
--   * @subdirs@ (@as@): Pull just these subdirectories
--   * @update-frequency@ (@u@): Frequency to call the async progress callback in
--     milliseconds, if any; only values higher than 0 are valid
--   * @append-user-agent@ (@s@): Additional string to append to the user agent
--   * @n-network-retries@ (@u@): Number of times to retry each download on receiving
--     a transient network error, such as a socket timeout; default is 5, 0
--     means return errors without retrying. Since: 2018.6
--   * @ref-keyring-map@ (@a(sss)@): Array of (collection ID, ref name, keyring
--     remote name) tuples specifying which remote\'s keyring should be used when
--     doing GPG verification of each collection-ref. This is useful to prevent a
--     remote from serving malicious updates to refs which did not originate from
--     it. This can be a subset or superset of the refs being pulled; any ref
--     not being pulled will be ignored and any ref without a keyring remote
--     will be verified with the keyring of the remote being pulled from.
--     Since: 2019.2
-- 
-- /Since: 2018.6/
repoPullFromRemotesAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> [OSTree.RepoFinderResult.RepoFinderResult]
    -- ^ /@results@/: 'P.Nothing'-terminated array of remotes to
    --    pull from, including the refs to pull from each
    -> Maybe (GVariant)
    -- ^ /@options@/: A GVariant @a{sv}@ with an extensible set of flags
    -> Maybe (b)
    -- ^ /@progress@/: an t'GI.OSTree.Objects.AsyncProgress.AsyncProgress' to update with the operation’s
    --    progress, or 'P.Nothing'
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: asynchronous completion callback
    -> m ()
repoPullFromRemotesAsync :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b,
 IsCancellable c) =>
a
-> [RepoFinderResult]
-> Maybe GVariant
-> Maybe b
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
repoPullFromRemotesAsync a
self [RepoFinderResult]
results Maybe GVariant
options Maybe b
progress Maybe c
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    [Ptr RepoFinderResult]
results' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [RepoFinderResult]
results
    Ptr (Ptr RepoFinderResult)
results'' <- forall a. [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray [Ptr RepoFinderResult]
results'
    Ptr GVariant
maybeOptions <- case Maybe GVariant
options of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jOptions -> do
            Ptr GVariant
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jOptions
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jOptions'
    Ptr AsyncProgress
maybeProgress <- case Maybe b
progress of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jProgress -> do
            Ptr AsyncProgress
jProgress' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jProgress
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AsyncProgress
jProgress'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
    Ptr Repo
-> Ptr (Ptr RepoFinderResult)
-> Ptr GVariant
-> Ptr AsyncProgress
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ostree_repo_pull_from_remotes_async Ptr Repo
self' Ptr (Ptr RepoFinderResult)
results'' Ptr GVariant
maybeOptions Ptr AsyncProgress
maybeProgress Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [RepoFinderResult]
results
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
progress forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall a. Ptr a -> IO ()
freeMem Ptr (Ptr RepoFinderResult)
results''
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoPullFromRemotesAsyncMethodInfo
instance (signature ~ ([OSTree.RepoFinderResult.RepoFinderResult] -> Maybe (GVariant) -> Maybe (b) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoPullFromRemotesAsyncMethodInfo a signature where
    overloadedMethod = repoPullFromRemotesAsync

instance O.OverloadedMethodInfo RepoPullFromRemotesAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPullFromRemotesAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPullFromRemotesAsync"
        })


#endif

-- method Repo::pull_from_remotes_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , 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 "the asynchronous 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_repo_pull_from_remotes_finish" ostree_repo_pull_from_remotes_finish :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Finish an asynchronous pull operation started with
-- 'GI.OSTree.Objects.Repo.repoPullFromRemotesAsync'.
-- 
-- /Since: 2018.6/
repoPullFromRemotesFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> b
    -- ^ /@result@/: the asynchronous result
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPullFromRemotesFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) =>
a -> b -> m ()
repoPullFromRemotesFinish a
self b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
ostree_repo_pull_from_remotes_finish Ptr Repo
self' Ptr AsyncResult
result_'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoPullFromRemotesFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod RepoPullFromRemotesFinishMethodInfo a signature where
    overloadedMethod = repoPullFromRemotesFinish

instance O.OverloadedMethodInfo RepoPullFromRemotesFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPullFromRemotesFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPullFromRemotesFinish"
        })


#endif

-- method Repo::pull_one_dir
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dir_to_pull"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Subdirectory path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "refs_to_fetch"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Optional list of refs; if %NULL, fetch all configured refs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoPullFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Options controlling fetch behavior"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "progress"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "AsyncProgress" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Progress" , 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_repo_pull_one_dir" ostree_repo_pull_one_dir :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    CString ->                              -- dir_to_pull : TBasicType TUTF8
    Ptr CString ->                          -- refs_to_fetch : TCArray True (-1) (-1) (TBasicType TUTF8)
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoPullFlags"})
    Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This is similar to 'GI.OSTree.Objects.Repo.repoPull', but only fetches a single
-- subpath.
repoPullOneDir ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@remoteName@/: Name of remote
    -> T.Text
    -- ^ /@dirToPull@/: Subdirectory path
    -> Maybe ([T.Text])
    -- ^ /@refsToFetch@/: Optional list of refs; if 'P.Nothing', fetch all configured refs
    -> [OSTree.Flags.RepoPullFlags]
    -- ^ /@flags@/: Options controlling fetch behavior
    -> Maybe (b)
    -- ^ /@progress@/: Progress
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPullOneDir :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b,
 IsCancellable c) =>
a
-> Text
-> Text
-> Maybe [Text]
-> [RepoPullFlags]
-> Maybe b
-> Maybe c
-> m ()
repoPullOneDir a
self Text
remoteName Text
dirToPull Maybe [Text]
refsToFetch [RepoPullFlags]
flags Maybe b
progress Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    CString
dirToPull' <- Text -> IO CString
textToCString Text
dirToPull
    Ptr CString
maybeRefsToFetch <- case Maybe [Text]
refsToFetch of
        Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just [Text]
jRefsToFetch -> do
            Ptr CString
jRefsToFetch' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jRefsToFetch
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jRefsToFetch'
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoPullFlags]
flags
    Ptr AsyncProgress
maybeProgress <- case Maybe b
progress of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jProgress -> do
            Ptr AsyncProgress
jProgress' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jProgress
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AsyncProgress
jProgress'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> Ptr CString
-> CUInt
-> Ptr AsyncProgress
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_pull_one_dir Ptr Repo
self' CString
remoteName' CString
dirToPull' Ptr CString
maybeRefsToFetch CUInt
flags' Ptr AsyncProgress
maybeProgress Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
progress forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
dirToPull'
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem CString
dirToPull'
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeRefsToFetch
     )

#if defined(ENABLE_OVERLOADING)
data RepoPullOneDirMethodInfo
instance (signature ~ (T.Text -> T.Text -> Maybe ([T.Text]) -> [OSTree.Flags.RepoPullFlags] -> Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoPullOneDirMethodInfo a signature where
    overloadedMethod = repoPullOneDir

instance O.OverloadedMethodInfo RepoPullOneDirMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPullOneDir",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPullOneDir"
        })


#endif

-- method Repo::pull_with_options
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "remote_name_or_baseurl"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote or file:// url"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A GVariant a{sv} with an extensible set of flags."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "progress"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "AsyncProgress" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Progress" , 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_repo_pull_with_options" ostree_repo_pull_with_options :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name_or_baseurl : TBasicType TUTF8
    Ptr GVariant ->                         -- options : TVariant
    Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Like 'GI.OSTree.Objects.Repo.repoPull', but supports an extensible set of flags.
-- The following are currently defined:
-- 
--   * @refs@ (@as@): Array of string refs
--   * @collection-refs@ (@a(sss)@): Array of (collection ID, ref name, checksum) tuples to pull;
--     mutually exclusive with @refs@ and @override-commit-ids@. Checksums may be the empty
--     string to pull the latest commit for that ref
--   * @flags@ (@i@): An instance of t'GI.OSTree.Flags.RepoPullFlags'
--   * @subdir@ (@s@): Pull just this subdirectory
--   * @subdirs@ (@as@): Pull just these subdirectories
--   * @override-remote-name@ (@s@): If local, add this remote to refspec
--   * @gpg-verify@ (@b@): GPG verify commits
--   * @gpg-verify-summary@ (@b@): GPG verify summary
--   * @disable-sign-verify@ (@b@): Disable signapi verification of commits
--   * @disable-sign-verify-summary@ (@b@): Disable signapi verification of the summary
--   * @depth@ (@i@): How far in the history to traverse; default is 0, -1 means infinite
--   * @per-object-fsync@ (@b@): Perform disk writes more slowly, avoiding a single large I\/O sync
--   * @disable-static-deltas@ (@b@): Do not use static deltas
--   * @require-static-deltas@ (@b@): Require static deltas
--   * @override-commit-ids@ (@as@): Array of specific commit IDs to fetch for refs
--   * @timestamp-check@ (@b@): Verify commit timestamps are newer than current (when pulling via ref); Since: 2017.11
--   * @timestamp-check-from-rev@ (@s@): Verify that all fetched commit timestamps are newer than timestamp of given rev; Since: 2020.4
--   * @max-metadata-size@ (@t@): Restrict metadata objects to a maximum number of bytes; 0 to disable.  Since: 2018.9
--   * @dry-run@ (@b@): Only print information on what will be downloaded (requires static deltas)
--   * @override-url@ (@s@): Fetch objects from this URL if remote specifies no metalink in options
--   * @inherit-transaction@ (@b@): Don\'t initiate, finish or abort a transaction, useful to do multiple pulls in one transaction.
--   * @http-headers@ (@a(ss)@): Additional headers to add to all HTTP requests
--   * @update-frequency@ (@u@): Frequency to call the async progress callback in milliseconds, if any; only values higher than 0 are valid
--   * @localcache-repos@ (@as@): File paths for local repos to use as caches when doing remote fetches
--   * @append-user-agent@ (@s@): Additional string to append to the user agent
--   * @n-network-retries@ (@u@): Number of times to retry each download on receiving
--     a transient network error, such as a socket timeout; default is 5, 0
--     means return errors without retrying. Since: 2018.6
--   * @ref-keyring-map@ (@a(sss)@): Array of (collection ID, ref name, keyring
--     remote name) tuples specifying which remote\'s keyring should be used when
--     doing GPG verification of each collection-ref. This is useful to prevent a
--     remote from serving malicious updates to refs which did not originate from
--     it. This can be a subset or superset of the refs being pulled; any ref
--     not being pulled will be ignored and any ref without a keyring remote
--     will be verified with the keyring of the remote being pulled from.
--     Since: 2019.2
--   * @summary-bytes@ (@ay\'): Contents of the @summary@ file to use. If this is
--     specified, @summary-sig-bytes@ must also be specified. This is
--     useful if doing multiple pull operations in a transaction, using
--     ostree_repo_remote_fetch_summary_with_options() beforehand to download
--     the @summary@ and @summary.sig@ once for the entire transaction. If not
--     specified, the @summary@ will be downloaded from the remote. Since: 2020.5
--   * @summary-sig-bytes@ (@ay@): Contents of the @summary.sig@ file. If this
--     is specified, @summary-bytes@ must also be specified. Since: 2020.5
--   * @disable-verify-bindings@ (@b\`): Disable verification of commit bindings.
--     Since: 2020.9
repoPullWithOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@remoteNameOrBaseurl@/: Name of remote or file:\/\/ url
    -> GVariant
    -- ^ /@options@/: A GVariant a{sv} with an extensible set of flags.
    -> Maybe (b)
    -- ^ /@progress@/: Progress
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoPullWithOptions :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b,
 IsCancellable c) =>
a -> Text -> GVariant -> Maybe b -> Maybe c -> m ()
repoPullWithOptions a
self Text
remoteNameOrBaseurl GVariant
options Maybe b
progress Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteNameOrBaseurl' <- Text -> IO CString
textToCString Text
remoteNameOrBaseurl
    Ptr GVariant
options' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
options
    Ptr AsyncProgress
maybeProgress <- case Maybe b
progress of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jProgress -> do
            Ptr AsyncProgress
jProgress' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jProgress
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AsyncProgress
jProgress'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr GVariant
-> Ptr AsyncProgress
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_pull_with_options Ptr Repo
self' CString
remoteNameOrBaseurl' Ptr GVariant
options' Ptr AsyncProgress
maybeProgress Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
options
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
progress forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
remoteNameOrBaseurl'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteNameOrBaseurl'
     )

#if defined(ENABLE_OVERLOADING)
data RepoPullWithOptionsMethodInfo
instance (signature ~ (T.Text -> GVariant -> Maybe (b) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.AsyncProgress.IsAsyncProgress b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoPullWithOptionsMethodInfo a signature where
    overloadedMethod = repoPullWithOptions

instance O.OverloadedMethodInfo RepoPullWithOptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoPullWithOptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoPullWithOptions"
        })


#endif

-- method Repo::query_object_storage_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sha256"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Checksum" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_size"
--           , argType = TBasicType TUInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Size in bytes object occupies physically"
--                 , 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_repo_query_object_storage_size" ostree_repo_query_object_storage_size :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- sha256 : TBasicType TUTF8
    Ptr Word64 ->                           -- out_size : TBasicType TUInt64
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Return the size in bytes of object with checksum /@sha256@/, after any
-- compression has been applied.
repoQueryObjectStorageSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@sha256@/: Checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m (Word64)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoQueryObjectStorageSize :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> ObjectType -> Text -> Maybe b -> m Word64
repoQueryObjectStorageSize a
self ObjectType
objtype Text
sha256 Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
sha256' <- Text -> IO CString
textToCString Text
sha256
    Ptr Word64
outSize <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word64)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr Word64
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_query_object_storage_size Ptr Repo
self' CUInt
objtype' CString
sha256' Ptr Word64
outSize Ptr Cancellable
maybeCancellable
        Word64
outSize' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word64
outSize
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outSize
        forall (m :: * -> *) a. Monad m => a -> m a
return Word64
outSize'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
sha256'
        forall a. Ptr a -> IO ()
freeMem Ptr Word64
outSize
     )

#if defined(ENABLE_OVERLOADING)
data RepoQueryObjectStorageSizeMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> Maybe (b) -> m (Word64)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoQueryObjectStorageSizeMethodInfo a signature where
    overloadedMethod = repoQueryObjectStorageSize

instance O.OverloadedMethodInfo RepoQueryObjectStorageSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoQueryObjectStorageSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoQueryObjectStorageSize"
        })


#endif

-- method Repo::read_commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "ref"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Ref or ASCII checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_root"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepoFile corresponding to the root"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The resolved commit checksum"
--                 , 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_repo_read_commit" ostree_repo_read_commit :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- ref : TBasicType TUTF8
    Ptr (Ptr Gio.File.File) ->              -- out_root : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr CString ->                          -- out_commit : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Load the content for /@rev@/ into /@outRoot@/.
repoReadCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@ref@/: Ref or ASCII checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ((Gio.File.File, T.Text))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoReadCommit :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe b -> m (File, Text)
repoReadCommit a
self Text
ref Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
ref' <- Text -> IO CString
textToCString Text
ref
    Ptr (Ptr File)
outRoot <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.File.File))
    Ptr CString
outCommit <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr (Ptr File)
-> Ptr CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_read_commit Ptr Repo
self' CString
ref' Ptr (Ptr File)
outRoot Ptr CString
outCommit Ptr Cancellable
maybeCancellable
        Ptr File
outRoot' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr File)
outRoot
        File
outRoot'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr File -> File
Gio.File.File) Ptr File
outRoot'
        CString
outCommit' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outCommit
        Text
outCommit'' <- HasCallStack => CString -> IO Text
cstringToText CString
outCommit'
        forall a. Ptr a -> IO ()
freeMem CString
outCommit'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
ref'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr File)
outRoot
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outCommit
        forall (m :: * -> *) a. Monad m => a -> m a
return (File
outRoot'', Text
outCommit'')
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
ref'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr File)
outRoot
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outCommit
     )

#if defined(ENABLE_OVERLOADING)
data RepoReadCommitMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ((Gio.File.File, T.Text))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoReadCommitMethodInfo a signature where
    overloadedMethod = repoReadCommit

instance O.OverloadedMethodInfo RepoReadCommitMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoReadCommit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoReadCommit"
        })


#endif

-- method Repo::read_commit_detached_metadata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 commit checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_metadata"
--           , argType = TVariant
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Metadata associated with commit in with format \"a{sv}\", or %NULL if none exists"
--                 , 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_repo_read_commit_detached_metadata" ostree_repo_read_commit_detached_metadata :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr (Ptr GVariant) ->                   -- out_metadata : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | OSTree commits can have arbitrary metadata associated; this
-- function retrieves them.  If none exists, /@outMetadata@/ will be set
-- to 'P.Nothing'.
repoReadCommitDetachedMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@checksum@/: ASCII SHA256 commit checksum
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ((Maybe GVariant))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoReadCommitDetachedMetadata :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe b -> m (Maybe GVariant)
repoReadCommitDetachedMetadata a
self Text
checksum Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr (Ptr GVariant)
outMetadata <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GVariant))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr (Ptr GVariant)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_read_commit_detached_metadata Ptr Repo
self' CString
checksum' Ptr (Ptr GVariant)
outMetadata Ptr Cancellable
maybeCancellable
        Ptr GVariant
outMetadata' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GVariant)
outMetadata
        Maybe GVariant
maybeOutMetadata' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr GVariant
outMetadata' forall a b. (a -> b) -> a -> b
$ \Ptr GVariant
outMetadata'' -> do
            GVariant
outMetadata''' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
outMetadata''
            forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
outMetadata'''
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outMetadata
        forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GVariant
maybeOutMetadata'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GVariant)
outMetadata
     )

#if defined(ENABLE_OVERLOADING)
data RepoReadCommitDetachedMetadataMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ((Maybe GVariant))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoReadCommitDetachedMetadataMethodInfo a signature where
    overloadedMethod = repoReadCommitDetachedMetadata

instance O.OverloadedMethodInfo RepoReadCommitDetachedMetadataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoReadCommitDetachedMetadata",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoReadCommitDetachedMetadata"
        })


#endif

-- method Repo::regenerate_summary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "additional_metadata"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A GVariant of type a{sv}, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "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_repo_regenerate_summary" ostree_repo_regenerate_summary :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr GVariant ->                         -- additional_metadata : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | An OSTree repository can contain a high level \"summary\" file that
-- describes the available branches and other metadata.
-- 
-- If the timetable for making commits and updating the summary file is fairly
-- regular, setting the @ostree.summary.expires@ key in /@additionalMetadata@/
-- will aid clients in working out when to check for updates.
-- 
-- It is regenerated automatically after any ref is
-- added, removed, or updated if @core\/auto-update-summary@ is set.
-- 
-- If the @core\/collection-id@ key is set in the configuration, it will be
-- included as @/OSTREE_SUMMARY_COLLECTION_ID/@ in the summary file. Refs that
-- have associated collection IDs will be included in the generated summary
-- file, listed under the @/OSTREE_SUMMARY_COLLECTION_MAP/@ key. Collection IDs
-- and refs in @/OSTREE_SUMMARY_COLLECTION_MAP/@ are guaranteed to be in
-- lexicographic order.
-- 
-- Locking: shared (Prior to 2021.7, this was exclusive)
repoRegenerateSummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (GVariant)
    -- ^ /@additionalMetadata@/: A GVariant of type a{sv}, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRegenerateSummary :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe GVariant -> Maybe b -> m ()
repoRegenerateSummary a
self Maybe GVariant
additionalMetadata Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr GVariant
maybeAdditionalMetadata <- case Maybe GVariant
additionalMetadata of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jAdditionalMetadata -> do
            Ptr GVariant
jAdditionalMetadata' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jAdditionalMetadata
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jAdditionalMetadata'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr GVariant -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_regenerate_summary Ptr Repo
self' Ptr GVariant
maybeAdditionalMetadata Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
additionalMetadata forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoRegenerateSummaryMethodInfo
instance (signature ~ (Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoRegenerateSummaryMethodInfo a signature where
    overloadedMethod = repoRegenerateSummary

instance O.OverloadedMethodInfo RepoRegenerateSummaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRegenerateSummary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRegenerateSummary"
        })


#endif

-- method Repo::reload_config
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "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_repo_reload_config" ostree_repo_reload_config :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | By default, an t'GI.OSTree.Objects.Repo.Repo' will cache the remote configuration and its
-- own repo\/config data.  This API can be used to reload it.
-- 
-- /Since: 2017.2/
repoReloadConfig ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: repo
    -> Maybe (b)
    -- ^ /@cancellable@/: cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoReloadConfig :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m ()
repoReloadConfig a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_reload_config Ptr Repo
self' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoReloadConfigMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoReloadConfigMethodInfo a signature where
    overloadedMethod = repoReloadConfig

instance O.OverloadedMethodInfo RepoReloadConfigMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoReloadConfig",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoReloadConfig"
        })


#endif

-- method Repo::remote_add
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "url"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "URL for remote (if URL begins with metalink=, it will be used as such)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GVariant of type a{sv}"
--                 , 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_repo_remote_add" ostree_repo_remote_add :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- url : TBasicType TUTF8
    Ptr GVariant ->                         -- options : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Create a new remote named /@name@/ pointing to /@url@/.  If /@options@/ is
-- provided, then it will be mapped to t'GI.GLib.Structs.KeyFile.KeyFile' entries, where the
-- GVariant dictionary key is an option string, and the value is
-- mapped as follows:
--   * s: 'GI.GLib.Structs.KeyFile.keyFileSetString'
--   * b: 'GI.GLib.Structs.KeyFile.keyFileSetBoolean'
--   * as: 'GI.GLib.Structs.KeyFile.keyFileSetStringList'
repoRemoteAdd ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@name@/: Name of remote
    -> Maybe (T.Text)
    -- ^ /@url@/: URL for remote (if URL begins with metalink=, it will be used as such)
    -> Maybe (GVariant)
    -- ^ /@options@/: GVariant of type a{sv}
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteAdd :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe Text -> Maybe GVariant -> Maybe b -> m ()
repoRemoteAdd a
self Text
name Maybe Text
url Maybe GVariant
options Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
maybeUrl <- case Maybe Text
url of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jUrl -> do
            CString
jUrl' <- Text -> IO CString
textToCString Text
jUrl
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jUrl'
    Ptr GVariant
maybeOptions <- case Maybe GVariant
options of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jOptions -> do
            Ptr GVariant
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jOptions
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jOptions'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> Ptr GVariant
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_remote_add Ptr Repo
self' CString
name' CString
maybeUrl Ptr GVariant
maybeOptions Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem CString
maybeUrl
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem CString
maybeUrl
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteAddMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoRemoteAddMethodInfo a signature where
    overloadedMethod = repoRemoteAdd

instance O.OverloadedMethodInfo RepoRemoteAddMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteAdd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteAdd"
        })


#endif

-- method Repo::remote_change
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "sysroot"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "System root" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "changeop"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoRemoteChange" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Operation to perform"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "url"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "URL for remote (if URL begins with metalink=, it will be used as such)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GVariant of type a{sv}"
--                 , 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_repo_remote_change" ostree_repo_remote_change :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.File.File ->                    -- sysroot : TInterface (Name {namespace = "Gio", name = "File"})
    CUInt ->                                -- changeop : TInterface (Name {namespace = "OSTree", name = "RepoRemoteChange"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- url : TBasicType TUTF8
    Ptr GVariant ->                         -- options : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | A combined function handling the equivalent of
-- 'GI.OSTree.Objects.Repo.repoRemoteAdd', 'GI.OSTree.Objects.Repo.repoRemoteDelete', with more
-- options.
repoRemoteChange ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (b)
    -- ^ /@sysroot@/: System root
    -> OSTree.Enums.RepoRemoteChange
    -- ^ /@changeop@/: Operation to perform
    -> T.Text
    -- ^ /@name@/: Name of remote
    -> Maybe (T.Text)
    -- ^ /@url@/: URL for remote (if URL begins with metalink=, it will be used as such)
    -> Maybe (GVariant)
    -- ^ /@options@/: GVariant of type a{sv}
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteChange :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsCancellable c) =>
a
-> Maybe b
-> RepoRemoteChange
-> Text
-> Maybe Text
-> Maybe GVariant
-> Maybe c
-> m ()
repoRemoteChange a
self Maybe b
sysroot RepoRemoteChange
changeop Text
name Maybe Text
url Maybe GVariant
options Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
maybeSysroot <- case Maybe b
sysroot of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jSysroot -> do
            Ptr File
jSysroot' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSysroot
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jSysroot'
    let changeop' :: CUInt
changeop' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoRemoteChange
changeop
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
maybeUrl <- case Maybe Text
url of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jUrl -> do
            CString
jUrl' <- Text -> IO CString
textToCString Text
jUrl
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jUrl'
    Ptr GVariant
maybeOptions <- case Maybe GVariant
options of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jOptions -> do
            Ptr GVariant
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jOptions
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jOptions'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr File
-> CUInt
-> CString
-> CString
-> Ptr GVariant
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_remote_change Ptr Repo
self' Ptr File
maybeSysroot CUInt
changeop' CString
name' CString
maybeUrl Ptr GVariant
maybeOptions Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sysroot forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem CString
maybeUrl
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem CString
maybeUrl
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteChangeMethodInfo
instance (signature ~ (Maybe (b) -> OSTree.Enums.RepoRemoteChange -> T.Text -> Maybe (T.Text) -> Maybe (GVariant) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoRemoteChangeMethodInfo a signature where
    overloadedMethod = repoRemoteChange

instance O.OverloadedMethodInfo RepoRemoteChangeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteChange",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteChange"
        })


#endif

-- method Repo::remote_delete
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , 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_repo_remote_delete" ostree_repo_remote_delete :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Delete the remote named /@name@/.  It is an error if the provided
-- remote does not exist.
repoRemoteDelete ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@name@/: Name of remote
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteDelete :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe b -> m ()
repoRemoteDelete a
self Text
name Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_remote_delete Ptr Repo
self' CString
name' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteDeleteMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoRemoteDeleteMethodInfo a signature where
    overloadedMethod = repoRemoteDelete

instance O.OverloadedMethodInfo RepoRemoteDeleteMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteDelete",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteDelete"
        })


#endif

-- method Repo::remote_fetch_summary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of a remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_summary"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for raw summary data, or\n              %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_signatures"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for raw summary\n                 signature data, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , 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_repo_remote_fetch_summary" ostree_repo_remote_fetch_summary :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr (Ptr GLib.Bytes.Bytes) ->           -- out_summary : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr (Ptr GLib.Bytes.Bytes) ->           -- out_signatures : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Tries to fetch the summary file and any GPG signatures on the summary file
-- over HTTP, and returns the binary data in /@outSummary@/ and /@outSignatures@/
-- respectively.
-- 
-- If no summary file exists on the remote server, /@outSummary@/ is set to
-- /@nULL@/.  Likewise if the summary file is not signed, /@outSignatures@/ is
-- set to /@nULL@/.  In either case the function still returns 'P.True'.
-- 
-- This method does not verify the signature of the downloaded summary file.
-- Use 'GI.OSTree.Objects.Repo.repoVerifySummary' for that.
-- 
-- Parse the summary data into a t'GVariant' using 'GI.GLib.Structs.Variant.variantNewFromBytes'
-- with @/OSTREE_SUMMARY_GVARIANT_FORMAT/@ as the format string.
repoRemoteFetchSummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Self
    -> T.Text
    -- ^ /@name@/: name of a remote
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteFetchSummary :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe b -> m (Bytes, Bytes)
repoRemoteFetchSummary a
self Text
name Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr (Ptr Bytes)
outSummary <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
    Ptr (Ptr Bytes)
outSignatures <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr (Ptr Bytes)
-> Ptr (Ptr Bytes)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_remote_fetch_summary Ptr Repo
self' CString
name' Ptr (Ptr Bytes)
outSummary Ptr (Ptr Bytes)
outSignatures Ptr Cancellable
maybeCancellable
        Ptr Bytes
outSummary' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Bytes)
outSummary
        Bytes
outSummary'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
outSummary'
        Ptr Bytes
outSignatures' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Bytes)
outSignatures
        Bytes
outSignatures'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
outSignatures'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSummary
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSignatures
        forall (m :: * -> *) a. Monad m => a -> m a
return (Bytes
outSummary'', Bytes
outSignatures'')
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSummary
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSignatures
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteFetchSummaryMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoRemoteFetchSummaryMethodInfo a signature where
    overloadedMethod = repoRemoteFetchSummary

instance O.OverloadedMethodInfo RepoRemoteFetchSummaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteFetchSummary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteFetchSummary"
        })


#endif

-- method Repo::remote_fetch_summary_with_options
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of a remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A GVariant a{sv} with an extensible set of flags"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_summary"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for raw summary data, or\n              %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "out_signatures"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for raw summary\n                 signature data, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , 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_repo_remote_fetch_summary_with_options" ostree_repo_remote_fetch_summary_with_options :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr GVariant ->                         -- options : TVariant
    Ptr (Ptr GLib.Bytes.Bytes) ->           -- out_summary : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr (Ptr GLib.Bytes.Bytes) ->           -- out_signatures : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Like 'GI.OSTree.Objects.Repo.repoRemoteFetchSummary', but supports an extensible set of flags.
-- The following are currently defined:
-- 
-- * override-url (s): Fetch summary from this URL if remote specifies no metalink in options
-- * http-headers (a(ss)): Additional headers to add to all HTTP requests
-- * append-user-agent (s): Additional string to append to the user agent
-- * n-network-retries (u): Number of times to retry each download on receiving
-- a transient network error, such as a socket timeout; default is 5, 0
-- means return errors without retrying
-- 
-- 
-- /Since: 2016.6/
repoRemoteFetchSummaryWithOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Self
    -> T.Text
    -- ^ /@name@/: name of a remote
    -> Maybe (GVariant)
    -- ^ /@options@/: A GVariant a{sv} with an extensible set of flags
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteFetchSummaryWithOptions :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe GVariant -> Maybe b -> m (Bytes, Bytes)
repoRemoteFetchSummaryWithOptions a
self Text
name Maybe GVariant
options Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr GVariant
maybeOptions <- case Maybe GVariant
options of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jOptions -> do
            Ptr GVariant
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jOptions
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jOptions'
    Ptr (Ptr Bytes)
outSummary <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
    Ptr (Ptr Bytes)
outSignatures <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr GVariant
-> Ptr (Ptr Bytes)
-> Ptr (Ptr Bytes)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_remote_fetch_summary_with_options Ptr Repo
self' CString
name' Ptr GVariant
maybeOptions Ptr (Ptr Bytes)
outSummary Ptr (Ptr Bytes)
outSignatures Ptr Cancellable
maybeCancellable
        Ptr Bytes
outSummary' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Bytes)
outSummary
        Bytes
outSummary'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
outSummary'
        Ptr Bytes
outSignatures' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Bytes)
outSignatures
        Bytes
outSignatures'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
outSignatures'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSummary
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSignatures
        forall (m :: * -> *) a. Monad m => a -> m a
return (Bytes
outSummary'', Bytes
outSignatures'')
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSummary
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Bytes)
outSignatures
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteFetchSummaryWithOptionsMethodInfo
instance (signature ~ (T.Text -> Maybe (GVariant) -> Maybe (b) -> m ((GLib.Bytes.Bytes, GLib.Bytes.Bytes))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoRemoteFetchSummaryWithOptionsMethodInfo a signature where
    overloadedMethod = repoRemoteFetchSummaryWithOptions

instance O.OverloadedMethodInfo RepoRemoteFetchSummaryWithOptionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteFetchSummaryWithOptions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteFetchSummaryWithOptions"
        })


#endif

-- method Repo::remote_get_gpg_keys
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of the remote or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_ids"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "\n   a %NULL-terminated array of GPG key IDs to include, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_keys"
--           , argType = TPtrArray TVariant
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "\n   return location for a #GPtrArray of the remote's trusted GPG keys, or\n   %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferContainer
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_remote_get_gpg_keys" ostree_repo_remote_get_gpg_keys :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr CString ->                          -- key_ids : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr (Ptr (GPtrArray (Ptr GVariant))) -> -- out_keys : TPtrArray TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Enumerate the trusted GPG keys for the remote /@name@/. If /@name@/ is
-- 'P.Nothing', the global GPG keys will be returned. The keys will be
-- returned in the /@outKeys@/ t'GI.GLib.Structs.PtrArray.PtrArray'. Each element in the array is a
-- t'GVariant' of format @/OSTREE_GPG_KEY_GVARIANT_FORMAT/@. The /@keyIds@/
-- array can be used to limit which keys are included. If /@keyIds@/ is
-- 'P.Nothing', then all keys are included.
-- 
-- /Since: 2021.4/
repoRemoteGetGpgKeys ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (T.Text)
    -- ^ /@name@/: name of the remote or 'P.Nothing'
    -> Maybe ([T.Text])
    -- ^ /@keyIds@/: 
    --    a 'P.Nothing'-terminated array of GPG key IDs to include, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m ([GVariant])
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteGetGpgKeys :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe Text -> Maybe [Text] -> Maybe b -> m [GVariant]
repoRemoteGetGpgKeys a
self Maybe Text
name Maybe [Text]
keyIds Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeName <- case Maybe Text
name of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jName -> do
            CString
jName' <- Text -> IO CString
textToCString Text
jName
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jName'
    Ptr CString
maybeKeyIds <- case Maybe [Text]
keyIds of
        Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just [Text]
jKeyIds -> do
            Ptr CString
jKeyIds' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jKeyIds
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jKeyIds'
    Ptr (Ptr (GPtrArray (Ptr GVariant)))
outKeys <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GPtrArray (Ptr GVariant))))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr CString
-> Ptr (Ptr (GPtrArray (Ptr GVariant)))
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_remote_get_gpg_keys Ptr Repo
self' CString
maybeName Ptr CString
maybeKeyIds Ptr (Ptr (GPtrArray (Ptr GVariant)))
outKeys Ptr Cancellable
maybeCancellable
        Ptr (GPtrArray (Ptr GVariant))
outKeys' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GPtrArray (Ptr GVariant)))
outKeys
        [Ptr GVariant]
outKeys'' <- forall a. Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGPtrArray Ptr (GPtrArray (Ptr GVariant))
outKeys'
        [GVariant]
outKeys''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Ptr GVariant -> IO GVariant
B.GVariant.newGVariantFromPtr [Ptr GVariant]
outKeys''
        forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr GVariant))
outKeys'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeName
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray (Ptr GVariant)))
outKeys
        forall (m :: * -> *) a. Monad m => a -> m a
return [GVariant]
outKeys'''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeName
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GPtrArray (Ptr GVariant)))
outKeys
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteGetGpgKeysMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe ([T.Text]) -> Maybe (b) -> m ([GVariant])), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoRemoteGetGpgKeysMethodInfo a signature where
    overloadedMethod = repoRemoteGetGpgKeys

instance O.OverloadedMethodInfo RepoRemoteGetGpgKeysMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteGetGpgKeys",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteGetGpgKeys"
        })


#endif

-- method Repo::remote_get_gpg_verify
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_gpg_verify"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Remote's GPG option"
--                 , 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_repo_remote_get_gpg_verify" ostree_repo_remote_get_gpg_verify :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr CInt ->                             -- out_gpg_verify : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Return whether GPG verification is enabled for the remote named /@name@/
-- through /@outGpgVerify@/.  It is an error if the provided remote does
-- not exist.
repoRemoteGetGpgVerify ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@name@/: Name of remote
    -> m (Bool)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteGetGpgVerify :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> m Bool
repoRemoteGetGpgVerify a
self Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr CInt
outGpgVerify <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CString -> Ptr CInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_remote_get_gpg_verify Ptr Repo
self' CString
name' Ptr CInt
outGpgVerify
        CInt
outGpgVerify' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
outGpgVerify
        let outGpgVerify'' :: Bool
outGpgVerify'' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
outGpgVerify'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outGpgVerify
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
outGpgVerify''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outGpgVerify
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteGetGpgVerifyMethodInfo
instance (signature ~ (T.Text -> m (Bool)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoRemoteGetGpgVerifyMethodInfo a signature where
    overloadedMethod = repoRemoteGetGpgVerify

instance O.OverloadedMethodInfo RepoRemoteGetGpgVerifyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteGetGpgVerify",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteGetGpgVerify"
        })


#endif

-- method Repo::remote_get_gpg_verify_summary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_gpg_verify_summary"
--           , argType = TBasicType TBoolean
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Remote's GPG option"
--                 , 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_repo_remote_get_gpg_verify_summary" ostree_repo_remote_get_gpg_verify_summary :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr CInt ->                             -- out_gpg_verify_summary : TBasicType TBoolean
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Return whether GPG verification of the summary is enabled for the remote
-- named /@name@/ through /@outGpgVerifySummary@/.  It is an error if the provided
-- remote does not exist.
repoRemoteGetGpgVerifySummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@name@/: Name of remote
    -> m (Bool)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteGetGpgVerifySummary :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> m Bool
repoRemoteGetGpgVerifySummary a
self Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr CInt
outGpgVerifySummary <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CString -> Ptr CInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_remote_get_gpg_verify_summary Ptr Repo
self' CString
name' Ptr CInt
outGpgVerifySummary
        CInt
outGpgVerifySummary' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
outGpgVerifySummary
        let outGpgVerifySummary'' :: Bool
outGpgVerifySummary'' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
outGpgVerifySummary'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outGpgVerifySummary
        forall (m :: * -> *) a. Monad m => a -> m a
return Bool
outGpgVerifySummary''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr CInt
outGpgVerifySummary
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteGetGpgVerifySummaryMethodInfo
instance (signature ~ (T.Text -> m (Bool)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoRemoteGetGpgVerifySummaryMethodInfo a signature where
    overloadedMethod = repoRemoteGetGpgVerifySummary

instance O.OverloadedMethodInfo RepoRemoteGetGpgVerifySummaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteGetGpgVerifySummary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteGetGpgVerifySummary"
        })


#endif

-- method Repo::remote_get_url
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_url"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Remote's URL" , 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_repo_remote_get_url" ostree_repo_remote_get_url :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr CString ->                          -- out_url : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Return the URL of the remote named /@name@/ through /@outUrl@/.  It is an
-- error if the provided remote does not exist.
repoRemoteGetUrl ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@name@/: Name of remote
    -> m (T.Text)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteGetUrl :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> m Text
repoRemoteGetUrl a
self Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr CString
outUrl <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CString -> Ptr CString -> Ptr (Ptr GError) -> IO CInt
ostree_repo_remote_get_url Ptr Repo
self' CString
name' Ptr CString
outUrl
        CString
outUrl' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outUrl
        Text
outUrl'' <- HasCallStack => CString -> IO Text
cstringToText CString
outUrl'
        forall a. Ptr a -> IO ()
freeMem CString
outUrl'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outUrl
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
outUrl''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outUrl
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteGetUrlMethodInfo
instance (signature ~ (T.Text -> m (T.Text)), MonadIO m, IsRepo a) => O.OverloadedMethod RepoRemoteGetUrlMethodInfo a signature where
    overloadedMethod = repoRemoteGetUrl

instance O.OverloadedMethodInfo RepoRemoteGetUrlMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteGetUrl",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteGetUrl"
        })


#endif

-- method Repo::remote_gpg_import
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of a remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "source_stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GInputStream, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_ids"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a %NULL-terminated array of GPG key IDs, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_imported"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for the number of imported\n                             keys, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , 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_repo_remote_gpg_import" ostree_repo_remote_gpg_import :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Gio.InputStream.InputStream ->      -- source_stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Ptr CString ->                          -- key_ids : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr Word32 ->                           -- out_imported : TBasicType TUInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Imports one or more GPG keys from the open /@sourceStream@/, or from the
-- user\'s personal keyring if /@sourceStream@/ is 'P.Nothing'.  The /@keyIds@/ array
-- can optionally restrict which keys are imported.  If /@keyIds@/ is 'P.Nothing',
-- then all keys are imported.
-- 
-- The imported keys will be used to conduct GPG verification when pulling
-- from the remote named /@name@/.
repoRemoteGpgImport ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Self
    -> T.Text
    -- ^ /@name@/: name of a remote
    -> Maybe (b)
    -- ^ /@sourceStream@/: a t'GI.Gio.Objects.InputStream.InputStream', or 'P.Nothing'
    -> Maybe ([T.Text])
    -- ^ /@keyIds@/: a 'P.Nothing'-terminated array of GPG key IDs, or 'P.Nothing'
    -> Maybe (c)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m (Word32)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoRemoteGpgImport :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsInputStream b,
 IsCancellable c) =>
a -> Text -> Maybe b -> Maybe [Text] -> Maybe c -> m Word32
repoRemoteGpgImport a
self Text
name Maybe b
sourceStream Maybe [Text]
keyIds Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr InputStream
maybeSourceStream <- case Maybe b
sourceStream of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jSourceStream -> do
            Ptr InputStream
jSourceStream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSourceStream
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr InputStream
jSourceStream'
    Ptr CString
maybeKeyIds <- case Maybe [Text]
keyIds of
        Maybe [Text]
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just [Text]
jKeyIds -> do
            Ptr CString
jKeyIds' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jKeyIds
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jKeyIds'
    Ptr Word32
outImported <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr InputStream
-> Ptr CString
-> Ptr Word32
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_remote_gpg_import Ptr Repo
self' CString
name' Ptr InputStream
maybeSourceStream Ptr CString
maybeKeyIds Ptr Word32
outImported Ptr Cancellable
maybeCancellable
        Word32
outImported' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
outImported
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sourceStream forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr Word32
outImported
        forall (m :: * -> *) a. Monad m => a -> m a
return Word32
outImported'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
name'
        forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeKeyIds
        forall a. Ptr a -> IO ()
freeMem Ptr Word32
outImported
     )

#if defined(ENABLE_OVERLOADING)
data RepoRemoteGpgImportMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe ([T.Text]) -> Maybe (c) -> m (Word32)), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoRemoteGpgImportMethodInfo a signature where
    overloadedMethod = repoRemoteGpgImport

instance O.OverloadedMethodInfo RepoRemoteGpgImportMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteGpgImport",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteGpgImport"
        })


#endif

-- method Repo::remote_list
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "out_n_remotes"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Number of remotes available"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "out_n_remotes"
--              , argType = TBasicType TUInt
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "Number of remotes available"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TCArray False (-1) 1 (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_remote_list" ostree_repo_remote_list :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Word32 ->                           -- out_n_remotes : TBasicType TUInt
    IO (Ptr CString)

-- | List available remote names in an t'GI.OSTree.Objects.Repo.Repo'.  Remote names are sorted
-- alphabetically.  If no remotes are available the function returns 'P.Nothing'.
repoRemoteList ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> m [T.Text]
    -- ^ __Returns:__ a 'P.Nothing'-terminated
    --          array of remote names
repoRemoteList :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> m [Text]
repoRemoteList a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Word32
outNRemotes <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr CString
result <- Ptr Repo -> Ptr Word32 -> IO (Ptr CString)
ostree_repo_remote_list Ptr Repo
self' Ptr Word32
outNRemotes
    Word32
outNRemotes' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
outNRemotes
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoRemoteList" Ptr CString
result
    [Text]
result' <- (forall a.
(HasCallStack, Integral a) =>
a -> Ptr CString -> IO [Text]
unpackUTF8CArrayWithLength Word32
outNRemotes') Ptr CString
result
    (forall a b c.
(Storable a, Integral b) =>
b -> (a -> IO c) -> Ptr a -> IO ()
mapCArrayWithLength Word32
outNRemotes') forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem Ptr Word32
outNRemotes
    forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data RepoRemoteListMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsRepo a) => O.OverloadedMethod RepoRemoteListMethodInfo a signature where
    overloadedMethod = repoRemoteList

instance O.OverloadedMethodInfo RepoRemoteListMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoRemoteList",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoRemoteList"
        })


#endif

-- XXX Could not generate method Repo::remote_list_collection_refs
-- Not implemented: GHashTable element of type TInterface (Name {namespace = "OSTree", name = "CollectionRef"}) unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoRemoteListCollectionRefsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "remoteListCollectionRefs" Repo) => O.OverloadedMethod RepoRemoteListCollectionRefsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "remoteListCollectionRefs" Repo) => O.OverloadedMethodInfo RepoRemoteListCollectionRefsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Repo::remote_list_refs
-- Not implemented: Hash table argument with transfer = Container? outAllRefs'
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoRemoteListRefsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "remoteListRefs" Repo) => O.OverloadedMethod RepoRemoteListRefsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "remoteListRefs" Repo) => O.OverloadedMethodInfo RepoRemoteListRefsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Repo::resolve_collection_ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ref"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "CollectionRef" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a collection\8211ref to resolve"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "allow_noent"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE to not throw an error if @ref doesn\8217t exist"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoResolveRevExtFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "options controlling behaviour"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_rev"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return location for\n   the checksum corresponding to @ref, or %NULL if @allow_noent is %TRUE and\n   the @ref could not be found"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_resolve_collection_ref" ostree_repo_resolve_collection_ref :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr OSTree.CollectionRef.CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"})
    CInt ->                                 -- allow_noent : TBasicType TBoolean
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoResolveRevExtFlags"})
    Ptr CString ->                          -- out_rev : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Look up the checksum for the given collection–ref, returning it in /@outRev@/.
-- This will search through the mirrors and remote refs.
-- 
-- If /@allowNoent@/ is 'P.True' and the given /@ref@/ cannot be found, 'P.True' will be
-- returned and /@outRev@/ will be set to 'P.Nothing'. If /@allowNoent@/ is 'P.False' and
-- the given /@ref@/ cannot be found, a 'GI.Gio.Enums.IOErrorEnumNotFound' error will be
-- returned.
-- 
-- If you want to check only local refs, not remote or mirrored ones, use the
-- flag 'GI.OSTree.Flags.RepoResolveRevExtFlagsLocalOnly'. This is analogous to using
-- 'GI.OSTree.Objects.Repo.repoResolveRevExt' but for collection-refs.
-- 
-- /Since: 2018.6/
repoResolveCollectionRef ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> OSTree.CollectionRef.CollectionRef
    -- ^ /@ref@/: a collection–ref to resolve
    -> Bool
    -- ^ /@allowNoent@/: 'P.True' to not throw an error if /@ref@/ doesn’t exist
    -> [OSTree.Flags.RepoResolveRevExtFlags]
    -- ^ /@flags@/: options controlling behaviour
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m ((Maybe T.Text))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoResolveCollectionRef :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> CollectionRef
-> Bool
-> [RepoResolveRevExtFlags]
-> Maybe b
-> m (Maybe Text)
repoResolveCollectionRef a
self CollectionRef
ref Bool
allowNoent [RepoResolveRevExtFlags]
flags Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CollectionRef
ref' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectionRef
ref
    let allowNoent' :: CInt
allowNoent' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
allowNoent
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoResolveRevExtFlags]
flags
    Ptr CString
outRev <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr CollectionRef
-> CInt
-> CUInt
-> Ptr CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_resolve_collection_ref Ptr Repo
self' Ptr CollectionRef
ref' CInt
allowNoent' CUInt
flags' Ptr CString
outRev Ptr Cancellable
maybeCancellable
        CString
outRev' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outRev
        Maybe Text
maybeOutRev' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outRev' forall a b. (a -> b) -> a -> b
$ \CString
outRev'' -> do
            Text
outRev''' <- HasCallStack => CString -> IO Text
cstringToText CString
outRev''
            forall (m :: * -> *) a. Monad m => a -> m a
return Text
outRev'''
        forall a. Ptr a -> IO ()
freeMem CString
outRev'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectionRef
ref
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outRev
        forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeOutRev'
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outRev
     )

#if defined(ENABLE_OVERLOADING)
data RepoResolveCollectionRefMethodInfo
instance (signature ~ (OSTree.CollectionRef.CollectionRef -> Bool -> [OSTree.Flags.RepoResolveRevExtFlags] -> Maybe (b) -> m ((Maybe T.Text))), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoResolveCollectionRefMethodInfo a signature where
    overloadedMethod = repoResolveCollectionRef

instance O.OverloadedMethodInfo RepoResolveCollectionRefMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoResolveCollectionRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoResolveCollectionRef"
        })


#endif

-- method Repo::resolve_keyring_for_collection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "collection_id"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the collection ID to look up a keyring for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "OSTree" , name = "Remote" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_resolve_keyring_for_collection" ostree_repo_resolve_keyring_for_collection :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- collection_id : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr OSTree.Remote.Remote)

-- | Find the GPG keyring for the given /@collectionId@/, using the local
-- configuration from the given t'GI.OSTree.Objects.Repo.Repo'. This will search the configured
-- remotes for ones whose @collection-id@ key matches /@collectionId@/, and will
-- return the first matching remote.
-- 
-- If multiple remotes match and have different keyrings, a debug message will
-- be emitted, and the first result will be returned. It is expected that the
-- keyrings should match.
-- 
-- If no match can be found, a 'GI.Gio.Enums.IOErrorEnumNotFound' error will be returned.
-- 
-- /Since: 2018.6/
repoResolveKeyringForCollection ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> T.Text
    -- ^ /@collectionId@/: the collection ID to look up a keyring for
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m OSTree.Remote.Remote
    -- ^ __Returns:__ t'GI.OSTree.Structs.Remote.Remote' containing the GPG keyring for
    --    /@collectionId@/ /(Can throw 'Data.GI.Base.GError.GError')/
repoResolveKeyringForCollection :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe b -> m Remote
repoResolveKeyringForCollection a
self Text
collectionId Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
collectionId' <- Text -> IO CString
textToCString Text
collectionId
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Remote
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr Remote)
ostree_repo_resolve_keyring_for_collection Ptr Repo
self' CString
collectionId' Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoResolveKeyringForCollection" Ptr Remote
result
        Remote
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Remote -> Remote
OSTree.Remote.Remote) Ptr Remote
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
collectionId'
        forall (m :: * -> *) a. Monad m => a -> m a
return Remote
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
collectionId'
     )

#if defined(ENABLE_OVERLOADING)
data RepoResolveKeyringForCollectionMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m OSTree.Remote.Remote), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoResolveKeyringForCollectionMethodInfo a signature where
    overloadedMethod = repoResolveKeyringForCollection

instance O.OverloadedMethodInfo RepoResolveKeyringForCollectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoResolveKeyringForCollection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoResolveKeyringForCollection"
        })


#endif

-- method Repo::resolve_rev
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "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
--           }
--       , Arg
--           { argCName = "allow_noent"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Do not throw an error if refspec does not exist"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_rev"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A checksum,or %NULL if @allow_noent is true and it does not exist"
--                 , 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_repo_resolve_rev" ostree_repo_resolve_rev :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- refspec : TBasicType TUTF8
    CInt ->                                 -- allow_noent : TBasicType TBoolean
    Ptr CString ->                          -- out_rev : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Look up the given refspec, returning the checksum it references in
-- the parameter /@outRev@/. Will fall back on remote directory if cannot
-- find the given refspec in local.
repoResolveRev ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@refspec@/: A refspec
    -> Bool
    -- ^ /@allowNoent@/: Do not throw an error if refspec does not exist
    -> m ((Maybe T.Text))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoResolveRev :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Bool -> m (Maybe Text)
repoResolveRev a
self Text
refspec Bool
allowNoent = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
refspec' <- Text -> IO CString
textToCString Text
refspec
    let allowNoent' :: CInt
allowNoent' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
allowNoent
    Ptr CString
outRev <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString -> CInt -> Ptr CString -> Ptr (Ptr GError) -> IO CInt
ostree_repo_resolve_rev Ptr Repo
self' CString
refspec' CInt
allowNoent' Ptr CString
outRev
        CString
outRev' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outRev
        Maybe Text
maybeOutRev' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outRev' forall a b. (a -> b) -> a -> b
$ \CString
outRev'' -> do
            Text
outRev''' <- HasCallStack => CString -> IO Text
cstringToText CString
outRev''
            forall (m :: * -> *) a. Monad m => a -> m a
return Text
outRev'''
        forall a. Ptr a -> IO ()
freeMem CString
outRev'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
refspec'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outRev
        forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeOutRev'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
refspec'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outRev
     )

#if defined(ENABLE_OVERLOADING)
data RepoResolveRevMethodInfo
instance (signature ~ (T.Text -> Bool -> m ((Maybe T.Text))), MonadIO m, IsRepo a) => O.OverloadedMethod RepoResolveRevMethodInfo a signature where
    overloadedMethod = repoResolveRev

instance O.OverloadedMethodInfo RepoResolveRevMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoResolveRev",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoResolveRev"
        })


#endif

-- method Repo::resolve_rev_ext
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "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
--           }
--       , Arg
--           { argCName = "allow_noent"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Do not throw an error if refspec does not exist"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoResolveRevExtFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Options controlling behavior"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_rev"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A checksum,or %NULL if @allow_noent is true and it does not exist"
--                 , 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_repo_resolve_rev_ext" ostree_repo_resolve_rev_ext :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- refspec : TBasicType TUTF8
    CInt ->                                 -- allow_noent : TBasicType TBoolean
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoResolveRevExtFlags"})
    Ptr CString ->                          -- out_rev : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Look up the given refspec, returning the checksum it references in
-- the parameter /@outRev@/. Differently from 'GI.OSTree.Objects.Repo.repoResolveRev',
-- this will not fall back to searching through remote repos if a
-- local ref is specified but not found.
-- 
-- The flag 'GI.OSTree.Flags.RepoResolveRevExtFlagsLocalOnly' is implied so
-- using it has no effect.
-- 
-- /Since: 2016.7/
repoResolveRevExt ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@refspec@/: A refspec
    -> Bool
    -- ^ /@allowNoent@/: Do not throw an error if refspec does not exist
    -> [OSTree.Flags.RepoResolveRevExtFlags]
    -- ^ /@flags@/: Options controlling behavior
    -> m ((Maybe T.Text))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoResolveRevExt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Bool -> [RepoResolveRevExtFlags] -> m (Maybe Text)
repoResolveRevExt a
self Text
refspec Bool
allowNoent [RepoResolveRevExtFlags]
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
refspec' <- Text -> IO CString
textToCString Text
refspec
    let allowNoent' :: CInt
allowNoent' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
allowNoent
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoResolveRevExtFlags]
flags
    Ptr CString
outRev <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CInt
-> CUInt
-> Ptr CString
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_resolve_rev_ext Ptr Repo
self' CString
refspec' CInt
allowNoent' CUInt
flags' Ptr CString
outRev
        CString
outRev' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outRev
        Maybe Text
maybeOutRev' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outRev' forall a b. (a -> b) -> a -> b
$ \CString
outRev'' -> do
            Text
outRev''' <- HasCallStack => CString -> IO Text
cstringToText CString
outRev''
            forall (m :: * -> *) a. Monad m => a -> m a
return Text
outRev'''
        forall a. Ptr a -> IO ()
freeMem CString
outRev'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
refspec'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outRev
        forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeOutRev'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
refspec'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outRev
     )

#if defined(ENABLE_OVERLOADING)
data RepoResolveRevExtMethodInfo
instance (signature ~ (T.Text -> Bool -> [OSTree.Flags.RepoResolveRevExtFlags] -> m ((Maybe T.Text))), MonadIO m, IsRepo a) => O.OverloadedMethod RepoResolveRevExtMethodInfo a signature where
    overloadedMethod = repoResolveRevExt

instance O.OverloadedMethodInfo RepoResolveRevExtMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoResolveRevExt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoResolveRevExt"
        })


#endif

-- method Repo::scan_hardlinks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , 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_repo_scan_hardlinks" ostree_repo_scan_hardlinks :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function is deprecated in favor of using 'GI.OSTree.Structs.RepoDevInoCache.repoDevInoCacheNew',
-- which allows a precise mapping to be built up between hardlink checkout files
-- and their checksums between @ostree_repo_checkout_at()@ and
-- @ostree_repo_write_directory_to_mtree()@.
-- 
-- When invoking 'GI.OSTree.Objects.Repo.repoWriteDirectoryToMtree', it has to compute the
-- checksum of all files. If your commit contains hardlinks from a checkout,
-- this functions builds a mapping of device numbers and inodes to their
-- checksum.
-- 
-- There is an upfront cost to creating this mapping, as this will scan the
-- entire objects directory. If your commit is composed of mostly hardlinks to
-- existing ostree objects, then this will speed up considerably, so call it
-- before you call 'GI.OSTree.Objects.Repo.repoWriteDirectoryToMtree' or similar.  However,
-- 'GI.OSTree.Structs.RepoDevInoCache.repoDevInoCacheNew' is better as it avoids scanning all objects.
-- 
-- Multithreading: This function is *not* MT safe.
repoScanHardlinks ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoScanHardlinks :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe b -> m ()
repoScanHardlinks a
self Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
ostree_repo_scan_hardlinks Ptr Repo
self' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoScanHardlinksMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoScanHardlinksMethodInfo a signature where
    overloadedMethod = repoScanHardlinks

instance O.OverloadedMethodInfo RepoScanHardlinksMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoScanHardlinks",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoScanHardlinks"
        })


#endif

-- method Repo::set_alias_ref_immediate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A remote for the ref"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ref"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The ref to write" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The ref target to point it to, or %NULL to unset"
--                 , 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 "GCancellable" , 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_repo_set_alias_ref_immediate" ostree_repo_set_alias_ref_immediate :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote : TBasicType TUTF8
    CString ->                              -- ref : TBasicType TUTF8
    CString ->                              -- target : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Like 'GI.OSTree.Objects.Repo.repoSetRefImmediate', but creates an alias.
-- 
-- /Since: 2017.10/
repoSetAliasRefImmediate ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (T.Text)
    -- ^ /@remote@/: A remote for the ref
    -> T.Text
    -- ^ /@ref@/: The ref to write
    -> Maybe (T.Text)
    -- ^ /@target@/: The ref target to point it to, or 'P.Nothing' to unset
    -> Maybe (b)
    -- ^ /@cancellable@/: GCancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSetAliasRefImmediate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe Text -> Text -> Maybe Text -> Maybe b -> m ()
repoSetAliasRefImmediate a
self Maybe Text
remote Text
ref Maybe Text
target Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeRemote <- case Maybe Text
remote of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jRemote -> do
            CString
jRemote' <- Text -> IO CString
textToCString Text
jRemote
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jRemote'
    CString
ref' <- Text -> IO CString
textToCString Text
ref
    CString
maybeTarget <- case Maybe Text
target of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jTarget -> do
            CString
jTarget' <- Text -> IO CString
textToCString Text
jTarget
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jTarget'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_set_alias_ref_immediate Ptr Repo
self' CString
maybeRemote CString
ref' CString
maybeTarget Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeRemote
        forall a. Ptr a -> IO ()
freeMem CString
ref'
        forall a. Ptr a -> IO ()
freeMem CString
maybeTarget
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeRemote
        forall a. Ptr a -> IO ()
freeMem CString
ref'
        forall a. Ptr a -> IO ()
freeMem CString
maybeTarget
     )

#if defined(ENABLE_OVERLOADING)
data RepoSetAliasRefImmediateMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoSetAliasRefImmediateMethodInfo a signature where
    overloadedMethod = repoSetAliasRefImmediate

instance O.OverloadedMethodInfo RepoSetAliasRefImmediateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSetAliasRefImmediate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSetAliasRefImmediate"
        })


#endif

-- method Repo::set_cache_dir
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dfd"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "directory fd" , 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 "subpath in @dfd" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GCancellable" , 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_repo_set_cache_dir" ostree_repo_set_cache_dir :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Int32 ->                                -- dfd : TBasicType TInt
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Set a custom location for the cache directory used for e.g.
-- per-remote summary caches. Setting this manually is useful when
-- doing operations on a system repo as a user because you don\'t have
-- write permissions in the repo, where the cache is normally stored.
-- 
-- /Since: 2016.5/
repoSetCacheDir ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Int32
    -- ^ /@dfd@/: directory fd
    -> T.Text
    -- ^ /@path@/: subpath in /@dfd@/
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSetCacheDir :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Int32 -> Text -> Maybe b -> m ()
repoSetCacheDir a
self Int32
dfd Text
path Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Int32
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_set_cache_dir Ptr Repo
self' Int32
dfd CString
path' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
path'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
path'
     )

#if defined(ENABLE_OVERLOADING)
data RepoSetCacheDirMethodInfo
instance (signature ~ (Int32 -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoSetCacheDirMethodInfo a signature where
    overloadedMethod = repoSetCacheDir

instance O.OverloadedMethodInfo RepoSetCacheDirMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSetCacheDir",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSetCacheDir"
        })


#endif

-- method Repo::set_collection_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "collection_id"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "new collection ID, or %NULL to unset it"
--                 , 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_repo_set_collection_id" ostree_repo_set_collection_id :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- collection_id : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Set or clear the collection ID of this repository. See [collection IDs][collection-ids].
-- The update will be made in memory, but must be written out to the repository
-- configuration on disk using 'GI.OSTree.Objects.Repo.repoWriteConfig'.
-- 
-- /Since: 2018.6/
repoSetCollectionId ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: an t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (T.Text)
    -- ^ /@collectionId@/: new collection ID, or 'P.Nothing' to unset it
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSetCollectionId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Maybe Text -> m ()
repoSetCollectionId a
self Maybe Text
collectionId = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeCollectionId <- case Maybe Text
collectionId of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jCollectionId -> do
            CString
jCollectionId' <- Text -> IO CString
textToCString Text
jCollectionId
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jCollectionId'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> CString -> Ptr (Ptr GError) -> IO CInt
ostree_repo_set_collection_id Ptr Repo
self' CString
maybeCollectionId
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. Ptr a -> IO ()
freeMem CString
maybeCollectionId
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeCollectionId
     )

#if defined(ENABLE_OVERLOADING)
data RepoSetCollectionIdMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoSetCollectionIdMethodInfo a signature where
    overloadedMethod = repoSetCollectionId

instance O.OverloadedMethodInfo RepoSetCollectionIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSetCollectionId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSetCollectionId"
        })


#endif

-- method Repo::set_collection_ref_immediate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ref"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "CollectionRef" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The collection\8211ref to write"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The checksum to point it to, or %NULL to unset"
--                 , 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 "GCancellable" , 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_repo_set_collection_ref_immediate" ostree_repo_set_collection_ref_immediate :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr OSTree.CollectionRef.CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This is like 'GI.OSTree.Objects.Repo.repoTransactionSetCollectionRef', except it may be
-- invoked outside of a transaction.  This is presently safe for the
-- case where we\'re creating or overwriting an existing ref.
-- 
-- /Since: 2018.6/
repoSetCollectionRefImmediate ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> OSTree.CollectionRef.CollectionRef
    -- ^ /@ref@/: The collection–ref to write
    -> Maybe (T.Text)
    -- ^ /@checksum@/: The checksum to point it to, or 'P.Nothing' to unset
    -> Maybe (b)
    -- ^ /@cancellable@/: GCancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSetCollectionRefImmediate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> CollectionRef -> Maybe Text -> Maybe b -> m ()
repoSetCollectionRefImmediate a
self CollectionRef
ref Maybe Text
checksum Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CollectionRef
ref' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectionRef
ref
    CString
maybeChecksum <- case Maybe Text
checksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jChecksum -> do
            CString
jChecksum' <- Text -> IO CString
textToCString Text
jChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jChecksum'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr CollectionRef
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_set_collection_ref_immediate Ptr Repo
self' Ptr CollectionRef
ref' CString
maybeChecksum Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectionRef
ref
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeChecksum
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeChecksum
     )

#if defined(ENABLE_OVERLOADING)
data RepoSetCollectionRefImmediateMethodInfo
instance (signature ~ (OSTree.CollectionRef.CollectionRef -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoSetCollectionRefImmediateMethodInfo a signature where
    overloadedMethod = repoSetCollectionRefImmediate

instance O.OverloadedMethodInfo RepoSetCollectionRefImmediateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSetCollectionRefImmediate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSetCollectionRefImmediate"
        })


#endif

-- method Repo::set_disable_fsync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "disable_fsync"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "If %TRUE, do not fsync"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_set_disable_fsync" ostree_repo_set_disable_fsync :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CInt ->                                 -- disable_fsync : TBasicType TBoolean
    IO ()

-- | Disable requests to @/fsync()/@ to stable storage during commits.  This
-- option should only be used by build system tools which are creating
-- disposable virtual machines, or have higher level mechanisms for
-- ensuring data consistency.
repoSetDisableFsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Bool
    -- ^ /@disableFsync@/: If 'P.True', do not fsync
    -> m ()
repoSetDisableFsync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Bool -> m ()
repoSetDisableFsync a
self Bool
disableFsync = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let disableFsync' :: CInt
disableFsync' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
disableFsync
    Ptr Repo -> CInt -> IO ()
ostree_repo_set_disable_fsync Ptr Repo
self' CInt
disableFsync'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoSetDisableFsyncMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoSetDisableFsyncMethodInfo a signature where
    overloadedMethod = repoSetDisableFsync

instance O.OverloadedMethodInfo RepoSetDisableFsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSetDisableFsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSetDisableFsync"
        })


#endif

-- method Repo::set_ref_immediate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A remote for the ref"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ref"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The ref to write" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The checksum to point it to, or %NULL to unset"
--                 , 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 "GCancellable" , 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_repo_set_ref_immediate" ostree_repo_set_ref_immediate :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote : TBasicType TUTF8
    CString ->                              -- ref : TBasicType TUTF8
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This is like 'GI.OSTree.Objects.Repo.repoTransactionSetRef', except it may be
-- invoked outside of a transaction.  This is presently safe for the
-- case where we\'re creating or overwriting an existing ref.
-- 
-- Multithreading: This function is MT safe.
repoSetRefImmediate ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (T.Text)
    -- ^ /@remote@/: A remote for the ref
    -> T.Text
    -- ^ /@ref@/: The ref to write
    -> Maybe (T.Text)
    -- ^ /@checksum@/: The checksum to point it to, or 'P.Nothing' to unset
    -> Maybe (b)
    -- ^ /@cancellable@/: GCancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSetRefImmediate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Maybe Text -> Text -> Maybe Text -> Maybe b -> m ()
repoSetRefImmediate a
self Maybe Text
remote Text
ref Maybe Text
checksum Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeRemote <- case Maybe Text
remote of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jRemote -> do
            CString
jRemote' <- Text -> IO CString
textToCString Text
jRemote
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jRemote'
    CString
ref' <- Text -> IO CString
textToCString Text
ref
    CString
maybeChecksum <- case Maybe Text
checksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jChecksum -> do
            CString
jChecksum' <- Text -> IO CString
textToCString Text
jChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jChecksum'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_set_ref_immediate Ptr Repo
self' CString
maybeRemote CString
ref' CString
maybeChecksum Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeRemote
        forall a. Ptr a -> IO ()
freeMem CString
ref'
        forall a. Ptr a -> IO ()
freeMem CString
maybeChecksum
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeRemote
        forall a. Ptr a -> IO ()
freeMem CString
ref'
        forall a. Ptr a -> IO ()
freeMem CString
maybeChecksum
     )

#if defined(ENABLE_OVERLOADING)
data RepoSetRefImmediateMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoSetRefImmediateMethodInfo a signature where
    overloadedMethod = repoSetRefImmediate

instance O.OverloadedMethodInfo RepoSetRefImmediateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSetRefImmediate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSetRefImmediate"
        })


#endif

-- method Repo::sign_commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "SHA256 of given commit to sign"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_id"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Use this GPG key id"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "homedir"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GPG home directory, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable" , 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_repo_sign_commit" ostree_repo_sign_commit :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- commit_checksum : TBasicType TUTF8
    CString ->                              -- key_id : TBasicType TUTF8
    CString ->                              -- homedir : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Add a GPG signature to a commit.
repoSignCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Self
    -> T.Text
    -- ^ /@commitChecksum@/: SHA256 of given commit to sign
    -> T.Text
    -- ^ /@keyId@/: Use this GPG key id
    -> Maybe (T.Text)
    -- ^ /@homedir@/: GPG home directory, or 'P.Nothing'
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSignCommit :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Text -> Maybe Text -> Maybe b -> m ()
repoSignCommit a
self Text
commitChecksum Text
keyId Maybe Text
homedir Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
commitChecksum' <- Text -> IO CString
textToCString Text
commitChecksum
    CString
keyId' <- Text -> IO CString
textToCString Text
keyId
    CString
maybeHomedir <- case Maybe Text
homedir of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jHomedir -> do
            CString
jHomedir' <- Text -> IO CString
textToCString Text
jHomedir
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jHomedir'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_sign_commit Ptr Repo
self' CString
commitChecksum' CString
keyId' CString
maybeHomedir Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
        forall a. Ptr a -> IO ()
freeMem CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
maybeHomedir
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
        forall a. Ptr a -> IO ()
freeMem CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
maybeHomedir
     )

#if defined(ENABLE_OVERLOADING)
data RepoSignCommitMethodInfo
instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoSignCommitMethodInfo a signature where
    overloadedMethod = repoSignCommit

instance O.OverloadedMethodInfo RepoSignCommitMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSignCommit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSignCommit"
        })


#endif

-- method Repo::sign_delta
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Just "Self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "from_commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "From commit" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "to_commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "To commit" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key_id"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "homedir"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "homedir" , 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_repo_sign_delta" ostree_repo_sign_delta :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- from_commit : TBasicType TUTF8
    CString ->                              -- to_commit : TBasicType TUTF8
    CString ->                              -- key_id : TBasicType TUTF8
    CString ->                              -- homedir : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | This function is deprecated, sign the summary file instead.
-- Add a GPG signature to a static delta.
repoSignDelta ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Self
    -> T.Text
    -- ^ /@fromCommit@/: From commit
    -> T.Text
    -- ^ /@toCommit@/: To commit
    -> T.Text
    -- ^ /@keyId@/: key id
    -> T.Text
    -- ^ /@homedir@/: homedir
    -> Maybe (b)
    -- ^ /@cancellable@/: cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSignDelta :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Text -> Text -> Text -> Maybe b -> m ()
repoSignDelta a
self Text
fromCommit Text
toCommit Text
keyId Text
homedir Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
fromCommit' <- Text -> IO CString
textToCString Text
fromCommit
    CString
toCommit' <- Text -> IO CString
textToCString Text
toCommit
    CString
keyId' <- Text -> IO CString
textToCString Text
keyId
    CString
homedir' <- Text -> IO CString
textToCString Text
homedir
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_sign_delta Ptr Repo
self' CString
fromCommit' CString
toCommit' CString
keyId' CString
homedir' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
fromCommit'
        forall a. Ptr a -> IO ()
freeMem CString
toCommit'
        forall a. Ptr a -> IO ()
freeMem CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
homedir'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
fromCommit'
        forall a. Ptr a -> IO ()
freeMem CString
toCommit'
        forall a. Ptr a -> IO ()
freeMem CString
keyId'
        forall a. Ptr a -> IO ()
freeMem CString
homedir'
     )

#if defined(ENABLE_OVERLOADING)
data RepoSignDeltaMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoSignDeltaMethodInfo a signature where
    overloadedMethod = repoSignDelta

instance O.OverloadedMethodInfo RepoSignDeltaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSignDelta",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSignDelta"
        })


#endif

-- method Repo::signature_verify_commit_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit_data"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Commit object data (GVariant)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit_metadata"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Commit metadata (GVariant `a{sv}`), must contain at least one valid signature"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoVerifyFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Optionally disable GPG or signapi"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_results"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Textual description of results"
--                 , 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_repo_signature_verify_commit_data" ostree_repo_signature_verify_commit_data :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    Ptr GLib.Bytes.Bytes ->                 -- commit_data : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr GLib.Bytes.Bytes ->                 -- commit_metadata : TInterface (Name {namespace = "GLib", name = "Bytes"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "RepoVerifyFlags"})
    Ptr CString ->                          -- out_results : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Validate the commit data using the commit metadata which must
-- contain at least one valid signature.  If GPG and signapi are
-- both enabled, then both must find at least one valid signature.
repoSignatureVerifyCommitData ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@remoteName@/: Name of remote
    -> GLib.Bytes.Bytes
    -- ^ /@commitData@/: Commit object data (GVariant)
    -> GLib.Bytes.Bytes
    -- ^ /@commitMetadata@/: Commit metadata (GVariant @a{sv}@), must contain at least one valid signature
    -> [OSTree.Flags.RepoVerifyFlags]
    -- ^ /@flags@/: Optionally disable GPG or signapi
    -> m ((Maybe T.Text))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoSignatureVerifyCommitData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Bytes -> Bytes -> [RepoVerifyFlags] -> m (Maybe Text)
repoSignatureVerifyCommitData a
self Text
remoteName Bytes
commitData Bytes
commitMetadata [RepoVerifyFlags]
flags = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    Ptr Bytes
commitData' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
commitData
    Ptr Bytes
commitMetadata' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
commitMetadata
    let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [RepoVerifyFlags]
flags
    Ptr CString
outResults <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr Bytes
-> Ptr Bytes
-> CUInt
-> Ptr CString
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_signature_verify_commit_data Ptr Repo
self' CString
remoteName' Ptr Bytes
commitData' Ptr Bytes
commitMetadata' CUInt
flags' Ptr CString
outResults
        CString
outResults' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outResults
        Maybe Text
maybeOutResults' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outResults' forall a b. (a -> b) -> a -> b
$ \CString
outResults'' -> do
            Text
outResults''' <- HasCallStack => CString -> IO Text
cstringToText CString
outResults''
            forall (m :: * -> *) a. Monad m => a -> m a
return Text
outResults'''
        forall a. Ptr a -> IO ()
freeMem CString
outResults'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
commitData
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
commitMetadata
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outResults
        forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeOutResults'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outResults
     )

#if defined(ENABLE_OVERLOADING)
data RepoSignatureVerifyCommitDataMethodInfo
instance (signature ~ (T.Text -> GLib.Bytes.Bytes -> GLib.Bytes.Bytes -> [OSTree.Flags.RepoVerifyFlags] -> m ((Maybe T.Text))), MonadIO m, IsRepo a) => O.OverloadedMethod RepoSignatureVerifyCommitDataMethodInfo a signature where
    overloadedMethod = repoSignatureVerifyCommitData

instance O.OverloadedMethodInfo RepoSignatureVerifyCommitDataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoSignatureVerifyCommitData",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoSignatureVerifyCommitData"
        })


#endif

-- method Repo::static_delta_execute_offline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "dir_or_file"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Path to a directory containing static delta data, or directly to the superblock"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "skip_validation"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "If %TRUE, assume data integrity"
--                 , 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_repo_static_delta_execute_offline" ostree_repo_static_delta_execute_offline :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.File.File ->                    -- dir_or_file : TInterface (Name {namespace = "Gio", name = "File"})
    CInt ->                                 -- skip_validation : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Given a directory representing an already-downloaded static delta
-- on disk, apply it, generating a new commit.  The directory must be
-- named with the form \"FROM-TO\", where both are checksums, and it
-- must contain a file named \"superblock\", along with at least one part.
repoStaticDeltaExecuteOffline ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> b
    -- ^ /@dirOrFile@/: Path to a directory containing static delta data, or directly to the superblock
    -> Bool
    -- ^ /@skipValidation@/: If 'P.True', assume data integrity
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoStaticDeltaExecuteOffline :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsCancellable c) =>
a -> b -> Bool -> Maybe c -> m ()
repoStaticDeltaExecuteOffline a
self b
dirOrFile Bool
skipValidation Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
dirOrFile' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dirOrFile
    let skipValidation' :: CInt
skipValidation' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
skipValidation
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr File
-> CInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_static_delta_execute_offline Ptr Repo
self' Ptr File
dirOrFile' CInt
skipValidation' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dirOrFile
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoStaticDeltaExecuteOfflineMethodInfo
instance (signature ~ (b -> Bool -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoStaticDeltaExecuteOfflineMethodInfo a signature where
    overloadedMethod = repoStaticDeltaExecuteOffline

instance O.OverloadedMethodInfo RepoStaticDeltaExecuteOfflineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoStaticDeltaExecuteOffline",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoStaticDeltaExecuteOffline"
        })


#endif

-- method Repo::static_delta_execute_offline_with_signature
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "dir_or_file"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Path to a directory containing static delta data, or directly to the superblock"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sign"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Sign" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Signature engine used to check superblock"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "skip_validation"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "If %TRUE, assume data integrity"
--                 , 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_repo_static_delta_execute_offline_with_signature" ostree_repo_static_delta_execute_offline_with_signature :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.File.File ->                    -- dir_or_file : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr OSTree.Sign.Sign ->                 -- sign : TInterface (Name {namespace = "OSTree", name = "Sign"})
    CInt ->                                 -- skip_validation : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Given a directory representing an already-downloaded static delta
-- on disk, apply it, generating a new commit.
-- If sign is passed, the static delta signature is verified.
-- If sign-verify-deltas configuration option is set and static delta is signed,
-- signature verification will be mandatory before apply the static delta.
-- The directory must be named with the form \"FROM-TO\", where both are
-- checksums, and it must contain a file named \"superblock\", along with at least
-- one part.
-- 
-- /Since: 2020.7/
repoStaticDeltaExecuteOfflineWithSignature ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.Sign.IsSign c, Gio.Cancellable.IsCancellable d) =>
    a
    -- ^ /@self@/: Repo
    -> b
    -- ^ /@dirOrFile@/: Path to a directory containing static delta data, or directly to the superblock
    -> c
    -- ^ /@sign@/: Signature engine used to check superblock
    -> Bool
    -- ^ /@skipValidation@/: If 'P.True', assume data integrity
    -> Maybe (d)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoStaticDeltaExecuteOfflineWithSignature :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsSign c,
 IsCancellable d) =>
a -> b -> c -> Bool -> Maybe d -> m ()
repoStaticDeltaExecuteOfflineWithSignature a
self b
dirOrFile c
sign Bool
skipValidation Maybe d
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
dirOrFile' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dirOrFile
    Ptr Sign
sign' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
sign
    let skipValidation' :: CInt
skipValidation' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
skipValidation
    Ptr Cancellable
maybeCancellable <- case Maybe d
cancellable of
        Maybe d
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just d
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr File
-> Ptr Sign
-> CInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_static_delta_execute_offline_with_signature Ptr Repo
self' Ptr File
dirOrFile' Ptr Sign
sign' CInt
skipValidation' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dirOrFile
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
sign
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe d
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoStaticDeltaExecuteOfflineWithSignatureMethodInfo
instance (signature ~ (b -> c -> Bool -> Maybe (d) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.Sign.IsSign c, Gio.Cancellable.IsCancellable d) => O.OverloadedMethod RepoStaticDeltaExecuteOfflineWithSignatureMethodInfo a signature where
    overloadedMethod = repoStaticDeltaExecuteOfflineWithSignature

instance O.OverloadedMethodInfo RepoStaticDeltaExecuteOfflineWithSignatureMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoStaticDeltaExecuteOfflineWithSignature",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoStaticDeltaExecuteOfflineWithSignature"
        })


#endif

-- method Repo::static_delta_generate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "opt"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "StaticDeltaGenerateOpt" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "High level optimization choice"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "from"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum of origin, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "to"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum of target"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "metadata"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Optional metadata" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "params"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Parameters, see below"
--                 , 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_repo_static_delta_generate" ostree_repo_static_delta_generate :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- opt : TInterface (Name {namespace = "OSTree", name = "StaticDeltaGenerateOpt"})
    CString ->                              -- from : TBasicType TUTF8
    CString ->                              -- to : TBasicType TUTF8
    Ptr GVariant ->                         -- metadata : TVariant
    Ptr GVariant ->                         -- params : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Generate a lookaside \"static delta\" from /@from@/ ('P.Nothing' means
-- from-empty) which can generate the objects in /@to@/.  This delta is
-- an optimization over fetching individual objects, and can be
-- conveniently stored and applied offline.
-- 
-- The /@params@/ argument should be an a{sv}.  The following attributes
-- are known:
--   - min-fallback-size: u: Minimum uncompressed size in megabytes to use fallback, 0 to disable fallbacks
--   - max-chunk-size: u: Maximum size in megabytes of a delta part
--   - max-bsdiff-size: u: Maximum size in megabytes to consider bsdiff compression
--   for input files
--   - compression: y: Compression type: 0=none, x=lzma, g=gzip
--   - bsdiff-enabled: b: Enable bsdiff compression.  Default TRUE.
--   - inline-parts: b: Put part data in header, to get a single file delta.  Default FALSE.
--   - verbose: b: Print diagnostic messages.  Default FALSE.
--   - endianness: b: Deltas use host byte order by default; this option allows choosing (G_BIG_ENDIAN or G_LITTLE_ENDIAN)
--   - filename: ^ay: Save delta superblock to this filename (bytestring), and parts in the same directory.  Default saves to repository.
--   - sign-name: ^ay: Signature type to use (bytestring).
--   - sign-key-ids: ^as: NULL-terminated array of keys used to sign delta superblock.
repoStaticDeltaGenerate ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.StaticDeltaGenerateOpt
    -- ^ /@opt@/: High level optimization choice
    -> Maybe (T.Text)
    -- ^ /@from@/: ASCII SHA256 checksum of origin, or 'P.Nothing'
    -> T.Text
    -- ^ /@to@/: ASCII SHA256 checksum of target
    -> Maybe (GVariant)
    -- ^ /@metadata@/: Optional metadata
    -> Maybe (GVariant)
    -- ^ /@params@/: Parameters, see below
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoStaticDeltaGenerate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> StaticDeltaGenerateOpt
-> Maybe Text
-> Text
-> Maybe GVariant
-> Maybe GVariant
-> Maybe b
-> m ()
repoStaticDeltaGenerate a
self StaticDeltaGenerateOpt
opt Maybe Text
from Text
to Maybe GVariant
metadata Maybe GVariant
params Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let opt' :: CUInt
opt' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) StaticDeltaGenerateOpt
opt
    CString
maybeFrom <- case Maybe Text
from of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jFrom -> do
            CString
jFrom' <- Text -> IO CString
textToCString Text
jFrom
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFrom'
    CString
to' <- Text -> IO CString
textToCString Text
to
    Ptr GVariant
maybeMetadata <- case Maybe GVariant
metadata of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jMetadata -> do
            Ptr GVariant
jMetadata' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jMetadata
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jMetadata'
    Ptr GVariant
maybeParams <- case Maybe GVariant
params of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jParams -> do
            Ptr GVariant
jParams' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jParams
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jParams'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> CString
-> Ptr GVariant
-> Ptr GVariant
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_static_delta_generate Ptr Repo
self' CUInt
opt' CString
maybeFrom CString
to' Ptr GVariant
maybeMetadata Ptr GVariant
maybeParams Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
metadata forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
params forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeFrom
        forall a. Ptr a -> IO ()
freeMem CString
to'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeFrom
        forall a. Ptr a -> IO ()
freeMem CString
to'
     )

#if defined(ENABLE_OVERLOADING)
data RepoStaticDeltaGenerateMethodInfo
instance (signature ~ (OSTree.Enums.StaticDeltaGenerateOpt -> Maybe (T.Text) -> T.Text -> Maybe (GVariant) -> Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoStaticDeltaGenerateMethodInfo a signature where
    overloadedMethod = repoStaticDeltaGenerate

instance O.OverloadedMethodInfo RepoStaticDeltaGenerateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoStaticDeltaGenerate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoStaticDeltaGenerate"
        })


#endif

-- method Repo::static_delta_reindex
-- method type : OrdinaryMethod
-- 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 = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "StaticDeltaIndexFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Flags affecting the indexing operation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "opt_to_commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "ASCII SHA256 checksum of target commit, or %NULL to index all targets"
--                 , 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_repo_static_delta_reindex" ostree_repo_static_delta_reindex :: 
    Ptr Repo ->                             -- repo : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "OSTree", name = "StaticDeltaIndexFlags"})
    CString ->                              -- opt_to_commit : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | The delta index for a particular commit lists all the existing deltas that can be used
-- when downloading that commit. This operation regenerates these indexes, either for
-- a particular commit (if /@optToCommit@/ is non-'P.Nothing'), or for all commits that
-- are reachable by an existing delta (if /@optToCommit@/ is 'P.Nothing').
-- 
-- This is normally called automatically when the summary is updated in 'GI.OSTree.Objects.Repo.repoRegenerateSummary'.
-- 
-- Locking: shared
-- 
-- /Since: 2020.8/
repoStaticDeltaReindex ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@repo@/: Repo
    -> OSTree.Enums.StaticDeltaIndexFlags
    -- ^ /@flags@/: Flags affecting the indexing operation
    -> T.Text
    -- ^ /@optToCommit@/: ASCII SHA256 checksum of target commit, or 'P.Nothing' to index all targets
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoStaticDeltaReindex :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> StaticDeltaIndexFlags -> Text -> Maybe b -> m ()
repoStaticDeltaReindex a
repo StaticDeltaIndexFlags
flags Text
optToCommit Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
repo' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
repo
    let flags' :: CUInt
flags' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) StaticDeltaIndexFlags
flags
    CString
optToCommit' <- Text -> IO CString
textToCString Text
optToCommit
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_static_delta_reindex Ptr Repo
repo' CUInt
flags' CString
optToCommit' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
repo
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
optToCommit'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
optToCommit'
     )

#if defined(ENABLE_OVERLOADING)
data RepoStaticDeltaReindexMethodInfo
instance (signature ~ (OSTree.Enums.StaticDeltaIndexFlags -> T.Text -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoStaticDeltaReindexMethodInfo a signature where
    overloadedMethod = repoStaticDeltaReindex

instance O.OverloadedMethodInfo RepoStaticDeltaReindexMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoStaticDeltaReindex",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoStaticDeltaReindex"
        })


#endif

-- method Repo::static_delta_verify_signature
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "delta_id"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "delta path" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sign"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Sign" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Signature engine used to check superblock"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_success_message"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "success message" , 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_repo_static_delta_verify_signature" ostree_repo_static_delta_verify_signature :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- delta_id : TBasicType TUTF8
    Ptr OSTree.Sign.Sign ->                 -- sign : TInterface (Name {namespace = "OSTree", name = "Sign"})
    Ptr CString ->                          -- out_success_message : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Verify static delta file signature.
-- 
-- /Since: 2020.7/
repoStaticDeltaVerifySignature ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.Sign.IsSign b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@deltaId@/: delta path
    -> b
    -- ^ /@sign@/: Signature engine used to check superblock
    -> m ((Maybe T.Text))
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoStaticDeltaVerifySignature :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsSign b) =>
a -> Text -> b -> m (Maybe Text)
repoStaticDeltaVerifySignature a
self Text
deltaId b
sign = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
deltaId' <- Text -> IO CString
textToCString Text
deltaId
    Ptr Sign
sign' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sign
    Ptr CString
outSuccessMessage <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr Sign
-> Ptr CString
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_static_delta_verify_signature Ptr Repo
self' CString
deltaId' Ptr Sign
sign' Ptr CString
outSuccessMessage
        CString
outSuccessMessage' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outSuccessMessage
        Maybe Text
maybeOutSuccessMessage' <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
outSuccessMessage' forall a b. (a -> b) -> a -> b
$ \CString
outSuccessMessage'' -> do
            Text
outSuccessMessage''' <- HasCallStack => CString -> IO Text
cstringToText CString
outSuccessMessage''
            forall (m :: * -> *) a. Monad m => a -> m a
return Text
outSuccessMessage'''
        forall a. Ptr a -> IO ()
freeMem CString
outSuccessMessage'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sign
        forall a. Ptr a -> IO ()
freeMem CString
deltaId'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outSuccessMessage
        forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeOutSuccessMessage'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
deltaId'
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outSuccessMessage
     )

#if defined(ENABLE_OVERLOADING)
data RepoStaticDeltaVerifySignatureMethodInfo
instance (signature ~ (T.Text -> b -> m ((Maybe T.Text))), MonadIO m, IsRepo a, OSTree.Sign.IsSign b) => O.OverloadedMethod RepoStaticDeltaVerifySignatureMethodInfo a signature where
    overloadedMethod = repoStaticDeltaVerifySignature

instance O.OverloadedMethodInfo RepoStaticDeltaVerifySignatureMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoStaticDeltaVerifySignature",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoStaticDeltaVerifySignature"
        })


#endif

-- method Repo::transaction_set_collection_ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ref"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "CollectionRef" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The collection\8211ref to write"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The checksum to point it to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_transaction_set_collection_ref" ostree_repo_transaction_set_collection_ref :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr OSTree.CollectionRef.CollectionRef -> -- ref : TInterface (Name {namespace = "OSTree", name = "CollectionRef"})
    CString ->                              -- checksum : TBasicType TUTF8
    IO ()

-- | If /@checksum@/ is not 'P.Nothing', then record it as the target of local ref named
-- /@ref@/.
-- 
-- Otherwise, if /@checksum@/ is 'P.Nothing', then record that the ref should
-- be deleted.
-- 
-- The change will not be written out immediately, but when the transaction
-- is completed with 'GI.OSTree.Objects.Repo.repoCommitTransaction'. If the transaction
-- is instead aborted with 'GI.OSTree.Objects.Repo.repoAbortTransaction', no changes will
-- be made to the repository.
-- 
-- Multithreading: Since v2017.15 this function is MT safe.
-- 
-- /Since: 2018.6/
repoTransactionSetCollectionRef ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> OSTree.CollectionRef.CollectionRef
    -- ^ /@ref@/: The collection–ref to write
    -> Maybe (T.Text)
    -- ^ /@checksum@/: The checksum to point it to
    -> m ()
repoTransactionSetCollectionRef :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> CollectionRef -> Maybe Text -> m ()
repoTransactionSetCollectionRef a
self CollectionRef
ref Maybe Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CollectionRef
ref' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CollectionRef
ref
    CString
maybeChecksum <- case Maybe Text
checksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jChecksum -> do
            CString
jChecksum' <- Text -> IO CString
textToCString Text
jChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jChecksum'
    Ptr Repo -> Ptr CollectionRef -> CString -> IO ()
ostree_repo_transaction_set_collection_ref Ptr Repo
self' Ptr CollectionRef
ref' CString
maybeChecksum
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CollectionRef
ref
    forall a. Ptr a -> IO ()
freeMem CString
maybeChecksum
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoTransactionSetCollectionRefMethodInfo
instance (signature ~ (OSTree.CollectionRef.CollectionRef -> Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoTransactionSetCollectionRefMethodInfo a signature where
    overloadedMethod = repoTransactionSetCollectionRef

instance O.OverloadedMethodInfo RepoTransactionSetCollectionRefMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoTransactionSetCollectionRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoTransactionSetCollectionRef"
        })


#endif

-- method Repo::transaction_set_ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A remote for the ref"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ref"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The ref to write" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The checksum to point it to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_transaction_set_ref" ostree_repo_transaction_set_ref :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote : TBasicType TUTF8
    CString ->                              -- ref : TBasicType TUTF8
    CString ->                              -- checksum : TBasicType TUTF8
    IO ()

-- | If /@checksum@/ is not 'P.Nothing', then record it as the target of ref named
-- /@ref@/; if /@remote@/ is provided, the ref will appear to originate from that
-- remote.
-- 
-- Otherwise, if /@checksum@/ is 'P.Nothing', then record that the ref should
-- be deleted.
-- 
-- The change will be written when the transaction is completed with
-- 'GI.OSTree.Objects.Repo.repoCommitTransaction'; that function takes care of writing all of
-- the objects (such as the commit referred to by /@checksum@/) before updating the
-- refs. If the transaction is instead aborted with
-- 'GI.OSTree.Objects.Repo.repoAbortTransaction', no changes to the ref will be made to the
-- repository.
-- 
-- Note however that currently writing *multiple* refs is not truly atomic; if
-- the process or system is terminated during
-- 'GI.OSTree.Objects.Repo.repoCommitTransaction', it is possible that just some of the refs
-- will have been updated. Your application should take care to handle this
-- case.
-- 
-- Multithreading: Since v2017.15 this function is MT safe.
repoTransactionSetRef ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Maybe (T.Text)
    -- ^ /@remote@/: A remote for the ref
    -> T.Text
    -- ^ /@ref@/: The ref to write
    -> Maybe (T.Text)
    -- ^ /@checksum@/: The checksum to point it to
    -> m ()
repoTransactionSetRef :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Maybe Text -> Text -> Maybe Text -> m ()
repoTransactionSetRef a
self Maybe Text
remote Text
ref Maybe Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeRemote <- case Maybe Text
remote of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jRemote -> do
            CString
jRemote' <- Text -> IO CString
textToCString Text
jRemote
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jRemote'
    CString
ref' <- Text -> IO CString
textToCString Text
ref
    CString
maybeChecksum <- case Maybe Text
checksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jChecksum -> do
            CString
jChecksum' <- Text -> IO CString
textToCString Text
jChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jChecksum'
    Ptr Repo -> CString -> CString -> CString -> IO ()
ostree_repo_transaction_set_ref Ptr Repo
self' CString
maybeRemote CString
ref' CString
maybeChecksum
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
maybeRemote
    forall a. Ptr a -> IO ()
freeMem CString
ref'
    forall a. Ptr a -> IO ()
freeMem CString
maybeChecksum
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoTransactionSetRefMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoTransactionSetRefMethodInfo a signature where
    overloadedMethod = repoTransactionSetRef

instance O.OverloadedMethodInfo RepoTransactionSetRefMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoTransactionSetRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoTransactionSetRef"
        })


#endif

-- method Repo::transaction_set_refspec
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , 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 "The refspec to write"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The checksum to point it to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_transaction_set_refspec" ostree_repo_transaction_set_refspec :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- refspec : TBasicType TUTF8
    CString ->                              -- checksum : TBasicType TUTF8
    IO ()

-- | Like 'GI.OSTree.Objects.Repo.repoTransactionSetRef', but takes concatenated
-- /@refspec@/ format as input instead of separate remote and name
-- arguments.
-- 
-- Multithreading: Since v2017.15 this function is MT safe.
repoTransactionSetRefspec ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> T.Text
    -- ^ /@refspec@/: The refspec to write
    -> Maybe (T.Text)
    -- ^ /@checksum@/: The checksum to point it to
    -> m ()
repoTransactionSetRefspec :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> Text -> Maybe Text -> m ()
repoTransactionSetRefspec a
self Text
refspec Maybe Text
checksum = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
refspec' <- Text -> IO CString
textToCString Text
refspec
    CString
maybeChecksum <- case Maybe Text
checksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jChecksum -> do
            CString
jChecksum' <- Text -> IO CString
textToCString Text
jChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jChecksum'
    Ptr Repo -> CString -> CString -> IO ()
ostree_repo_transaction_set_refspec Ptr Repo
self' CString
refspec' CString
maybeChecksum
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
refspec'
    forall a. Ptr a -> IO ()
freeMem CString
maybeChecksum
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoTransactionSetRefspecMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoTransactionSetRefspecMethodInfo a signature where
    overloadedMethod = repoTransactionSetRefspec

instance O.OverloadedMethodInfo RepoTransactionSetRefspecMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoTransactionSetRefspec",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoTransactionSetRefspec"
        })


#endif

-- XXX Could not generate method Repo::traverse_commit
-- Not implemented: GHashTable element of type TVariant unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoTraverseCommitMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "traverseCommit" Repo) => O.OverloadedMethod RepoTraverseCommitMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "traverseCommit" Repo) => O.OverloadedMethodInfo RepoTraverseCommitMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Repo::traverse_reachable_refs
-- Not implemented: GHashTable key of type TVariant unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoTraverseReachableRefsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "traverseReachableRefs" Repo) => O.OverloadedMethod RepoTraverseReachableRefsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "traverseReachableRefs" Repo) => O.OverloadedMethodInfo RepoTraverseReachableRefsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Repo::verify_commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Repository" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyringdir"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Path to directory GPG keyrings; overrides built-in default if given"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "extra_keyring"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Path to additional keyring file (not a directory)"
--                 , 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_repo_verify_commit" ostree_repo_verify_commit :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- commit_checksum : TBasicType TUTF8
    Ptr Gio.File.File ->                    -- keyringdir : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.File.File ->                    -- extra_keyring : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Check for a valid GPG signature on commit named by the ASCII
-- checksum /@commitChecksum@/.
repoVerifyCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) =>
    a
    -- ^ /@self@/: Repository
    -> T.Text
    -- ^ /@commitChecksum@/: ASCII SHA256 checksum
    -> Maybe (b)
    -- ^ /@keyringdir@/: Path to directory GPG keyrings; overrides built-in default if given
    -> Maybe (c)
    -- ^ /@extraKeyring@/: Path to additional keyring file (not a directory)
    -> Maybe (d)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoVerifyCommit :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c,
 IsCancellable d) =>
a -> Text -> Maybe b -> Maybe c -> Maybe d -> m ()
repoVerifyCommit a
self Text
commitChecksum Maybe b
keyringdir Maybe c
extraKeyring Maybe d
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
commitChecksum' <- Text -> IO CString
textToCString Text
commitChecksum
    Ptr File
maybeKeyringdir <- case Maybe b
keyringdir of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jKeyringdir -> do
            Ptr File
jKeyringdir' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jKeyringdir
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jKeyringdir'
    Ptr File
maybeExtraKeyring <- case Maybe c
extraKeyring of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jExtraKeyring -> do
            Ptr File
jExtraKeyring' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jExtraKeyring
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jExtraKeyring'
    Ptr Cancellable
maybeCancellable <- case Maybe d
cancellable of
        Maybe d
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just d
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr File
-> Ptr File
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_verify_commit Ptr Repo
self' CString
commitChecksum' Ptr File
maybeKeyringdir Ptr File
maybeExtraKeyring Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
keyringdir forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
extraKeyring forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe d
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoVerifyCommitMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe (c) -> Maybe (d) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => O.OverloadedMethod RepoVerifyCommitMethodInfo a signature where
    overloadedMethod = repoVerifyCommit

instance O.OverloadedMethodInfo RepoVerifyCommitMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoVerifyCommit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoVerifyCommit"
        })


#endif

-- method Repo::verify_commit_ext
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Repository" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyringdir"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Path to directory GPG keyrings; overrides built-in default if given"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "extra_keyring"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Path to additional keyring file (not a directory)"
--                 , 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
--               (TInterface
--                  Name { namespace = "OSTree" , name = "GpgVerifyResult" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_verify_commit_ext" ostree_repo_verify_commit_ext :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- commit_checksum : TBasicType TUTF8
    Ptr Gio.File.File ->                    -- keyringdir : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.File.File ->                    -- extra_keyring : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult)

-- | Read GPG signature(s) on the commit named by the ASCII checksum
-- /@commitChecksum@/ and return detailed results.
repoVerifyCommitExt ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) =>
    a
    -- ^ /@self@/: Repository
    -> T.Text
    -- ^ /@commitChecksum@/: ASCII SHA256 checksum
    -> Maybe (b)
    -- ^ /@keyringdir@/: Path to directory GPG keyrings; overrides built-in default if given
    -> Maybe (c)
    -- ^ /@extraKeyring@/: Path to additional keyring file (not a directory)
    -> Maybe (d)
    -- ^ /@cancellable@/: Cancellable
    -> m OSTree.GpgVerifyResult.GpgVerifyResult
    -- ^ __Returns:__ an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'P.Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/
repoVerifyCommitExt :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c,
 IsCancellable d) =>
a -> Text -> Maybe b -> Maybe c -> Maybe d -> m GpgVerifyResult
repoVerifyCommitExt a
self Text
commitChecksum Maybe b
keyringdir Maybe c
extraKeyring Maybe d
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
commitChecksum' <- Text -> IO CString
textToCString Text
commitChecksum
    Ptr File
maybeKeyringdir <- case Maybe b
keyringdir of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jKeyringdir -> do
            Ptr File
jKeyringdir' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jKeyringdir
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jKeyringdir'
    Ptr File
maybeExtraKeyring <- case Maybe c
extraKeyring of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jExtraKeyring -> do
            Ptr File
jExtraKeyring' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jExtraKeyring
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr File
jExtraKeyring'
    Ptr Cancellable
maybeCancellable <- case Maybe d
cancellable of
        Maybe d
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just d
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr GpgVerifyResult
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr File
-> Ptr File
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr GpgVerifyResult)
ostree_repo_verify_commit_ext Ptr Repo
self' CString
commitChecksum' Ptr File
maybeKeyringdir Ptr File
maybeExtraKeyring Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoVerifyCommitExt" Ptr GpgVerifyResult
result
        GpgVerifyResult
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr GpgVerifyResult -> GpgVerifyResult
OSTree.GpgVerifyResult.GpgVerifyResult) Ptr GpgVerifyResult
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
keyringdir forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
extraKeyring forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe d
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return GpgVerifyResult
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoVerifyCommitExtMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe (c) -> Maybe (d) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.File.IsFile b, Gio.File.IsFile c, Gio.Cancellable.IsCancellable d) => O.OverloadedMethod RepoVerifyCommitExtMethodInfo a signature where
    overloadedMethod = repoVerifyCommitExt

instance O.OverloadedMethodInfo RepoVerifyCommitExtMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoVerifyCommitExt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoVerifyCommitExt"
        })


#endif

-- method Repo::verify_commit_for_remote
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Repository" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "commit_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "OSTree remote to use for configuration"
--                 , 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
--               (TInterface
--                  Name { namespace = "OSTree" , name = "GpgVerifyResult" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_verify_commit_for_remote" ostree_repo_verify_commit_for_remote :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- commit_checksum : TBasicType TUTF8
    CString ->                              -- remote_name : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult)

-- | Read GPG signature(s) on the commit named by the ASCII checksum
-- /@commitChecksum@/ and return detailed results, based on the keyring
-- configured for /@remote@/.
-- 
-- /Since: 2016.14/
repoVerifyCommitForRemote ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repository
    -> T.Text
    -- ^ /@commitChecksum@/: ASCII SHA256 checksum
    -> T.Text
    -- ^ /@remoteName@/: OSTree remote to use for configuration
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m OSTree.GpgVerifyResult.GpgVerifyResult
    -- ^ __Returns:__ an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'P.Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/
repoVerifyCommitForRemote :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Text -> Maybe b -> m GpgVerifyResult
repoVerifyCommitForRemote a
self Text
commitChecksum Text
remoteName Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
commitChecksum' <- Text -> IO CString
textToCString Text
commitChecksum
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr GpgVerifyResult
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr GpgVerifyResult)
ostree_repo_verify_commit_for_remote Ptr Repo
self' CString
commitChecksum' CString
remoteName' Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoVerifyCommitForRemote" Ptr GpgVerifyResult
result
        GpgVerifyResult
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr GpgVerifyResult -> GpgVerifyResult
OSTree.GpgVerifyResult.GpgVerifyResult) Ptr GpgVerifyResult
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall (m :: * -> *) a. Monad m => a -> m a
return GpgVerifyResult
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
commitChecksum'
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
     )

#if defined(ENABLE_OVERLOADING)
data RepoVerifyCommitForRemoteMethodInfo
instance (signature ~ (T.Text -> T.Text -> Maybe (b) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoVerifyCommitForRemoteMethodInfo a signature where
    overloadedMethod = repoVerifyCommitForRemote

instance O.OverloadedMethodInfo RepoVerifyCommitForRemoteMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoVerifyCommitForRemote",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoVerifyCommitForRemote"
        })


#endif

-- method Repo::verify_summary
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "remote_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of remote" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "summary"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Summary data as a #GBytes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signatures"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Summary signatures as a #GBytes"
--                 , 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
--               (TInterface
--                  Name { namespace = "OSTree" , name = "GpgVerifyResult" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_verify_summary" ostree_repo_verify_summary :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- remote_name : TBasicType TUTF8
    Ptr GLib.Bytes.Bytes ->                 -- summary : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr GLib.Bytes.Bytes ->                 -- signatures : TInterface (Name {namespace = "GLib", name = "Bytes"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr OSTree.GpgVerifyResult.GpgVerifyResult)

-- | Verify /@signatures@/ for /@summary@/ data using GPG keys in the keyring for
-- /@remoteName@/, and return an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'.
repoVerifySummary ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@remoteName@/: Name of remote
    -> GLib.Bytes.Bytes
    -- ^ /@summary@/: Summary data as a t'GI.GLib.Structs.Bytes.Bytes'
    -> GLib.Bytes.Bytes
    -- ^ /@signatures@/: Summary signatures as a t'GI.GLib.Structs.Bytes.Bytes'
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m OSTree.GpgVerifyResult.GpgVerifyResult
    -- ^ __Returns:__ an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult', or 'P.Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/
repoVerifySummary :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Bytes -> Bytes -> Maybe b -> m GpgVerifyResult
repoVerifySummary a
self Text
remoteName Bytes
summary Bytes
signatures Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
remoteName' <- Text -> IO CString
textToCString Text
remoteName
    Ptr Bytes
summary' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
summary
    Ptr Bytes
signatures' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
signatures
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr GpgVerifyResult
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr Bytes
-> Ptr Bytes
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr GpgVerifyResult)
ostree_repo_verify_summary Ptr Repo
self' CString
remoteName' Ptr Bytes
summary' Ptr Bytes
signatures' Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoVerifySummary" Ptr GpgVerifyResult
result
        GpgVerifyResult
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr GpgVerifyResult -> GpgVerifyResult
OSTree.GpgVerifyResult.GpgVerifyResult) Ptr GpgVerifyResult
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
summary
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
signatures
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
        forall (m :: * -> *) a. Monad m => a -> m a
return GpgVerifyResult
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
remoteName'
     )

#if defined(ENABLE_OVERLOADING)
data RepoVerifySummaryMethodInfo
instance (signature ~ (T.Text -> GLib.Bytes.Bytes -> GLib.Bytes.Bytes -> Maybe (b) -> m OSTree.GpgVerifyResult.GpgVerifyResult), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoVerifySummaryMethodInfo a signature where
    overloadedMethod = repoVerifySummary

instance O.OverloadedMethodInfo RepoVerifySummaryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoVerifySummary",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoVerifySummary"
        })


#endif

-- method Repo::write_archive_to_mtree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "archive"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A path to an archive file"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mtree"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "MutableTree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #OstreeMutableTree to write to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifier"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitModifier" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Optional commit modifier"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "autocreate_parents"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Autocreate parent directories"
--                 , 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_repo_write_archive_to_mtree" ostree_repo_write_archive_to_mtree :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.File.File ->                    -- archive : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr OSTree.MutableTree.MutableTree ->   -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"})
    Ptr OSTree.RepoCommitModifier.RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"})
    CInt ->                                 -- autocreate_parents : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Import an archive file /@archive@/ into the repository, and write its
-- file structure to /@mtree@/.
repoWriteArchiveToMtree ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> b
    -- ^ /@archive@/: A path to an archive file
    -> c
    -- ^ /@mtree@/: The t'GI.OSTree.Objects.MutableTree.MutableTree' to write to
    -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier)
    -- ^ /@modifier@/: Optional commit modifier
    -> Bool
    -- ^ /@autocreateParents@/: Autocreate parent directories
    -> Maybe (d)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteArchiveToMtree :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsMutableTree c,
 IsCancellable d) =>
a -> b -> c -> Maybe RepoCommitModifier -> Bool -> Maybe d -> m ()
repoWriteArchiveToMtree a
self b
archive c
mtree Maybe RepoCommitModifier
modifier Bool
autocreateParents Maybe d
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
archive' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
archive
    Ptr MutableTree
mtree' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
mtree
    Ptr RepoCommitModifier
maybeModifier <- case Maybe RepoCommitModifier
modifier of
        Maybe RepoCommitModifier
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just RepoCommitModifier
jModifier -> do
            Ptr RepoCommitModifier
jModifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
jModifier
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RepoCommitModifier
jModifier'
    let autocreateParents' :: CInt
autocreateParents' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
autocreateParents
    Ptr Cancellable
maybeCancellable <- case Maybe d
cancellable of
        Maybe d
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just d
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr File
-> Ptr MutableTree
-> Ptr RepoCommitModifier
-> CInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_archive_to_mtree Ptr Repo
self' Ptr File
archive' Ptr MutableTree
mtree' Ptr RepoCommitModifier
maybeModifier CInt
autocreateParents' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
archive
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
mtree
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RepoCommitModifier
modifier forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe d
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteArchiveToMtreeMethodInfo
instance (signature ~ (b -> c -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) -> Bool -> Maybe (d) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) => O.OverloadedMethod RepoWriteArchiveToMtreeMethodInfo a signature where
    overloadedMethod = repoWriteArchiveToMtree

instance O.OverloadedMethodInfo RepoWriteArchiveToMtreeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteArchiveToMtree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteArchiveToMtree"
        })


#endif

-- method Repo::write_archive_to_mtree_from_fd
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #OstreeRepo" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fd"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A file descriptor to read the archive from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mtree"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "MutableTree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #OstreeMutableTree to write to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifier"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitModifier" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Optional commit modifier"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "autocreate_parents"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Autocreate parent directories"
--                 , 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_repo_write_archive_to_mtree_from_fd" ostree_repo_write_archive_to_mtree_from_fd :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Int32 ->                                -- fd : TBasicType TInt
    Ptr OSTree.MutableTree.MutableTree ->   -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"})
    Ptr OSTree.RepoCommitModifier.RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"})
    CInt ->                                 -- autocreate_parents : TBasicType TBoolean
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Read an archive from /@fd@/ and import it into the repository, writing
-- its file structure to /@mtree@/.
repoWriteArchiveToMtreeFromFd ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: An t'GI.OSTree.Objects.Repo.Repo'
    -> Int32
    -- ^ /@fd@/: A file descriptor to read the archive from
    -> b
    -- ^ /@mtree@/: The t'GI.OSTree.Objects.MutableTree.MutableTree' to write to
    -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier)
    -- ^ /@modifier@/: Optional commit modifier
    -> Bool
    -- ^ /@autocreateParents@/: Autocreate parent directories
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteArchiveToMtreeFromFd :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsMutableTree b,
 IsCancellable c) =>
a
-> Int32
-> b
-> Maybe RepoCommitModifier
-> Bool
-> Maybe c
-> m ()
repoWriteArchiveToMtreeFromFd a
self Int32
fd b
mtree Maybe RepoCommitModifier
modifier Bool
autocreateParents Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MutableTree
mtree' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
mtree
    Ptr RepoCommitModifier
maybeModifier <- case Maybe RepoCommitModifier
modifier of
        Maybe RepoCommitModifier
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just RepoCommitModifier
jModifier -> do
            Ptr RepoCommitModifier
jModifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
jModifier
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RepoCommitModifier
jModifier'
    let autocreateParents' :: CInt
autocreateParents' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
autocreateParents
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Int32
-> Ptr MutableTree
-> Ptr RepoCommitModifier
-> CInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_archive_to_mtree_from_fd Ptr Repo
self' Int32
fd Ptr MutableTree
mtree' Ptr RepoCommitModifier
maybeModifier CInt
autocreateParents' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
mtree
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RepoCommitModifier
modifier forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteArchiveToMtreeFromFdMethodInfo
instance (signature ~ (Int32 -> b -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) -> Bool -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteArchiveToMtreeFromFdMethodInfo a signature where
    overloadedMethod = repoWriteArchiveToMtreeFromFd

instance O.OverloadedMethodInfo RepoWriteArchiveToMtreeFromFdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteArchiveToMtreeFromFd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteArchiveToMtreeFromFd"
        })


#endif

-- method Repo::write_commit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "parent"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "ASCII SHA256 checksum for parent, or %NULL for none"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "subject"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Subject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "body"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Just "Body" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "metadata"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GVariant of type a{sv}, or %NULL for none"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "root"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The tree to point the commit to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Resulting ASCII SHA256 checksum for commit"
--                 , 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_repo_write_commit" ostree_repo_write_commit :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- parent : TBasicType TUTF8
    CString ->                              -- subject : TBasicType TUTF8
    CString ->                              -- body : TBasicType TUTF8
    Ptr GVariant ->                         -- metadata : TVariant
    Ptr OSTree.RepoFile.RepoFile ->         -- root : TInterface (Name {namespace = "OSTree", name = "RepoFile"})
    Ptr CString ->                          -- out_commit : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Write a commit metadata object, referencing /@rootContentsChecksum@/
-- and /@rootMetadataChecksum@/.
-- This uses the current time as the commit timestamp, but it can be
-- overridden with an explicit timestamp via the
-- <https://reproducible-builds.org/specs/source-date-epoch/ standard>
-- @SOURCE_DATE_EPOCH@ environment flag.
repoWriteCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (T.Text)
    -- ^ /@parent@/: ASCII SHA256 checksum for parent, or 'P.Nothing' for none
    -> Maybe (T.Text)
    -- ^ /@subject@/: Subject
    -> Maybe (T.Text)
    -- ^ /@body@/: Body
    -> Maybe (GVariant)
    -- ^ /@metadata@/: GVariant of type a{sv}, or 'P.Nothing' for none
    -> b
    -- ^ /@root@/: The tree to point the commit to
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m (T.Text)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteCommit :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsRepoFile b,
 IsCancellable c) =>
a
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe GVariant
-> b
-> Maybe c
-> m Text
repoWriteCommit a
self Maybe Text
parent Maybe Text
subject Maybe Text
body Maybe GVariant
metadata b
root Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeParent <- case Maybe Text
parent of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jParent -> do
            CString
jParent' <- Text -> IO CString
textToCString Text
jParent
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jParent'
    CString
maybeSubject <- case Maybe Text
subject of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jSubject -> do
            CString
jSubject' <- Text -> IO CString
textToCString Text
jSubject
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jSubject'
    CString
maybeBody <- case Maybe Text
body of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jBody -> do
            CString
jBody' <- Text -> IO CString
textToCString Text
jBody
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jBody'
    Ptr GVariant
maybeMetadata <- case Maybe GVariant
metadata of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jMetadata -> do
            Ptr GVariant
jMetadata' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jMetadata
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jMetadata'
    Ptr RepoFile
root' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
root
    Ptr CString
outCommit <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CString
-> Ptr GVariant
-> Ptr RepoFile
-> Ptr CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_commit Ptr Repo
self' CString
maybeParent CString
maybeSubject CString
maybeBody Ptr GVariant
maybeMetadata Ptr RepoFile
root' Ptr CString
outCommit Ptr Cancellable
maybeCancellable
        CString
outCommit' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outCommit
        Text
outCommit'' <- HasCallStack => CString -> IO Text
cstringToText CString
outCommit'
        forall a. Ptr a -> IO ()
freeMem CString
outCommit'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
metadata forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
root
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeParent
        forall a. Ptr a -> IO ()
freeMem CString
maybeSubject
        forall a. Ptr a -> IO ()
freeMem CString
maybeBody
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outCommit
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
outCommit''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeParent
        forall a. Ptr a -> IO ()
freeMem CString
maybeSubject
        forall a. Ptr a -> IO ()
freeMem CString
maybeBody
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outCommit
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteCommitMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (GVariant) -> b -> Maybe (c) -> m (T.Text)), MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteCommitMethodInfo a signature where
    overloadedMethod = repoWriteCommit

instance O.OverloadedMethodInfo RepoWriteCommitMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteCommit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteCommit"
        })


#endif

-- method Repo::write_commit_detached_metadata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "ASCII SHA256 commit checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "metadata"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Metadata to associate with commit in with format \"a{sv}\", or %NULL to delete"
--                 , 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_repo_write_commit_detached_metadata" ostree_repo_write_commit_detached_metadata :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr GVariant ->                         -- metadata : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Replace any existing metadata associated with commit referred to by
-- /@checksum@/ with /@metadata@/.  If /@metadata@/ is 'P.Nothing', then existing
-- data will be deleted.
repoWriteCommitDetachedMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@checksum@/: ASCII SHA256 commit checksum
    -> Maybe (GVariant)
    -- ^ /@metadata@/: Metadata to associate with commit in with format \"a{sv}\", or 'P.Nothing' to delete
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteCommitDetachedMetadata :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> Text -> Maybe GVariant -> Maybe b -> m ()
repoWriteCommitDetachedMetadata a
self Text
checksum Maybe GVariant
metadata Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr GVariant
maybeMetadata <- case Maybe GVariant
metadata of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jMetadata -> do
            Ptr GVariant
jMetadata' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jMetadata
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jMetadata'
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr GVariant
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_commit_detached_metadata Ptr Repo
self' CString
checksum' Ptr GVariant
maybeMetadata Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
metadata forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteCommitDetachedMetadataMethodInfo
instance (signature ~ (T.Text -> Maybe (GVariant) -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoWriteCommitDetachedMetadataMethodInfo a signature where
    overloadedMethod = repoWriteCommitDetachedMetadata

instance O.OverloadedMethodInfo RepoWriteCommitDetachedMetadataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteCommitDetachedMetadata",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteCommitDetachedMetadata"
        })


#endif

-- method Repo::write_commit_with_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "parent"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "ASCII SHA256 checksum for parent, or %NULL for none"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "subject"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Subject" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "body"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Just "Body" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "metadata"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GVariant of type a{sv}, or %NULL for none"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "root"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The tree to point the commit to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "time"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The time to use to stamp the commit"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_commit"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Resulting ASCII SHA256 checksum for commit"
--                 , 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_repo_write_commit_with_time" ostree_repo_write_commit_with_time :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- parent : TBasicType TUTF8
    CString ->                              -- subject : TBasicType TUTF8
    CString ->                              -- body : TBasicType TUTF8
    Ptr GVariant ->                         -- metadata : TVariant
    Ptr OSTree.RepoFile.RepoFile ->         -- root : TInterface (Name {namespace = "OSTree", name = "RepoFile"})
    Word64 ->                               -- time : TBasicType TUInt64
    Ptr CString ->                          -- out_commit : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Write a commit metadata object, referencing /@rootContentsChecksum@/
-- and /@rootMetadataChecksum@/.
repoWriteCommitWithTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (T.Text)
    -- ^ /@parent@/: ASCII SHA256 checksum for parent, or 'P.Nothing' for none
    -> Maybe (T.Text)
    -- ^ /@subject@/: Subject
    -> Maybe (T.Text)
    -- ^ /@body@/: Body
    -> Maybe (GVariant)
    -- ^ /@metadata@/: GVariant of type a{sv}, or 'P.Nothing' for none
    -> b
    -- ^ /@root@/: The tree to point the commit to
    -> Word64
    -- ^ /@time@/: The time to use to stamp the commit
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m (T.Text)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteCommitWithTime :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsRepoFile b,
 IsCancellable c) =>
a
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe GVariant
-> b
-> Word64
-> Maybe c
-> m Text
repoWriteCommitWithTime a
self Maybe Text
parent Maybe Text
subject Maybe Text
body Maybe GVariant
metadata b
root Word64
time Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeParent <- case Maybe Text
parent of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jParent -> do
            CString
jParent' <- Text -> IO CString
textToCString Text
jParent
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jParent'
    CString
maybeSubject <- case Maybe Text
subject of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jSubject -> do
            CString
jSubject' <- Text -> IO CString
textToCString Text
jSubject
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jSubject'
    CString
maybeBody <- case Maybe Text
body of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jBody -> do
            CString
jBody' <- Text -> IO CString
textToCString Text
jBody
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jBody'
    Ptr GVariant
maybeMetadata <- case Maybe GVariant
metadata of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jMetadata -> do
            Ptr GVariant
jMetadata' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jMetadata
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jMetadata'
    Ptr RepoFile
root' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
root
    Ptr CString
outCommit <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> CString
-> CString
-> Ptr GVariant
-> Ptr RepoFile
-> Word64
-> Ptr CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_commit_with_time Ptr Repo
self' CString
maybeParent CString
maybeSubject CString
maybeBody Ptr GVariant
maybeMetadata Ptr RepoFile
root' Word64
time Ptr CString
outCommit Ptr Cancellable
maybeCancellable
        CString
outCommit' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CString
outCommit
        Text
outCommit'' <- HasCallStack => CString -> IO Text
cstringToText CString
outCommit'
        forall a. Ptr a -> IO ()
freeMem CString
outCommit'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
metadata forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
root
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeParent
        forall a. Ptr a -> IO ()
freeMem CString
maybeSubject
        forall a. Ptr a -> IO ()
freeMem CString
maybeBody
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outCommit
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
outCommit''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeParent
        forall a. Ptr a -> IO ()
freeMem CString
maybeSubject
        forall a. Ptr a -> IO ()
freeMem CString
maybeBody
        forall a. Ptr a -> IO ()
freeMem Ptr CString
outCommit
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteCommitWithTimeMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (GVariant) -> b -> Word64 -> Maybe (c) -> m (T.Text)), MonadIO m, IsRepo a, OSTree.RepoFile.IsRepoFile b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteCommitWithTimeMethodInfo a signature where
    overloadedMethod = repoWriteCommitWithTime

instance O.OverloadedMethodInfo RepoWriteCommitWithTimeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteCommitWithTime",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteCommitWithTime"
        })


#endif

-- method Repo::write_config
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "new_config"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "KeyFile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Overwrite the config file with this data"
--                 , 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_repo_write_config" ostree_repo_write_config :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr GLib.KeyFile.KeyFile ->             -- new_config : TInterface (Name {namespace = "GLib", name = "KeyFile"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Save /@newConfig@/ in place of this repository\'s config file.
repoWriteConfig ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo
    -> GLib.KeyFile.KeyFile
    -- ^ /@newConfig@/: Overwrite the config file with this data
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteConfig :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a -> KeyFile -> m ()
repoWriteConfig a
self KeyFile
newConfig = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr KeyFile
newConfig' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr KeyFile
newConfig
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo -> Ptr KeyFile -> Ptr (Ptr GError) -> IO CInt
ostree_repo_write_config Ptr Repo
self' Ptr KeyFile
newConfig'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr KeyFile
newConfig
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteConfigMethodInfo
instance (signature ~ (GLib.KeyFile.KeyFile -> m ()), MonadIO m, IsRepo a) => O.OverloadedMethod RepoWriteConfigMethodInfo a signature where
    overloadedMethod = repoWriteConfig

instance O.OverloadedMethodInfo RepoWriteConfigMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteConfig",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteConfig"
        })


#endif

-- method Repo::write_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "expected_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "If provided, validate content against this checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_input"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Content object stream"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Length of @object_input"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_csum"
--           , argType = TCArray False 32 (-1) (TBasicType TUInt8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Binary checksum" , 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_repo_write_content" ostree_repo_write_content :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- expected_checksum : TBasicType TUTF8
    Ptr Gio.InputStream.InputStream ->      -- object_input : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Word64 ->                               -- length : TBasicType TUInt64
    Ptr (Ptr Word8) ->                      -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8)
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Store the content object streamed as /@objectInput@/,
-- with total length /@length@/.  The actual checksum will
-- be returned as /@outCsum@/.
repoWriteContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (T.Text)
    -- ^ /@expectedChecksum@/: If provided, validate content against this checksum
    -> b
    -- ^ /@objectInput@/: Content object stream
    -> Word64
    -- ^ /@length@/: Length of /@objectInput@/
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m (ByteString)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteContent :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsInputStream b,
 IsCancellable c) =>
a -> Maybe Text -> b -> Word64 -> Maybe c -> m ByteString
repoWriteContent a
self Maybe Text
expectedChecksum b
objectInput Word64
length_ Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeExpectedChecksum <- case Maybe Text
expectedChecksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jExpectedChecksum -> do
            CString
jExpectedChecksum' <- Text -> IO CString
textToCString Text
jExpectedChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedChecksum'
    Ptr InputStream
objectInput' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
objectInput
    Ptr (Ptr Word8)
outCsum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr InputStream
-> Word64
-> Ptr (Ptr Word8)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_content Ptr Repo
self' CString
maybeExpectedChecksum Ptr InputStream
objectInput' Word64
length_ Ptr (Ptr Word8)
outCsum Ptr Cancellable
maybeCancellable
        Ptr Word8
outCsum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
outCsum
        ByteString
outCsum'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
outCsum'
        forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
objectInput
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
        forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
outCsum''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteContentMethodInfo
instance (signature ~ (Maybe (T.Text) -> b -> Word64 -> Maybe (c) -> m (ByteString)), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteContentMethodInfo a signature where
    overloadedMethod = repoWriteContent

instance O.OverloadedMethodInfo RepoWriteContentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteContent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteContent"
        })


#endif

-- method Repo::write_content_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "expected_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "If provided, validate content against this checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Input" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Length of @object" , 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 "Invoked when content is writed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 6
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User data for @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_write_content_async" ostree_repo_write_content_async :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- expected_checksum : TBasicType TUTF8
    Ptr Gio.InputStream.InputStream ->      -- object : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Word64 ->                               -- length : TBasicType TUInt64
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Asynchronously store the content object /@object@/.  If provided, the
-- checksum /@expectedChecksum@/ will be verified.
repoWriteContentAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> Maybe (T.Text)
    -- ^ /@expectedChecksum@/: If provided, validate content against this checksum
    -> b
    -- ^ /@object@/: Input
    -> Word64
    -- ^ /@length@/: Length of /@object@/
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: Invoked when content is writed
    -> m ()
repoWriteContentAsync :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsInputStream b,
 IsCancellable c) =>
a
-> Maybe Text
-> b
-> Word64
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
repoWriteContentAsync a
self Maybe Text
expectedChecksum b
object Word64
length_ Maybe c
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeExpectedChecksum <- case Maybe Text
expectedChecksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jExpectedChecksum -> do
            CString
jExpectedChecksum' <- Text -> IO CString
textToCString Text
jExpectedChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedChecksum'
    Ptr InputStream
object' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
object
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
    Ptr Repo
-> CString
-> Ptr InputStream
-> Word64
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ostree_repo_write_content_async Ptr Repo
self' CString
maybeExpectedChecksum Ptr InputStream
object' Word64
length_ Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
object
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoWriteContentAsyncMethodInfo
instance (signature ~ (Maybe (T.Text) -> b -> Word64 -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteContentAsyncMethodInfo a signature where
    overloadedMethod = repoWriteContentAsync

instance O.OverloadedMethodInfo RepoWriteContentAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteContentAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteContentAsync"
        })


#endif

-- method Repo::write_content_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "Repo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #OstreeRepo" , 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 "a #GAsyncResult" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_csum"
--           , argType = TBasicType TUInt8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A binary SHA256 checksum of the content object"
--                 , 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_repo_write_content_finish" ostree_repo_write_content_finish :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr Word8 ->                            -- out_csum : TBasicType TUInt8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Completes an invocation of 'GI.OSTree.Objects.Repo.repoWriteContentAsync'.
repoWriteContentFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@self@/: a t'GI.OSTree.Objects.Repo.Repo'
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
    -> m (Word8)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteContentFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) =>
a -> b -> m Word8
repoWriteContentFinish a
self b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    Ptr Word8
outCsum <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word8)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr AsyncResult -> Ptr Word8 -> Ptr (Ptr GError) -> IO CInt
ostree_repo_write_content_finish Ptr Repo
self' Ptr AsyncResult
result_' Ptr Word8
outCsum
        Word8
outCsum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word8
outCsum
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum
        forall (m :: * -> *) a. Monad m => a -> m a
return Word8
outCsum'
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteContentFinishMethodInfo
instance (signature ~ (b -> m (Word8)), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod RepoWriteContentFinishMethodInfo a signature where
    overloadedMethod = repoWriteContentFinish

instance O.OverloadedMethodInfo RepoWriteContentFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteContentFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteContentFinish"
        })


#endif

-- method Repo::write_content_trusted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Store content using this ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_input"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Content stream" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Length of @object_input"
--                 , 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_repo_write_content_trusted" ostree_repo_write_content_trusted :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr Gio.InputStream.InputStream ->      -- object_input : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Word64 ->                               -- length : TBasicType TUInt64
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Store the content object streamed as /@objectInput@/, with total
-- length /@length@/.  The given /@checksum@/ will be treated as trusted.
-- 
-- This function should be used when importing file objects from local
-- disk, for example.
repoWriteContentTrusted ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> T.Text
    -- ^ /@checksum@/: Store content using this ASCII SHA256 checksum
    -> b
    -- ^ /@objectInput@/: Content stream
    -> Word64
    -- ^ /@length@/: Length of /@objectInput@/
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteContentTrusted :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsInputStream b,
 IsCancellable c) =>
a -> Text -> b -> Word64 -> Maybe c -> m ()
repoWriteContentTrusted a
self Text
checksum b
objectInput Word64
length_ Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr InputStream
objectInput' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
objectInput
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Ptr InputStream
-> Word64
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_content_trusted Ptr Repo
self' CString
checksum' Ptr InputStream
objectInput' Word64
length_ Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
objectInput
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteContentTrustedMethodInfo
instance (signature ~ (T.Text -> b -> Word64 -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteContentTrustedMethodInfo a signature where
    overloadedMethod = repoWriteContentTrusted

instance O.OverloadedMethodInfo RepoWriteContentTrustedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteContentTrusted",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteContentTrusted"
        })


#endif

-- method Repo::write_dfd_to_mtree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "dfd"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Directory file descriptor"
--                 , 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" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mtree"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "MutableTree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Overlay directory contents into this tree"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifier"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitModifier" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Optional modifier" , 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_repo_write_dfd_to_mtree" ostree_repo_write_dfd_to_mtree :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Int32 ->                                -- dfd : TBasicType TInt
    CString ->                              -- path : TBasicType TUTF8
    Ptr OSTree.MutableTree.MutableTree ->   -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"})
    Ptr OSTree.RepoCommitModifier.RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Store as objects all contents of the directory referred to by /@dfd@/
-- and /@path@/ all children into the repository /@self@/, overlaying the
-- resulting filesystem hierarchy into /@mtree@/.
repoWriteDfdToMtree ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> Int32
    -- ^ /@dfd@/: Directory file descriptor
    -> T.Text
    -- ^ /@path@/: Path
    -> b
    -- ^ /@mtree@/: Overlay directory contents into this tree
    -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier)
    -- ^ /@modifier@/: Optional modifier
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteDfdToMtree :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsMutableTree b,
 IsCancellable c) =>
a
-> Int32
-> Text
-> b
-> Maybe RepoCommitModifier
-> Maybe c
-> m ()
repoWriteDfdToMtree a
self Int32
dfd Text
path b
mtree Maybe RepoCommitModifier
modifier Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr MutableTree
mtree' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
mtree
    Ptr RepoCommitModifier
maybeModifier <- case Maybe RepoCommitModifier
modifier of
        Maybe RepoCommitModifier
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just RepoCommitModifier
jModifier -> do
            Ptr RepoCommitModifier
jModifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
jModifier
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RepoCommitModifier
jModifier'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Int32
-> CString
-> Ptr MutableTree
-> Ptr RepoCommitModifier
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_dfd_to_mtree Ptr Repo
self' Int32
dfd CString
path' Ptr MutableTree
mtree' Ptr RepoCommitModifier
maybeModifier Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
mtree
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RepoCommitModifier
modifier forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
path'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
path'
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteDfdToMtreeMethodInfo
instance (signature ~ (Int32 -> T.Text -> b -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) -> Maybe (c) -> m ()), MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteDfdToMtreeMethodInfo a signature where
    overloadedMethod = repoWriteDfdToMtree

instance O.OverloadedMethodInfo RepoWriteDfdToMtreeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteDfdToMtree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteDfdToMtree"
        })


#endif

-- method Repo::write_directory_to_mtree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "dir"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path to a directory"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mtree"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "MutableTree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Overlay directory contents into this tree"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifier"
--           , argType =
--               TInterface
--                 Name { namespace = "OSTree" , name = "RepoCommitModifier" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Optional modifier" , 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_repo_write_directory_to_mtree" ostree_repo_write_directory_to_mtree :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.File.File ->                    -- dir : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr OSTree.MutableTree.MutableTree ->   -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"})
    Ptr OSTree.RepoCommitModifier.RepoCommitModifier -> -- modifier : TInterface (Name {namespace = "OSTree", name = "RepoCommitModifier"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Store objects for /@dir@/ and all children into the repository /@self@/,
-- overlaying the resulting filesystem hierarchy into /@mtree@/.
repoWriteDirectoryToMtree ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) =>
    a
    -- ^ /@self@/: Repo
    -> b
    -- ^ /@dir@/: Path to a directory
    -> c
    -- ^ /@mtree@/: Overlay directory contents into this tree
    -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier)
    -- ^ /@modifier@/: Optional modifier
    -> Maybe (d)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteDirectoryToMtree :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsRepo a, IsFile b, IsMutableTree c,
 IsCancellable d) =>
a -> b -> c -> Maybe RepoCommitModifier -> Maybe d -> m ()
repoWriteDirectoryToMtree a
self b
dir c
mtree Maybe RepoCommitModifier
modifier Maybe d
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
dir' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dir
    Ptr MutableTree
mtree' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
mtree
    Ptr RepoCommitModifier
maybeModifier <- case Maybe RepoCommitModifier
modifier of
        Maybe RepoCommitModifier
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just RepoCommitModifier
jModifier -> do
            Ptr RepoCommitModifier
jModifier' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RepoCommitModifier
jModifier
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RepoCommitModifier
jModifier'
    Ptr Cancellable
maybeCancellable <- case Maybe d
cancellable of
        Maybe d
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just d
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr File
-> Ptr MutableTree
-> Ptr RepoCommitModifier
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_directory_to_mtree Ptr Repo
self' Ptr File
dir' Ptr MutableTree
mtree' Ptr RepoCommitModifier
maybeModifier Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dir
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
mtree
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RepoCommitModifier
modifier forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe d
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteDirectoryToMtreeMethodInfo
instance (signature ~ (b -> c -> Maybe (OSTree.RepoCommitModifier.RepoCommitModifier) -> Maybe (d) -> m ()), MonadIO m, IsRepo a, Gio.File.IsFile b, OSTree.MutableTree.IsMutableTree c, Gio.Cancellable.IsCancellable d) => O.OverloadedMethod RepoWriteDirectoryToMtreeMethodInfo a signature where
    overloadedMethod = repoWriteDirectoryToMtree

instance O.OverloadedMethodInfo RepoWriteDirectoryToMtreeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteDirectoryToMtree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteDirectoryToMtree"
        })


#endif

-- method Repo::write_metadata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expected_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "If provided, validate content against this checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Metadata" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_csum"
--           , argType = TCArray False 32 (-1) (TBasicType TUInt8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Binary checksum" , 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_repo_write_metadata" ostree_repo_write_metadata :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- expected_checksum : TBasicType TUTF8
    Ptr GVariant ->                         -- object : TVariant
    Ptr (Ptr Word8) ->                      -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8)
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Store the metadata object /@object@/.  Return the checksum
-- as /@outCsum@/.
-- 
-- If /@expectedChecksum@/ is not 'P.Nothing', verify it against the
-- computed checksum.
repoWriteMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> Maybe (T.Text)
    -- ^ /@expectedChecksum@/: If provided, validate content against this checksum
    -> GVariant
    -- ^ /@object@/: Metadata
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m (ByteString)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteMetadata :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> ObjectType -> Maybe Text -> GVariant -> Maybe b -> m ByteString
repoWriteMetadata a
self ObjectType
objtype Maybe Text
expectedChecksum GVariant
object Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
maybeExpectedChecksum <- case Maybe Text
expectedChecksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jExpectedChecksum -> do
            CString
jExpectedChecksum' <- Text -> IO CString
textToCString Text
jExpectedChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedChecksum'
    Ptr GVariant
object' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
object
    Ptr (Ptr Word8)
outCsum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr GVariant
-> Ptr (Ptr Word8)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_metadata Ptr Repo
self' CUInt
objtype' CString
maybeExpectedChecksum Ptr GVariant
object' Ptr (Ptr Word8)
outCsum Ptr Cancellable
maybeCancellable
        Ptr Word8
outCsum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
outCsum
        ByteString
outCsum'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
outCsum'
        forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
object
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
        forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
outCsum''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteMetadataMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> Maybe (T.Text) -> GVariant -> Maybe (b) -> m (ByteString)), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoWriteMetadataMethodInfo a signature where
    overloadedMethod = repoWriteMetadata

instance O.OverloadedMethodInfo RepoWriteMetadataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteMetadata",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteMetadata"
        })


#endif

-- method Repo::write_metadata_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expected_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "If provided, validate content against this checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Metadata" , 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 "Invoked when metadata is writed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 6
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Data for @callback" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_write_metadata_async" ostree_repo_write_metadata_async :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- expected_checksum : TBasicType TUTF8
    Ptr GVariant ->                         -- object : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Asynchronously store the metadata object /@variant@/.  If provided,
-- the checksum /@expectedChecksum@/ will be verified.
repoWriteMetadataAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> Maybe (T.Text)
    -- ^ /@expectedChecksum@/: If provided, validate content against this checksum
    -> GVariant
    -- ^ /@object@/: Metadata
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: Invoked when metadata is writed
    -> m ()
repoWriteMetadataAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> ObjectType
-> Maybe Text
-> GVariant
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
repoWriteMetadataAsync a
self ObjectType
objtype Maybe Text
expectedChecksum GVariant
object Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
maybeExpectedChecksum <- case Maybe Text
expectedChecksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jExpectedChecksum -> do
            CString
jExpectedChecksum' <- Text -> IO CString
textToCString Text
jExpectedChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedChecksum'
    Ptr GVariant
object' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
object
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
    Ptr Repo
-> CUInt
-> CString
-> Ptr GVariant
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ostree_repo_write_metadata_async Ptr Repo
self' CUInt
objtype' CString
maybeExpectedChecksum Ptr GVariant
object' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
object
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data RepoWriteMetadataAsyncMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> Maybe (T.Text) -> GVariant -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoWriteMetadataAsyncMethodInfo a signature where
    overloadedMethod = repoWriteMetadataAsync

instance O.OverloadedMethodInfo RepoWriteMetadataAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteMetadataAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteMetadataAsync"
        })


#endif

-- method Repo::write_metadata_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "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
--           }
--       , Arg
--           { argCName = "out_csum"
--           , argType = TCArray False 32 (-1) (TBasicType TUInt8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Binary checksum value"
--                 , 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_repo_write_metadata_finish" ostree_repo_write_metadata_finish :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr Word8) ->                      -- out_csum : TCArray False 32 (-1) (TBasicType TUInt8)
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Complete a call to 'GI.OSTree.Objects.Repo.repoWriteMetadataAsync'.
repoWriteMetadataFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@self@/: Repo
    -> b
    -- ^ /@result@/: Result
    -> m (ByteString)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteMetadataFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) =>
a -> b -> m ByteString
repoWriteMetadataFinish a
self b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    Ptr (Ptr Word8)
outCsum <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Word8))
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr AsyncResult
-> Ptr (Ptr Word8)
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_metadata_finish Ptr Repo
self' Ptr AsyncResult
result_' Ptr (Ptr Word8)
outCsum
        Ptr Word8
outCsum' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Word8)
outCsum
        ByteString
outCsum'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Integer
32) Ptr Word8
outCsum'
        forall a. Ptr a -> IO ()
freeMem Ptr Word8
outCsum'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
        forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
outCsum''
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Word8)
outCsum
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteMetadataFinishMethodInfo
instance (signature ~ (b -> m (ByteString)), MonadIO m, IsRepo a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod RepoWriteMetadataFinishMethodInfo a signature where
    overloadedMethod = repoWriteMetadataFinish

instance O.OverloadedMethodInfo RepoWriteMetadataFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteMetadataFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteMetadataFinish"
        })


#endif

-- method Repo::write_metadata_stream_trusted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Store object with this ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_input"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Metadata object stream"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Length, may be 0 for unknown"
--                 , 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_repo_write_metadata_stream_trusted" ostree_repo_write_metadata_stream_trusted :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr Gio.InputStream.InputStream ->      -- object_input : TInterface (Name {namespace = "Gio", name = "InputStream"})
    Word64 ->                               -- length : TBasicType TUInt64
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Store the metadata object /@variant@/; the provided /@checksum@/ is
-- trusted.
repoWriteMetadataStreamTrusted ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@checksum@/: Store object with this ASCII SHA256 checksum
    -> b
    -- ^ /@objectInput@/: Metadata object stream
    -> Word64
    -- ^ /@length@/: Length, may be 0 for unknown
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteMetadataStreamTrusted :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsInputStream b,
 IsCancellable c) =>
a -> ObjectType -> Text -> b -> Word64 -> Maybe c -> m ()
repoWriteMetadataStreamTrusted a
self ObjectType
objtype Text
checksum b
objectInput Word64
length_ Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr InputStream
objectInput' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
objectInput
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr InputStream
-> Word64
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_metadata_stream_trusted Ptr Repo
self' CUInt
objtype' CString
checksum' Ptr InputStream
objectInput' Word64
length_ Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
objectInput
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteMetadataStreamTrustedMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> b -> Word64 -> Maybe (c) -> m ()), MonadIO m, IsRepo a, Gio.InputStream.IsInputStream b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteMetadataStreamTrustedMethodInfo a signature where
    overloadedMethod = repoWriteMetadataStreamTrusted

instance O.OverloadedMethodInfo RepoWriteMetadataStreamTrustedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteMetadataStreamTrusted",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteMetadataStreamTrusted"
        })


#endif

-- method Repo::write_metadata_trusted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "objtype"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "ObjectType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Object type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Store object with this ASCII SHA256 checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "variant"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Metadata object" , 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_repo_write_metadata_trusted" ostree_repo_write_metadata_trusted :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CUInt ->                                -- objtype : TInterface (Name {namespace = "OSTree", name = "ObjectType"})
    CString ->                              -- checksum : TBasicType TUTF8
    Ptr GVariant ->                         -- variant : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Store the metadata object /@variant@/; the provided /@checksum@/ is
-- trusted.
repoWriteMetadataTrusted ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: Repo
    -> OSTree.Enums.ObjectType
    -- ^ /@objtype@/: Object type
    -> T.Text
    -- ^ /@checksum@/: Store object with this ASCII SHA256 checksum
    -> GVariant
    -- ^ /@variant@/: Metadata object
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteMetadataTrusted :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a -> ObjectType -> Text -> GVariant -> Maybe b -> m ()
repoWriteMetadataTrusted a
self ObjectType
objtype Text
checksum GVariant
variant Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let objtype' :: CUInt
objtype' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) ObjectType
objtype
    CString
checksum' <- Text -> IO CString
textToCString Text
checksum
    Ptr GVariant
variant' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
variant
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CUInt
-> CString
-> Ptr GVariant
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_metadata_trusted Ptr Repo
self' CUInt
objtype' CString
checksum' Ptr GVariant
variant' Ptr Cancellable
maybeCancellable
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
variant
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
checksum'
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteMetadataTrustedMethodInfo
instance (signature ~ (OSTree.Enums.ObjectType -> T.Text -> GVariant -> Maybe (b) -> m ()), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoWriteMetadataTrustedMethodInfo a signature where
    overloadedMethod = repoWriteMetadataTrusted

instance O.OverloadedMethodInfo RepoWriteMetadataTrustedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteMetadataTrusted",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteMetadataTrusted"
        })


#endif

-- method Repo::write_mtree
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "mtree"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "MutableTree" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Mutable tree" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_file"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "An #OstreeRepoFile representing @mtree's root."
--                 , 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_repo_write_mtree" ostree_repo_write_mtree :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    Ptr OSTree.MutableTree.MutableTree ->   -- mtree : TInterface (Name {namespace = "OSTree", name = "MutableTree"})
    Ptr (Ptr Gio.File.File) ->              -- out_file : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Write all metadata objects for /@mtree@/ to repo; the resulting
-- /@outFile@/ points to the 'GI.OSTree.Enums.ObjectTypeDirTree' object that
-- the /@mtree@/ represented.
repoWriteMtree ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: Repo
    -> b
    -- ^ /@mtree@/: Mutable tree
    -> Maybe (c)
    -- ^ /@cancellable@/: Cancellable
    -> m (Gio.File.File)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteMtree :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsRepo a, IsMutableTree b,
 IsCancellable c) =>
a -> b -> Maybe c -> m File
repoWriteMtree a
self b
mtree Maybe c
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MutableTree
mtree' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
mtree
    Ptr (Ptr File)
outFile <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gio.File.File))
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> Ptr MutableTree
-> Ptr (Ptr File)
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
ostree_repo_write_mtree Ptr Repo
self' Ptr MutableTree
mtree' Ptr (Ptr File)
outFile Ptr Cancellable
maybeCancellable
        Ptr File
outFile' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr File)
outFile
        File
outFile'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr File -> File
Gio.File.File) Ptr File
outFile'
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
mtree
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr File)
outFile
        forall (m :: * -> *) a. Monad m => a -> m a
return File
outFile''
     ) (do
        forall a. Ptr a -> IO ()
freeMem Ptr (Ptr File)
outFile
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteMtreeMethodInfo
instance (signature ~ (b -> Maybe (c) -> m (Gio.File.File)), MonadIO m, IsRepo a, OSTree.MutableTree.IsMutableTree b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod RepoWriteMtreeMethodInfo a signature where
    overloadedMethod = repoWriteMtree

instance O.OverloadedMethodInfo RepoWriteMtreeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteMtree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteMtree"
        })


#endif

-- method Repo::write_regfile
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "expected_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Expected checksum (SHA-256 hex string)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uid"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gid"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "group id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Unix file mode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_len"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Expected content length"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xattrs"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Extended attributes (GVariant type `(ayay)`)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "OSTree" , name = "ContentWriter" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_write_regfile" ostree_repo_write_regfile :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- expected_checksum : TBasicType TUTF8
    Word32 ->                               -- uid : TBasicType TUInt32
    Word32 ->                               -- gid : TBasicType TUInt32
    Word32 ->                               -- mode : TBasicType TUInt32
    Word64 ->                               -- content_len : TBasicType TUInt64
    Ptr GVariant ->                         -- xattrs : TVariant
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr OSTree.ContentWriter.ContentWriter)

-- | Create an @OstreeContentWriter@ that allows streaming output into
-- the repository.
-- 
-- /Since: 2021.2/
repoWriteRegfile ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a) =>
    a
    -- ^ /@self@/: Repo,
    -> Maybe (T.Text)
    -- ^ /@expectedChecksum@/: Expected checksum (SHA-256 hex string)
    -> Word32
    -- ^ /@uid@/: user id
    -> Word32
    -- ^ /@gid@/: group id
    -> Word32
    -- ^ /@mode@/: Unix file mode
    -> Word64
    -- ^ /@contentLen@/: Expected content length
    -> Maybe (GVariant)
    -- ^ /@xattrs@/: Extended attributes (GVariant type @(ayay)@)
    -> m OSTree.ContentWriter.ContentWriter
    -- ^ __Returns:__ A new writer, or 'P.Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteRegfile :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRepo a) =>
a
-> Maybe Text
-> Word32
-> Word32
-> Word32
-> Word64
-> Maybe GVariant
-> m ContentWriter
repoWriteRegfile a
self Maybe Text
expectedChecksum Word32
uid Word32
gid Word32
mode Word64
contentLen Maybe GVariant
xattrs = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeExpectedChecksum <- case Maybe Text
expectedChecksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jExpectedChecksum -> do
            CString
jExpectedChecksum' <- Text -> IO CString
textToCString Text
jExpectedChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedChecksum'
    Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jXattrs -> do
            Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr ContentWriter
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Word32
-> Word32
-> Word32
-> Word64
-> Ptr GVariant
-> Ptr (Ptr GError)
-> IO (Ptr ContentWriter)
ostree_repo_write_regfile Ptr Repo
self' CString
maybeExpectedChecksum Word32
uid Word32
gid Word32
mode Word64
contentLen Ptr GVariant
maybeXattrs
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoWriteRegfile" Ptr ContentWriter
result
        ContentWriter
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ContentWriter -> ContentWriter
OSTree.ContentWriter.ContentWriter) Ptr ContentWriter
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall (m :: * -> *) a. Monad m => a -> m a
return ContentWriter
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteRegfileMethodInfo
instance (signature ~ (Maybe (T.Text) -> Word32 -> Word32 -> Word32 -> Word64 -> Maybe (GVariant) -> m OSTree.ContentWriter.ContentWriter), MonadIO m, IsRepo a) => O.OverloadedMethod RepoWriteRegfileMethodInfo a signature where
    overloadedMethod = repoWriteRegfile

instance O.OverloadedMethodInfo RepoWriteRegfileMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteRegfile",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteRegfile"
        })


#endif

-- method Repo::write_regfile_inline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "expected_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The expected checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uid"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gid"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Group id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "File mode" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xattrs"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Extended attributes, GVariant of type (ayay)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "buf"
--           , argType = TCArray False (-1) 7 (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "File contents" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TUInt32
--           , 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 = Just "Cancellable" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "len"
--              , argType = TBasicType TUInt32
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_write_regfile_inline" ostree_repo_write_regfile_inline :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- expected_checksum : TBasicType TUTF8
    Word32 ->                               -- uid : TBasicType TUInt32
    Word32 ->                               -- gid : TBasicType TUInt32
    Word32 ->                               -- mode : TBasicType TUInt32
    Ptr GVariant ->                         -- xattrs : TVariant
    Ptr Word8 ->                            -- buf : TCArray False (-1) 7 (TBasicType TUInt8)
    Word32 ->                               -- len : TBasicType TUInt32
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CString

-- | Synchronously create a file object from the provided content.  This API
-- is intended for small files where it is reasonable to buffer the entire
-- content in memory.
-- 
-- Unlike @ostree_repo_write_content()@, if /@expectedChecksum@/ is provided,
-- this function will not check for the presence of the object beforehand.
-- 
-- /Since: 2021.2/
repoWriteRegfileInline ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: repo
    -> Maybe (T.Text)
    -- ^ /@expectedChecksum@/: The expected checksum
    -> Word32
    -- ^ /@uid@/: User id
    -> Word32
    -- ^ /@gid@/: Group id
    -> Word32
    -- ^ /@mode@/: File mode
    -> Maybe (GVariant)
    -- ^ /@xattrs@/: Extended attributes, GVariant of type (ayay)
    -> ByteString
    -- ^ /@buf@/: File contents
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m T.Text
    -- ^ __Returns:__ Checksum (as a hex string) of the committed file /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteRegfileInline :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> Maybe Text
-> Word32
-> Word32
-> Word32
-> Maybe GVariant
-> ByteString
-> Maybe b
-> m Text
repoWriteRegfileInline a
self Maybe Text
expectedChecksum Word32
uid Word32
gid Word32
mode Maybe GVariant
xattrs ByteString
buf Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let len :: Word32
len = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
buf
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeExpectedChecksum <- case Maybe Text
expectedChecksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jExpectedChecksum -> do
            CString
jExpectedChecksum' <- Text -> IO CString
textToCString Text
jExpectedChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedChecksum'
    Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jXattrs -> do
            Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
    Ptr Word8
buf' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
buf
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CString
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Word32
-> Word32
-> Word32
-> Ptr GVariant
-> Ptr Word8
-> Word32
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CString
ostree_repo_write_regfile_inline Ptr Repo
self' CString
maybeExpectedChecksum Word32
uid Word32
gid Word32
mode Ptr GVariant
maybeXattrs Ptr Word8
buf' Word32
len Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoWriteRegfileInline" CString
result
        Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
        forall a. Ptr a -> IO ()
freeMem CString
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem Ptr Word8
buf'
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem Ptr Word8
buf'
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteRegfileInlineMethodInfo
instance (signature ~ (Maybe (T.Text) -> Word32 -> Word32 -> Word32 -> Maybe (GVariant) -> ByteString -> Maybe (b) -> m T.Text), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoWriteRegfileInlineMethodInfo a signature where
    overloadedMethod = repoWriteRegfileInline

instance O.OverloadedMethodInfo RepoWriteRegfileInlineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteRegfileInline",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteRegfileInline"
        })


#endif

-- method Repo::write_symlink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , 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 = "expected_checksum"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The expected checksum"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uid"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "User id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "gid"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Group id" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "xattrs"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Extended attributes, GVariant of type (ayay)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "symlink_target"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Target of the symbolic link"
--                 , 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 TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_write_symlink" ostree_repo_write_symlink :: 
    Ptr Repo ->                             -- self : TInterface (Name {namespace = "OSTree", name = "Repo"})
    CString ->                              -- expected_checksum : TBasicType TUTF8
    Word32 ->                               -- uid : TBasicType TUInt32
    Word32 ->                               -- gid : TBasicType TUInt32
    Ptr GVariant ->                         -- xattrs : TVariant
    CString ->                              -- symlink_target : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CString

-- | Synchronously create a symlink object.
-- 
-- Unlike @ostree_repo_write_content()@, if /@expectedChecksum@/ is provided,
-- this function will not check for the presence of the object beforehand.
-- 
-- /Since: 2021.2/
repoWriteSymlink ::
    (B.CallStack.HasCallStack, MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@self@/: repo
    -> Maybe (T.Text)
    -- ^ /@expectedChecksum@/: The expected checksum
    -> Word32
    -- ^ /@uid@/: User id
    -> Word32
    -- ^ /@gid@/: Group id
    -> Maybe (GVariant)
    -- ^ /@xattrs@/: Extended attributes, GVariant of type (ayay)
    -> T.Text
    -- ^ /@symlinkTarget@/: Target of the symbolic link
    -> Maybe (b)
    -- ^ /@cancellable@/: Cancellable
    -> m T.Text
    -- ^ __Returns:__ Checksum (as a hex string) of the committed file /(Can throw 'Data.GI.Base.GError.GError')/
repoWriteSymlink :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsRepo a, IsCancellable b) =>
a
-> Maybe Text
-> Word32
-> Word32
-> Maybe GVariant
-> Text
-> Maybe b
-> m Text
repoWriteSymlink a
self Maybe Text
expectedChecksum Word32
uid Word32
gid Maybe GVariant
xattrs Text
symlinkTarget Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr Repo
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeExpectedChecksum <- case Maybe Text
expectedChecksum of
        Maybe Text
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just Text
jExpectedChecksum -> do
            CString
jExpectedChecksum' <- Text -> IO CString
textToCString Text
jExpectedChecksum
            forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedChecksum'
    Ptr GVariant
maybeXattrs <- case Maybe GVariant
xattrs of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jXattrs -> do
            Ptr GVariant
jXattrs' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jXattrs
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jXattrs'
    CString
symlinkTarget' <- Text -> IO CString
textToCString Text
symlinkTarget
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        CString
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr Repo
-> CString
-> Word32
-> Word32
-> Ptr GVariant
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CString
ostree_repo_write_symlink Ptr Repo
self' CString
maybeExpectedChecksum Word32
uid Word32
gid Ptr GVariant
maybeXattrs CString
symlinkTarget' Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoWriteSymlink" CString
result
        Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
        forall a. Ptr a -> IO ()
freeMem CString
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
xattrs forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem CString
symlinkTarget'
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedChecksum
        forall a. Ptr a -> IO ()
freeMem CString
symlinkTarget'
     )

#if defined(ENABLE_OVERLOADING)
data RepoWriteSymlinkMethodInfo
instance (signature ~ (Maybe (T.Text) -> Word32 -> Word32 -> Maybe (GVariant) -> T.Text -> Maybe (b) -> m T.Text), MonadIO m, IsRepo a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod RepoWriteSymlinkMethodInfo a signature where
    overloadedMethod = repoWriteSymlink

instance O.OverloadedMethodInfo RepoWriteSymlinkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.OSTree.Objects.Repo.repoWriteSymlink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ostree-1.0.16/docs/GI-OSTree-Objects-Repo.html#v:repoWriteSymlink"
        })


#endif

-- method Repo::create_at
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "dfd"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Directory fd" , 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" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The mode to store the repository in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "options"
--           , argType = TVariant
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a{sv}: See below for accepted keys"
--                 , 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 (TInterface Name { namespace = "OSTree" , name = "Repo" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_create_at" ostree_repo_create_at :: 
    Int32 ->                                -- dfd : TBasicType TInt
    CString ->                              -- path : TBasicType TUTF8
    CUInt ->                                -- mode : TInterface (Name {namespace = "OSTree", name = "RepoMode"})
    Ptr GVariant ->                         -- options : TVariant
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Repo)

-- | This is a file-descriptor relative version of 'GI.OSTree.Objects.Repo.repoCreate'.
-- Create the underlying structure on disk for the repository, and call
-- 'GI.OSTree.Objects.Repo.repoOpenAt' on the result, preparing it for use.
-- 
-- If a repository already exists at /@dfd@/ + /@path@/ (defined by an @objects\/@
-- subdirectory existing), then this function will simply call
-- 'GI.OSTree.Objects.Repo.repoOpenAt'.  In other words, this function cannot be used to change
-- the mode or configuration (@repo\/config@) of an existing repo.
-- 
-- The /@options@/ dict may contain:
-- 
--   - collection-id: s: Set as collection ID in repo\/config (Since 2017.9)
-- 
-- /Since: 2017.10/
repoCreateAt ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    Int32
    -- ^ /@dfd@/: Directory fd
    -> T.Text
    -- ^ /@path@/: Path
    -> OSTree.Enums.RepoMode
    -- ^ /@mode@/: The mode to store the repository in
    -> Maybe (GVariant)
    -- ^ /@options@/: a{sv}: See below for accepted keys
    -> Maybe (a)
    -- ^ /@cancellable@/: Cancellable
    -> m Repo
    -- ^ __Returns:__ A new OSTree repository reference /(Can throw 'Data.GI.Base.GError.GError')/
repoCreateAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Int32 -> Text -> RepoMode -> Maybe GVariant -> Maybe a -> m Repo
repoCreateAt Int32
dfd Text
path RepoMode
mode Maybe GVariant
options Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    CString
path' <- Text -> IO CString
textToCString Text
path
    let mode' :: CUInt
mode' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) RepoMode
mode
    Ptr GVariant
maybeOptions <- case Maybe GVariant
options of
        Maybe GVariant
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just GVariant
jOptions -> do
            Ptr GVariant
jOptions' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
jOptions
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr GVariant
jOptions'
    Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
        Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just a
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Repo
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Int32
-> CString
-> CUInt
-> Ptr GVariant
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr Repo)
ostree_repo_create_at Int32
dfd CString
path' CUInt
mode' Ptr GVariant
maybeOptions Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoCreateAt" Ptr Repo
result
        Repo
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Repo -> Repo
Repo) Ptr Repo
result
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe GVariant
options forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
path'
        forall (m :: * -> *) a. Monad m => a -> m a
return Repo
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
path'
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method Repo::mode_from_string
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "mode"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a repo mode as a string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "out_mode"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "RepoMode" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the corresponding #OstreeRepoMode"
--                 , 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_repo_mode_from_string" ostree_repo_mode_from_string :: 
    CString ->                              -- mode : TBasicType TUTF8
    Ptr CUInt ->                            -- out_mode : TInterface (Name {namespace = "OSTree", name = "RepoMode"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | /No description available in the introspection data./
repoModeFromString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@mode@/: a repo mode as a string
    -> m (OSTree.Enums.RepoMode)
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
repoModeFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m RepoMode
repoModeFromString Text
mode = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    CString
mode' <- Text -> IO CString
textToCString Text
mode
    Ptr CUInt
outMode <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr CUInt -> Ptr (Ptr GError) -> IO CInt
ostree_repo_mode_from_string CString
mode' Ptr CUInt
outMode
        CUInt
outMode' <- forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
outMode
        let outMode'' :: RepoMode
outMode'' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
outMode'
        forall a. Ptr a -> IO ()
freeMem CString
mode'
        forall a. Ptr a -> IO ()
freeMem Ptr CUInt
outMode
        forall (m :: * -> *) a. Monad m => a -> m a
return RepoMode
outMode''
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
mode'
        forall a. Ptr a -> IO ()
freeMem Ptr CUInt
outMode
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method Repo::open_at
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "dfd"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Directory fd" , 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" , 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 (TInterface Name { namespace = "OSTree" , name = "Repo" })
-- throws : True
-- Skip return : False

foreign import ccall "ostree_repo_open_at" ostree_repo_open_at :: 
    Int32 ->                                -- dfd : TBasicType TInt
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Repo)

-- | This combines 'GI.OSTree.Objects.Repo.repoNew' (but using fd-relative access) with
-- 'GI.OSTree.Objects.Repo.repoOpen'.  Use this when you know you should be operating on an
-- already extant repository.  If you want to create one, use 'GI.OSTree.Objects.Repo.repoCreateAt'.
-- 
-- /Since: 2017.10/
repoOpenAt ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    Int32
    -- ^ /@dfd@/: Directory fd
    -> T.Text
    -- ^ /@path@/: Path
    -> Maybe (a)
    -> m Repo
    -- ^ __Returns:__ An accessor object for an OSTree repository located at /@dfd@/ + /@path@/ /(Can throw 'Data.GI.Base.GError.GError')/
repoOpenAt :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Int32 -> Text -> Maybe a -> m Repo
repoOpenAt Int32
dfd Text
path Maybe a
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
        Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just a
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Repo
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Int32
-> CString -> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr Repo)
ostree_repo_open_at Int32
dfd CString
path' Ptr Cancellable
maybeCancellable
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoOpenAt" Ptr Repo
result
        Repo
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Repo -> Repo
Repo) Ptr Repo
result
        forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        forall a. Ptr a -> IO ()
freeMem CString
path'
        forall (m :: * -> *) a. Monad m => a -> m a
return Repo
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
path'
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method Repo::pull_default_console_progress_changed
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "progress"
--           , argType =
--               TInterface Name { namespace = "OSTree" , name = "AsyncProgress" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Async progress" , 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 = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_pull_default_console_progress_changed" ostree_repo_pull_default_console_progress_changed :: 
    Ptr OSTree.AsyncProgress.AsyncProgress -> -- progress : TInterface (Name {namespace = "OSTree", name = "AsyncProgress"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Convenient \"changed\" callback for use with
-- 'GI.OSTree.Objects.AsyncProgress.asyncProgressNewAndConnect' when pulling from a remote
-- repository.
-- 
-- Depending on the state of the t'GI.OSTree.Objects.AsyncProgress.AsyncProgress', either displays a
-- custom status message, or else outstanding fetch progress in bytes\/sec,
-- or else outstanding content or metadata writes to the repository in
-- number of objects.
-- 
-- Compatibility note: this function previously assumed that /@userData@/
-- was a pointer to a @/GSConsole/@ instance.  This is no longer the case,
-- and /@userData@/ is ignored.
repoPullDefaultConsoleProgressChanged ::
    (B.CallStack.HasCallStack, MonadIO m, OSTree.AsyncProgress.IsAsyncProgress a) =>
    a
    -- ^ /@progress@/: Async progress
    -> Ptr ()
    -- ^ /@userData@/: User data
    -> m ()
repoPullDefaultConsoleProgressChanged :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncProgress a) =>
a -> Ptr () -> m ()
repoPullDefaultConsoleProgressChanged a
progress Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncProgress
progress' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
progress
    Ptr AsyncProgress -> Ptr () -> IO ()
ostree_repo_pull_default_console_progress_changed Ptr AsyncProgress
progress' Ptr ()
userData
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
progress
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- XXX Could not generate method Repo::traverse_new_parents
-- Not implemented: GHashTable element of type TVariant unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoTraverseNewParentsMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "traverseNewParents" Repo) => O.OverloadedMethod RepoTraverseNewParentsMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "traverseNewParents" Repo) => O.OverloadedMethodInfo RepoTraverseNewParentsMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- XXX Could not generate method Repo::traverse_new_reachable
-- Not implemented: GHashTable element of type TVariant unsupported.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data RepoTraverseNewReachableMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "traverseNewReachable" Repo) => O.OverloadedMethod RepoTraverseNewReachableMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "traverseNewReachable" Repo) => O.OverloadedMethodInfo RepoTraverseNewReachableMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method Repo::traverse_parents_get_commits
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "parents"
--           , argType = TGHash (TBasicType TPtr) (TBasicType TPtr)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object"
--           , 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 (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "ostree_repo_traverse_parents_get_commits" ostree_repo_traverse_parents_get_commits :: 
    Ptr (GHashTable (Ptr ()) (Ptr ())) ->   -- parents : TGHash (TBasicType TPtr) (TBasicType TPtr)
    Ptr GVariant ->                         -- object : TVariant
    IO (Ptr CString)

-- | Gets all the commits that a certain object belongs to, as recorded
-- by a parents table gotten from ostree_repo_traverse_commit_union_with_parents.
-- 
-- /Since: 2018.5/
repoTraverseParentsGetCommits ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Map.Map (Ptr ()) (Ptr ())
    -> GVariant
    -> m [T.Text]
    -- ^ __Returns:__ An array of checksums for
    -- the commits the key belongs to.
repoTraverseParentsGetCommits :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Map (Ptr ()) (Ptr ()) -> GVariant -> m [Text]
repoTraverseParentsGetCommits Map (Ptr ()) (Ptr ())
parents GVariant
object = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    let parents' :: [(Ptr (), Ptr ())]
parents' = forall k a. Map k a -> [(k, a)]
Map.toList Map (Ptr ()) (Ptr ())
parents
    let parents'' :: [(PtrWrapped (Ptr ()), Ptr ())]
parents'' = forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst forall a. Ptr a -> PtrWrapped (Ptr a)
B.GHT.ptrPackPtr [(Ptr (), Ptr ())]
parents'
    let parents''' :: [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
parents''' = forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond forall a. Ptr a -> PtrWrapped (Ptr a)
B.GHT.ptrPackPtr [(PtrWrapped (Ptr ()), Ptr ())]
parents''
    Ptr (GHashTable (Ptr ()) (Ptr ()))
parents'''' <- forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable forall a. GHashFunc (Ptr a)
gDirectHash forall a. GEqualFunc (Ptr a)
gDirectEqual forall a. Maybe a
Nothing forall a. Maybe a
Nothing [(PtrWrapped (Ptr ()), PtrWrapped (Ptr ()))]
parents'''
    Ptr GVariant
object' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
object
    Ptr CString
result <- Ptr (GHashTable (Ptr ()) (Ptr ()))
-> Ptr GVariant -> IO (Ptr CString)
ostree_repo_traverse_parents_get_commits Ptr (GHashTable (Ptr ()) (Ptr ()))
parents'''' Ptr GVariant
object'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"repoTraverseParentsGetCommits" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
object
    forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr ()) (Ptr ()))
parents''''
    forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
#endif