-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | API library for working with Git repositories
--   
--   <tt>gitlib</tt> is a high-level, lazy and conduit-aware set of
--   abstractions for programming with Git types. Several different
--   backends are available, including one for the libgit2 C library
--   (<a>http://libgit2.github.com</a>) (see <tt>gitlib-libgit2</tt>). The
--   aim is both type-safety and convenience of use for Haskell users,
--   combined with high performance and minimal memory footprint by taking
--   advantage of Haskell's laziness and the conduit library's
--   deterministic resource cleanup.
--   
--   For further information, as well as typical use cases, see
--   <a>Git.Tutorial</a>.
@package gitlib
@version 3.1.3


-- | This module provides a brief introductory tutorial in the
--   "Introduction" section followed by a lengthy discussion of the
--   library's design and idioms.
module Git.Tutorial

module Git.Types
type RawFilePath = ByteString
data RepositoryFacts
RepositoryFacts :: !Bool -> RepositoryFacts
[hasSymbolicReferences] :: RepositoryFacts -> !Bool
type RefName = Text
type CommitAuthor = Text
type CommitEmail = Text
type CommitMessage = Text
type TreeFilePath = RawFilePath

-- | <tt>Repository</tt> is the central point of contact between user code
--   and Git data objects. Every object must belong to some repository.
class (Applicative m, Monad m, MonadThrow m, IsOid (Oid r), Show (Oid r), Eq (Oid r), Ord (Oid r)) => MonadGit r m | m -> r where {
    type family Oid r :: *;
    data family Tree r :: *;
    data family Options r :: *;
}
facts :: MonadGit r m => m RepositoryFacts
parseOid :: MonadGit r m => Text -> m (Oid r)
getRepository :: MonadGit r m => m r
closeRepository :: MonadGit r m => m ()
deleteRepository :: MonadGit r m => m ()
createReference :: MonadGit r m => RefName -> RefTarget r -> m ()
lookupReference :: MonadGit r m => RefName -> m (Maybe (RefTarget r))
updateReference :: MonadGit r m => RefName -> RefTarget r -> m ()
deleteReference :: MonadGit r m => RefName -> m ()
sourceReferences :: MonadGit r m => ConduitT i RefName m ()
lookupObject :: MonadGit r m => Oid r -> m (Object r m)
existsObject :: MonadGit r m => Oid r -> m Bool
sourceObjects :: MonadGit r m => Maybe (CommitOid r) -> CommitOid r -> Bool -> ConduitT i (ObjectOid r) m ()
lookupCommit :: MonadGit r m => CommitOid r -> m (Commit r)
lookupTree :: MonadGit r m => TreeOid r -> m (Tree r)
lookupBlob :: MonadGit r m => BlobOid r -> m (Blob r m)
lookupTag :: MonadGit r m => TagOid r -> m (Tag r)
readIndex :: MonadGit r m => TreeT r m ()
writeIndex :: MonadGit r m => TreeT r m ()
newTreeBuilder :: MonadGit r m => Maybe (Tree r) -> m (TreeBuilder r m)
treeOid :: MonadGit r m => Tree r -> m (TreeOid r)
treeEntry :: MonadGit r m => Tree r -> TreeFilePath -> m (Maybe (TreeEntry r))
sourceTreeEntries :: MonadGit r m => Tree r -> ConduitT i (TreeFilePath, TreeEntry r) m ()
diffContentsWithTree :: MonadGit r m => ConduitT () (Either TreeFilePath ByteString) m () -> Tree r -> ConduitT i ByteString m ()
hashContents :: MonadGit r m => BlobContents m -> m (BlobOid r)
createBlob :: MonadGit r m => BlobContents m -> m (BlobOid r)
createCommit :: MonadGit r m => [CommitOid r] -> TreeOid r -> Signature -> Signature -> CommitMessage -> Maybe RefName -> m (Commit r)
createTag :: MonadGit r m => CommitOid r -> Signature -> CommitMessage -> Text -> m (Tag r)
data RepositoryOptions
RepositoryOptions :: !FilePath -> !Maybe FilePath -> !Bool -> !Bool -> RepositoryOptions
[repoPath] :: RepositoryOptions -> !FilePath
[repoWorkingDir] :: RepositoryOptions -> !Maybe FilePath
[repoIsBare] :: RepositoryOptions -> !Bool
[repoAutoCreate] :: RepositoryOptions -> !Bool
defaultRepositoryOptions :: RepositoryOptions
data RepositoryFactory n m r
RepositoryFactory :: (RepositoryOptions -> m r) -> (forall a. r -> n a -> m a) -> RepositoryFactory n m r
[openRepository] :: RepositoryFactory n m r -> RepositoryOptions -> m r
[runRepository] :: RepositoryFactory n m r -> forall a. r -> n a -> m a
class IsOid o
renderOid :: IsOid o => o -> Text
renderObjOid :: IsOid o => Tagged a o -> Text
type BlobOid r = Tagged r (Oid r)
type TreeOid r = Tagged (Tree r) (Oid r)
type CommitOid r = Tagged (Commit r) (Oid r)
type TagOid r = Tagged (Tag r) (Oid r)
data ObjectOid r
BlobObjOid :: !BlobOid r -> ObjectOid r
TreeObjOid :: !TreeOid r -> ObjectOid r
CommitObjOid :: !CommitOid r -> ObjectOid r
TagObjOid :: !TagOid r -> ObjectOid r
parseObjOid :: MonadGit r m => forall o. Text -> m (Tagged o (Oid r))
copyOid :: (MonadGit r m, MonadGit s n) => Oid r -> n (Oid s)
newtype SHA
SHA :: ByteString -> SHA
[getSHA] :: SHA -> ByteString
shaToText :: SHA -> Text
textToSha :: MonadFail m => Text -> m SHA
data Blob r m
Blob :: !BlobOid r -> !BlobContents m -> Blob r m
[blobOid] :: Blob r m -> !BlobOid r
[blobContents] :: Blob r m -> !BlobContents m
type ByteSource m = ConduitT () ByteString m ()
data BlobContents m
BlobString :: !ByteString -> BlobContents m
BlobStringLazy :: !ByteString -> BlobContents m
BlobStream :: !ByteSource m -> BlobContents m
BlobSizedStream :: !ByteSource m -> !Int -> BlobContents m
data BlobKind
PlainBlob :: BlobKind
ExecutableBlob :: BlobKind
SymlinkBlob :: BlobKind
newtype TreeT r m a
TreeT :: StateT (TreeBuilder r m) m a -> TreeT r m a
[runTreeT] :: TreeT r m a -> StateT (TreeBuilder r m) m a
data TreeEntry r
BlobEntry :: !BlobOid r -> !BlobKind -> TreeEntry r
[blobEntryOid] :: TreeEntry r -> !BlobOid r
[blobEntryKind] :: TreeEntry r -> !BlobKind
TreeEntry :: !TreeOid r -> TreeEntry r
[treeEntryOid] :: TreeEntry r -> !TreeOid r
CommitEntry :: !CommitOid r -> TreeEntry r
[commitEntryOid] :: TreeEntry r -> !CommitOid r
treeEntryToOid :: TreeEntry r -> Oid r
data TreeBuilder r m
TreeBuilder :: Maybe (TreeOid r) -> HashMap TreeFilePath (TreeBuilder r m) -> (Maybe (Tree r) -> m (TreeBuilder r m)) -> (TreeBuilder r m -> m (ModifiedBuilder r m, TreeOid r)) -> (TreeFilePath -> m (Maybe (TreeEntry r))) -> m Int -> (TreeBuilder r m -> TreeFilePath -> TreeEntry r -> m (ModifiedBuilder r m)) -> (TreeBuilder r m -> TreeFilePath -> m (ModifiedBuilder r m)) -> TreeBuilder r m
[mtbBaseTreeOid] :: TreeBuilder r m -> Maybe (TreeOid r)
[mtbPendingUpdates] :: TreeBuilder r m -> HashMap TreeFilePath (TreeBuilder r m)
[mtbNewBuilder] :: TreeBuilder r m -> Maybe (Tree r) -> m (TreeBuilder r m)
[mtbWriteContents] :: TreeBuilder r m -> TreeBuilder r m -> m (ModifiedBuilder r m, TreeOid r)
[mtbLookupEntry] :: TreeBuilder r m -> TreeFilePath -> m (Maybe (TreeEntry r))
[mtbEntryCount] :: TreeBuilder r m -> m Int
[mtbPutEntry] :: TreeBuilder r m -> TreeBuilder r m -> TreeFilePath -> TreeEntry r -> m (ModifiedBuilder r m)
[mtbDropEntry] :: TreeBuilder r m -> TreeBuilder r m -> TreeFilePath -> m (ModifiedBuilder r m)
data ModifiedBuilder r m
ModifiedBuilder :: TreeBuilder r m -> ModifiedBuilder r m
BuilderUnchanged :: TreeBuilder r m -> ModifiedBuilder r m
fromBuilderMod :: ModifiedBuilder r m -> TreeBuilder r m
data Commit r
Commit :: !CommitOid r -> ![CommitOid r] -> !TreeOid r -> !Signature -> !Signature -> !CommitMessage -> !Text -> Commit r
[commitOid] :: Commit r -> !CommitOid r
[commitParents] :: Commit r -> ![CommitOid r]
[commitTree] :: Commit r -> !TreeOid r
[commitAuthor] :: Commit r -> !Signature
[commitCommitter] :: Commit r -> !Signature
[commitLog] :: Commit r -> !CommitMessage
[commitEncoding] :: Commit r -> !Text
sourceCommitParents :: MonadGit r m => Commit r -> ConduitT i (Commit r) m ()
lookupCommitParents :: MonadGit r m => Commit r -> m [Commit r]
data Signature
Signature :: !CommitAuthor -> !CommitEmail -> !ZonedTime -> Signature
[signatureName] :: Signature -> !CommitAuthor
[signatureEmail] :: Signature -> !CommitEmail
[signatureWhen] :: Signature -> !ZonedTime
defaultSignature :: Signature
data Tag r
Tag :: !TagOid r -> !CommitOid r -> Tag r
[tagOid] :: Tag r -> !TagOid r
[tagCommit] :: Tag r -> !CommitOid r
data Object r m
BlobObj :: !Blob r m -> Object r m
TreeObj :: !Tree r -> Object r m
CommitObj :: !Commit r -> Object r m
TagObj :: !Tag r -> Object r m
objectOid :: MonadGit r m => Object r m -> m (Oid r)
loadObject :: MonadGit r m => ObjectOid r -> m (Object r m)
objectToObjOid :: MonadGit r m => Object r m -> m (ObjectOid r)
untagObjOid :: ObjectOid r -> Oid r
data RefTarget (r :: *)
RefObj :: !Oid r -> RefTarget (r :: *)
RefSymbolic :: !RefName -> RefTarget (r :: *)
commitRefTarget :: Commit r -> RefTarget r
data ModificationKind
Unchanged :: ModificationKind
Modified :: ModificationKind
Added :: ModificationKind
Deleted :: ModificationKind
TypeChanged :: ModificationKind
data MergeStatus
NoConflict :: MergeStatus
BothModified :: MergeStatus
LeftModifiedRightDeleted :: MergeStatus
LeftDeletedRightModified :: MergeStatus
BothAdded :: MergeStatus
LeftModifiedRightTypeChanged :: MergeStatus
LeftTypeChangedRightModified :: MergeStatus
LeftDeletedRightTypeChanged :: MergeStatus
LeftTypeChangedRightDeleted :: MergeStatus
BothTypeChanged :: MergeStatus
mergeStatus :: ModificationKind -> ModificationKind -> MergeStatus
data MergeResult r
MergeSuccess :: CommitOid r -> MergeResult r
[mergeCommit] :: MergeResult r -> CommitOid r
MergeConflicted :: CommitOid r -> CommitOid r -> CommitOid r -> Map TreeFilePath (ModificationKind, ModificationKind) -> MergeResult r
[mergeCommit] :: MergeResult r -> CommitOid r
[mergeHeadLeft] :: MergeResult r -> CommitOid r
[mergeHeadRight] :: MergeResult r -> CommitOid r
[mergeConflicts] :: MergeResult r -> Map TreeFilePath (ModificationKind, ModificationKind)
copyMergeResult :: (MonadGit r m, IsOid (Oid s)) => MergeResult s -> m (MergeResult r)

-- | There is a separate <a>GitException</a> for each possible failure when
--   interacting with the Git repository.
data GitException
BackendError :: Text -> GitException
GitError :: Text -> GitException
RepositoryNotExist :: GitException
RepositoryInvalid :: GitException
RepositoryCannotAccess :: Text -> GitException
BlobCreateFailed :: Text -> GitException
BlobEmptyCreateFailed :: GitException
BlobEncodingUnknown :: Text -> GitException
BlobLookupFailed :: GitException
DiffBlobFailed :: Text -> GitException
DiffPrintToPatchFailed :: Text -> GitException
DiffTreeToIndexFailed :: Text -> GitException
IndexAddFailed :: TreeFilePath -> Text -> GitException
IndexCreateFailed :: Text -> GitException
PathEncodingError :: Text -> GitException
PushNotFastForward :: Text -> GitException
TagLookupFailed :: Text -> GitException
TranslationException :: Text -> GitException
TreeCreateFailed :: Text -> GitException
TreeBuilderCreateFailed :: GitException
TreeBuilderInsertFailed :: TreeFilePath -> GitException
TreeBuilderRemoveFailed :: TreeFilePath -> GitException
TreeBuilderWriteFailed :: Text -> GitException
TreeLookupFailed :: GitException
TreeCannotTraverseBlob :: GitException
TreeCannotTraverseCommit :: GitException
TreeEntryLookupFailed :: TreeFilePath -> GitException
TreeUpdateFailed :: GitException
TreeWalkFailed :: Text -> GitException
TreeEmptyCreateFailed :: GitException
CommitCreateFailed :: GitException
CommitLookupFailed :: Text -> GitException
ReferenceCreateFailed :: RefName -> GitException
ReferenceDeleteFailed :: RefName -> GitException
RefCannotCreateFromPartialOid :: GitException
ReferenceListingFailed :: Text -> GitException
ReferenceLookupFailed :: RefName -> GitException
ObjectLookupFailed :: Text -> Int -> GitException
ObjectRefRequiresFullOid :: GitException
OidCopyFailed :: GitException
OidParseFailed :: Text -> GitException
QuotaHardLimitExceeded :: Int -> Int -> GitException
instance GHC.Show.Show Git.Types.RepositoryFacts
instance GHC.Read.Read Git.Types.SHA
instance GHC.Classes.Ord Git.Types.SHA
instance GHC.Classes.Eq Git.Types.SHA
instance GHC.Enum.Enum Git.Types.BlobKind
instance GHC.Classes.Eq Git.Types.BlobKind
instance GHC.Show.Show Git.Types.BlobKind
instance GHC.Show.Show Git.Types.Signature
instance GHC.Read.Read Git.Types.ModificationKind
instance GHC.Show.Show Git.Types.ModificationKind
instance GHC.Enum.Enum Git.Types.ModificationKind
instance GHC.Classes.Ord Git.Types.ModificationKind
instance GHC.Classes.Eq Git.Types.ModificationKind
instance GHC.Read.Read Git.Types.MergeStatus
instance GHC.Show.Show Git.Types.MergeStatus
instance GHC.Enum.Enum Git.Types.MergeStatus
instance GHC.Classes.Ord Git.Types.MergeStatus
instance GHC.Classes.Eq Git.Types.MergeStatus
instance GHC.Show.Show Git.Types.GitException
instance GHC.Classes.Eq Git.Types.GitException
instance GHC.Exception.Type.Exception Git.Types.GitException
instance GHC.Base.Semigroup (Git.Types.ModifiedBuilder r m)
instance GHC.Base.Monoid (Git.Types.ModifiedBuilder r m)
instance GHC.Classes.Eq (Git.Types.BlobContents m)
instance Git.Types.IsOid Git.Types.SHA
instance GHC.Show.Show Git.Types.SHA
instance Data.Hashable.Class.Hashable Git.Types.SHA

module Git.Tree.Builder
data TreeT r m a
data TreeBuilder r m
TreeBuilder :: Maybe (TreeOid r) -> HashMap TreeFilePath (TreeBuilder r m) -> (Maybe (Tree r) -> m (TreeBuilder r m)) -> (TreeBuilder r m -> m (ModifiedBuilder r m, TreeOid r)) -> (TreeFilePath -> m (Maybe (TreeEntry r))) -> m Int -> (TreeBuilder r m -> TreeFilePath -> TreeEntry r -> m (ModifiedBuilder r m)) -> (TreeBuilder r m -> TreeFilePath -> m (ModifiedBuilder r m)) -> TreeBuilder r m
[mtbBaseTreeOid] :: TreeBuilder r m -> Maybe (TreeOid r)
[mtbPendingUpdates] :: TreeBuilder r m -> HashMap TreeFilePath (TreeBuilder r m)
[mtbNewBuilder] :: TreeBuilder r m -> Maybe (Tree r) -> m (TreeBuilder r m)
[mtbWriteContents] :: TreeBuilder r m -> TreeBuilder r m -> m (ModifiedBuilder r m, TreeOid r)
[mtbLookupEntry] :: TreeBuilder r m -> TreeFilePath -> m (Maybe (TreeEntry r))
[mtbEntryCount] :: TreeBuilder r m -> m Int
[mtbPutEntry] :: TreeBuilder r m -> TreeBuilder r m -> TreeFilePath -> TreeEntry r -> m (ModifiedBuilder r m)
[mtbDropEntry] :: TreeBuilder r m -> TreeBuilder r m -> TreeFilePath -> m (ModifiedBuilder r m)
data ModifiedBuilder r m
ModifiedBuilder :: TreeBuilder r m -> ModifiedBuilder r m
BuilderUnchanged :: TreeBuilder r m -> ModifiedBuilder r m
createTree :: MonadGit r m => TreeT r m a -> m (TreeOid r)
withNewTree :: MonadGit r m => TreeT r m a -> m (a, TreeOid r)
mutateTree :: MonadGit r m => Tree r -> TreeT r m a -> m (TreeOid r)
mutateTreeOid :: MonadGit r m => TreeOid r -> TreeT r m a -> m (TreeOid r)
currentTree :: MonadGit r m => TreeT r m (Tree r)
currentTreeOid :: MonadGit r m => TreeT r m (TreeOid r)
withTree :: MonadGit r m => Tree r -> TreeT r m a -> m (a, TreeOid r)
withTreeOid :: MonadGit r m => TreeOid r -> TreeT r m a -> m (a, TreeOid r)
dropEntry :: MonadGit r m => TreeFilePath -> TreeT r m ()
getEntry :: MonadGit r m => TreeFilePath -> TreeT r m (Maybe (TreeEntry r))
putBlob :: MonadGit r m => TreeFilePath -> BlobOid r -> TreeT r m ()
putBlob' :: MonadGit r m => TreeFilePath -> BlobOid r -> BlobKind -> TreeT r m ()
putCommit :: MonadGit r m => TreeFilePath -> CommitOid r -> TreeT r m ()
putEntry :: MonadGit r m => TreeFilePath -> TreeEntry r -> TreeT r m ()
putTree :: MonadGit r m => TreeFilePath -> TreeOid r -> TreeT r m ()
treeEntry :: MonadGit r m => Tree r -> TreeFilePath -> m (Maybe (TreeEntry r))
data ModifyTreeResult r
TreeEntryNotFound :: ModifyTreeResult r
TreeEntryDeleted :: ModifyTreeResult r
TreeEntryPersistent :: TreeEntry r -> ModifyTreeResult r
TreeEntryMutated :: TreeEntry r -> ModifyTreeResult r
fromModifyTreeResult :: ModifyTreeResult r -> Maybe (TreeEntry r)
toModifyTreeResult :: (TreeEntry r -> ModifyTreeResult r) -> Maybe (TreeEntry r) -> ModifyTreeResult r
emptyTreeId :: Text
instance GHC.Show.Show Git.Tree.Builder.BuilderAction
instance GHC.Classes.Eq Git.Tree.Builder.BuilderAction
instance GHC.Base.Functor m => GHC.Base.Functor (Git.Types.TreeT r m)
instance GHC.Base.Monad m => GHC.Base.Monad (Git.Types.TreeT r m)
instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Git.Types.TreeT r m)
instance (GHC.Base.Functor m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Git.Types.TreeT r m)
instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Git.Types.TreeT r m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Git.Types.TreeT r m)
instance Control.Monad.Trans.Class.MonadTrans (Git.Types.TreeT r)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Git.Types.TreeT r m)

module Git.Repository
withNewRepository :: (MonadGit r n, MonadUnliftIO n, MonadUnliftIO m) => RepositoryFactory n m r -> FilePath -> n a -> m a
withNewRepository' :: (MonadGit r n, MonadUnliftIO n, MonadUnliftIO m) => RepositoryFactory n m r -> FilePath -> n a -> m a
withRepository' :: (MonadGit r n, MonadUnliftIO n, MonadUnliftIO m) => RepositoryFactory n m r -> RepositoryOptions -> n a -> m a
withRepository :: (MonadGit r n, MonadUnliftIO n, MonadUnliftIO m) => RepositoryFactory n m r -> FilePath -> n a -> m a

module Git.Reference
listReferences :: MonadGit r m => m [RefName]
resolveReference :: MonadGit r m => RefName -> m (Maybe (Oid r))
referenceToOid :: MonadGit r m => RefTarget r -> m (Maybe (Oid r))

module Git.Object
listObjects :: MonadGit r m => Maybe (CommitOid r) -> CommitOid r -> Bool -> m [ObjectOid r]
traverseObjects :: MonadGit r m => (ObjectOid r -> m a) -> CommitOid r -> m [a]
traverseObjects_ :: MonadGit r m => (ObjectOid r -> m ()) -> CommitOid r -> m ()

-- | Given a list of objects (commit and top-level trees) return by
--   <a>listObjects</a>, expand it to include all subtrees and blobs as
--   well. Ordering is preserved.
expandTreeObjects :: MonadGit r m => ConduitT (ObjectOid r) (ObjectOid r) m ()
listAllObjects :: MonadGit r m => Maybe (CommitOid r) -> CommitOid r -> m [ObjectOid r]

module Git.Blob
createBlobUtf8 :: MonadGit r m => Text -> m (BlobOid r)
catBlob :: MonadGit r m => BlobOid r -> m ByteString
catBlobLazy :: MonadGit r m => BlobOid r -> m ByteString
catBlobUtf8 :: MonadGit r m => BlobOid r -> m Text
blobContentsToByteString :: MonadGit r m => BlobContents m -> m ByteString
blobToByteString :: MonadGit r m => Blob r m -> m ByteString
blobContentsToLazyByteString :: MonadGit r m => BlobContents m -> m ByteString
blobToLazyByteString :: MonadGit r m => Blob r m -> m ByteString
writeBlob :: (MonadGit r m, MonadIO m, MonadResource m) => FilePath -> BlobContents m -> m ()
treeBlobEntries :: MonadGit r m => Tree r -> m [(TreeFilePath, BlobOid r, BlobKind)]
sourceTreeBlobEntries :: MonadGit r m => Tree r -> ConduitT i (TreeFilePath, BlobOid r, BlobKind) m ()
copyBlob :: (MonadGit r m, MonadGit s (t m), MonadTrans t) => BlobOid r -> HashSet Text -> t m (BlobOid s, HashSet Text)

module Git.Tree
listTreeEntries :: MonadGit r m => Tree r -> m [(TreeFilePath, TreeEntry r)]
copyTreeEntry :: (MonadGit r m, MonadGit s (t m), MonadTrans t) => TreeEntry r -> HashSet Text -> t m (TreeEntry s, HashSet Text)
copyTree :: (MonadGit r m, MonadGit s (t m), MonadTrans t) => TreeOid r -> HashSet Text -> t m (TreeOid s, HashSet Text)

module Git.Commit
commitTreeEntry :: MonadGit r m => Commit r -> TreeFilePath -> m (Maybe (TreeEntry r))
copyCommitOid :: (IsOid (Oid r), MonadGit s n) => CommitOid r -> n (CommitOid s)
copyCommit :: (MonadGit r m, MonadGit s (t m), MonadTrans t) => CommitOid r -> Maybe RefName -> HashSet Text -> t m (CommitOid s, HashSet Text)
listCommits :: MonadGit r m => Maybe (CommitOid r) -> CommitOid r -> m [CommitOid r]
traverseCommits :: MonadGit r m => (CommitOid r -> m a) -> CommitOid r -> m [a]
traverseCommits_ :: MonadGit r m => (CommitOid r -> m ()) -> CommitOid r -> m ()

module Git.Commit.Push

-- | Fast-forward push a reference between repositories using a recursive
--   copy. This can be extremely slow, but always works no matter which two
--   backends are being used. It should be considered a matter of last
--   resort, or for objects sets that are known to be small.
pushCommit :: (MonadGit r m, MonadGit s (t m), MonadTrans t) => CommitOid r -> Text -> t m (CommitOid s)
copyRepository :: (MonadGit r m, MonadUnliftIO m, MonadGit s (t m), MonadTrans t, MonadUnliftIO (t m)) => RepositoryFactory (t m) m s -> Maybe (CommitOid r) -> Text -> FilePath -> Bool -> m ()


-- | Interface for working with Git repositories.
module Git

module Git.Tree.Working
data FileEntry m
FileEntry :: UTCTime -> BlobOid m -> BlobKind -> BlobOid m -> FileEntry m
[fileModTime] :: FileEntry m -> UTCTime
[fileBlobOid] :: FileEntry m -> BlobOid m
[fileBlobKind] :: FileEntry m -> BlobKind
[fileChecksum] :: FileEntry m -> BlobOid m
type FileTree m = HashMap TreeFilePath (FileEntry m)
readFileTree :: (MonadGit r m, MonadUnliftIO m) => RefName -> FilePath -> Bool -> m (FileTree r)
readFileTree' :: (MonadGit r m, MonadUnliftIO m) => Tree r -> FilePath -> Bool -> m (FileTree r)
readModTime :: (MonadIO m, MonadGit r m) => FilePath -> Bool -> FilePath -> BlobOid r -> BlobKind -> m (Maybe (FileEntry r))

module Git.Tree.Builder.Pure
type EntryHashMap r = HashMap TreeFilePath (TreeEntry r)

-- | Create a new, empty tree.
--   
--   Since empty trees cannot exist in Git, attempting to write out an
--   empty tree is a no-op.
newPureTreeBuilder :: MonadGit r m => (Tree r -> m (EntryHashMap r)) -> (EntryHashMap r -> m (TreeOid r)) -> Maybe (Tree r) -> m (TreeBuilder r m)

module Git.Utils

module Git.Working
checkoutFiles :: (MonadGit r m, MonadResource m) => FilePath -> Tree r -> (TreeFilePath -> Either String FilePath) -> Bool -> m ()