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


-- | libgit2-glib bindings
--   
--   Bindings for libgit2-glib, autogenerated by haskell-gi.
@package gi-ggit
@version 1.0.9


-- | Build time configuration used during code generation.
module GI.Ggit.Config

-- | Overrides used when generating these bindings.
overrides :: Text


module GI.Ggit.Enums

-- | The type of a branch.
data BranchType

-- | specifies a local branch.
BranchTypeLocal :: BranchType

-- | specifies a remote branch.
BranchTypeRemote :: BranchType

-- | Catch-all for unknown values
AnotherBranchType :: Int -> BranchType

-- | <i>No description available in the introspection data.</i>
data CloneLocal

-- | <i>No description available in the introspection data.</i>
CloneLocalAuto :: CloneLocal

-- | <i>No description available in the introspection data.</i>
CloneLocalLocal :: CloneLocal

-- | <i>No description available in the introspection data.</i>
CloneLocalNoLocal :: CloneLocal

-- | <i>No description available in the introspection data.</i>
CloneLocalNoLinks :: CloneLocal

-- | Catch-all for unknown values
AnotherCloneLocal :: Int -> CloneLocal

-- | Priority level of a config file. These priority levels correspond to
--   the natural escalation logic (from higher to lower) when searching for
--   config entries in git.git.
data ConfigLevel

-- | System-wide on Windows, for compatibility with portable git.
ConfigLevelProgramdata :: ConfigLevel

-- | System-wide configuration file.
ConfigLevelSystem :: ConfigLevel

-- | XDG compatible configuration file (.config/git/config).
ConfigLevelXdg :: ConfigLevel

-- | User-specific configuration file, also called Global configuration
--   file.
ConfigLevelGlobal :: ConfigLevel

-- | Repository specific configuration file.
ConfigLevelLocal :: ConfigLevel

-- | Application specific configuration file; freely defined by
--   applications.
ConfigLevelApp :: ConfigLevel

-- | Represents the highest level of a config file.
ConfigLevelHighest :: ConfigLevel

-- | Catch-all for unknown values
AnotherConfigLevel :: Int -> ConfigLevel

-- | Describes the type of change the delta is.
data DeltaType

-- | unmodified.
DeltaTypeUnmodified :: DeltaType

-- | added.
DeltaTypeAdded :: DeltaType

-- | deleted.
DeltaTypeDeleted :: DeltaType

-- | modified.
DeltaTypeModified :: DeltaType

-- | renamed.
DeltaTypeRenamed :: DeltaType

-- | copied.
DeltaTypeCopied :: DeltaType

-- | ignored.
DeltaTypeIgnored :: DeltaType

-- | untracked.
DeltaTypeUntracked :: DeltaType

-- | Catch-all for unknown values
AnotherDeltaType :: Int -> DeltaType

-- | When producing a binary diff, the binary data returned will be either
--   the deflated full ("literal") contents of the file, or the deflated
--   binary delta between the two sides (whichever is smaller).
data DiffBinaryType

-- | <i>No description available in the introspection data.</i>
DiffBinaryTypeNone :: DiffBinaryType

-- | <i>No description available in the introspection data.</i>
DiffBinaryTypeLiteral :: DiffBinaryType

-- | <i>No description available in the introspection data.</i>
DiffBinaryTypeDelta :: DiffBinaryType

-- | Catch-all for unknown values
AnotherDiffBinaryType :: Int -> DiffBinaryType

-- | Possible output formats for diff data.
data DiffFormatType

-- | full git diff.
DiffFormatTypePatch :: DiffFormatType

-- | just the file headers of patch.
DiffFormatTypePatchHeader :: DiffFormatType

-- | like git diff --raw.
DiffFormatTypeRaw :: DiffFormatType

-- | like git diff --name-only.
DiffFormatTypeNameOnly :: DiffFormatType

-- | like git diff --name-status.
DiffFormatTypeNameStatus :: DiffFormatType

-- | Catch-all for unknown values
AnotherDiffFormatType :: Int -> DiffFormatType

-- | These values describe where a line came from and will be passed to the
--   <a>DiffLineCallback</a> when iterating over a diff.
--   
--   The <tt><i>GGIT_DIFF_LINE_FILE_HDR</i></tt>,
--   <tt><i>GGIT_DIFF_LINE_HUNK_HDR</i></tt> and
--   <tt><i>GGIT_DIFF_LINE_BINARY</i></tt> values are only sent when the
--   diff is being printed.
data DiffLineType

-- | line is part of the context.
DiffLineTypeContext :: DiffLineType

-- | line that was added.
DiffLineTypeAddition :: DiffLineType

-- | line that was removed.
DiffLineTypeDeletion :: DiffLineType

-- | Both files have no LF at end.
DiffLineTypeContextEofnl :: DiffLineType

-- | LF was added at end of file.
DiffLineTypeAddEofnl :: DiffLineType

-- | LF was removed at end of file.
DiffLineTypeDelEofnl :: DiffLineType

-- | the file header.
DiffLineTypeFileHdr :: DiffLineType

-- | the hunk header.
DiffLineTypeHunkHdr :: DiffLineType

-- | is binary.
DiffLineTypeBinary :: DiffLineType

-- | Catch-all for unknown values
AnotherDiffLineType :: Int -> DiffLineType

-- | <i>No description available in the introspection data.</i>
data Direction

-- | <i>No description available in the introspection data.</i>
DirectionFetch :: Direction

-- | <i>No description available in the introspection data.</i>
DirectionPush :: Direction

-- | Catch-all for unknown values
AnotherDirection :: Int -> Direction

-- | Error codes for the <tt><i>GGIT_ERROR</i></tt> error domain.
data Error

-- | A generic error for when an operation fails.
ErrorGitError :: Error

-- | Input does not exist in the scope searched.
ErrorNotfound :: Error

-- | A reference with this name already exists.
ErrorExists :: Error

-- | The given error is ambiguous.
ErrorAmbiguous :: Error

-- | The buffer is too short.
ErrorBufs :: Error

-- | Skip and passthrough the given ODB backend.
ErrorPassthrough :: Error

-- | The iteration has finished.
ErrorIterover :: Error

-- | Catch-all for unknown values
AnotherError :: Int -> Error

-- | Catch exceptions of type <a>Error</a>. This is a specialized version
--   of <a>catchGErrorJustDomain</a>.
catchError :: IO a -> (Error -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>Error</a>. This is a specialized version
--   of <a>handleGErrorJustDomain</a>.
handleError :: (Error -> GErrorMessage -> IO a) -> IO a -> IO a

-- | <i>No description available in the introspection data.</i>
data FileMode

-- | <i>No description available in the introspection data.</i>
FileModeUnreadable :: FileMode

-- | <i>No description available in the introspection data.</i>
FileModeTree :: FileMode

-- | <i>No description available in the introspection data.</i>
FileModeBlob :: FileMode

-- | <i>No description available in the introspection data.</i>
FileModeBlobExecutable :: FileMode

-- | <i>No description available in the introspection data.</i>
FileModeLink :: FileMode

-- | <i>No description available in the introspection data.</i>
FileModeCommit :: FileMode

-- | Catch-all for unknown values
AnotherFileMode :: Int -> FileMode

-- | <i>No description available in the introspection data.</i>
data MergeFileFavor

-- | <i>No description available in the introspection data.</i>
MergeFileFavorNormal :: MergeFileFavor

-- | <i>No description available in the introspection data.</i>
MergeFileFavorOurs :: MergeFileFavor

-- | <i>No description available in the introspection data.</i>
MergeFileFavorTheirs :: MergeFileFavor

-- | <i>No description available in the introspection data.</i>
MergeFileFavorUnion :: MergeFileFavor

-- | Catch-all for unknown values
AnotherMergeFileFavor :: Int -> MergeFileFavor

-- | Valid stages for pack building.
data PackbuilderStage

-- | adding objects.
PackbuilderStageAddingObjects :: PackbuilderStage

-- | deltafication.
PackbuilderStageDeltafication :: PackbuilderStage

-- | Catch-all for unknown values
AnotherPackbuilderStage :: Int -> PackbuilderStage

-- | The type of proxy to use.
data ProxyType

-- | Do not attempt to connect through a proxy.
ProxyTypeNone :: ProxyType

-- | Try to auto-detect the proxy from the git configuration.
ProxyTypeAuto :: ProxyType

-- | Connect via the URL given in the options.
ProxyTypeSpecified :: ProxyType

-- | Catch-all for unknown values
AnotherProxyType :: Int -> ProxyType

-- | Type of rebase operation in-progress.
data RebaseOperationType

-- | The given commit is to be cherry-picked. The client should commit the
--   changes and continue if there are no conflicts.
RebaseOperationTypePick :: RebaseOperationType

-- | The given commit is to be cherry-picked, but the client should prompt
--   the user to provide an updated commit message.
RebaseOperationTypeReword :: RebaseOperationType

-- | The given commit is to be cherry-picked, but the client should stop to
--   allow the user to edit the changes before committing them.
RebaseOperationTypeEdit :: RebaseOperationType

-- | The given commit is to be squashed into the previous commit. The
--   commit message will be merged with the previous message.
RebaseOperationTypeSquash :: RebaseOperationType

-- | The given commit is to be squashed into the previous commit. The
--   commit message from this commit will be discarded.
RebaseOperationTypeFixup :: RebaseOperationType

-- | No commit will be cherry-picked. The client should run the given
--   command and (if successful) continue.
RebaseOperationTypeExec :: RebaseOperationType

-- | Catch-all for unknown values
AnotherRebaseOperationType :: Int -> RebaseOperationType

-- | Describes the type a reference is.
data RefType

-- | An invalid reference.
RefTypeInvalid :: RefType

-- | A reference which points at an object id.
RefTypeOid :: RefType

-- | A reference which points at another reference.
RefTypeSymbolic :: RefType

-- | All reference types.
RefTypeListall :: RefType

-- | Catch-all for unknown values
AnotherRefType :: Int -> RefType

-- | Argument to the completion callback which tells it which operation
--   finished.
data RemoteCompletionType

-- | download.
RemoteCompletionTypeDownload :: RemoteCompletionType

-- | indexing.
RemoteCompletionTypeIndexing :: RemoteCompletionType

-- | error.
RemoteCompletionTypeError :: RemoteCompletionType

-- | Catch-all for unknown values
AnotherRemoteCompletionType :: Int -> RemoteCompletionType

-- | Automatic tag following option
--   
--   Lets us select the --tags option to use.
data RemoteDownloadTagsType

-- | Use the setting from the configuration.
RemoteDownloadTagsTypeUnspecified :: RemoteDownloadTagsType

-- | Ask the server for tags pointing to objects we're already downloading.
RemoteDownloadTagsTypeAuto :: RemoteDownloadTagsType

-- | Don't ask for any tags beyond the refspecs.
RemoteDownloadTagsTypeNone :: RemoteDownloadTagsType

-- | Ask for the all the tags.
RemoteDownloadTagsTypeAll :: RemoteDownloadTagsType

-- | Catch-all for unknown values
AnotherRemoteDownloadTagsType :: Int -> RemoteDownloadTagsType

-- | Describes the type of reset to perform.
data ResetType

-- | The head will be moved to the commit.
ResetTypeSoft :: ResetType

-- | the head will be moved to the commit and the index will be replaced
--   with the content of the commit tree.
ResetTypeMixed :: ResetType

-- | MIXED plus changes in working tree discarded.
ResetTypeHard :: ResetType

-- | Catch-all for unknown values
AnotherResetType :: Int -> ResetType

-- | Show options for <tt><i>ggit_repository_file_status_foreach</i></tt>.
--   Determines which files are included in the status.
data StatusShow

-- | receive one callback for each file, even if the file is in both the
--   index and the workdir (combining <a>StatusFlags</a>).
StatusShowIndexAndWorkdir :: StatusShow

-- | only receive callbacks for files in the index.
StatusShowIndexOnly :: StatusShow

-- | only receive callbacks for files in the workdir.
StatusShowWorkdirOnly :: StatusShow

-- | Catch-all for unknown values
AnotherStatusShow :: Int -> StatusShow

-- | Describes which submodules should be ignored.
data SubmoduleIgnore

-- | reset to on-disk value.
SubmoduleIgnoreUnspecified :: SubmoduleIgnore

-- | don't ignore any change.
SubmoduleIgnoreNone :: SubmoduleIgnore

-- | ignore untracked files.
SubmoduleIgnoreUntracked :: SubmoduleIgnore

-- | ignore changes in the working directory.
SubmoduleIgnoreDirty :: SubmoduleIgnore

-- | never check if the submodule is dirty.
SubmoduleIgnoreAll :: SubmoduleIgnore

-- | Catch-all for unknown values
AnotherSubmoduleIgnore :: Int -> SubmoduleIgnore

-- | Options for submodule recurse. Represents the value of
--   <tt>submodule.$name.fetchRecurseSubmodules</tt>
data SubmoduleRecurse

-- | do no recurse into submodules.
SubmoduleRecurseNo :: SubmoduleRecurse

-- | recurse into submodules.
SubmoduleRecurseYes :: SubmoduleRecurse

-- | recurse into submodules only when commit not already in local clone.
SubmoduleRecurseOndemand :: SubmoduleRecurse

-- | Catch-all for unknown values
AnotherSubmoduleRecurse :: Int -> SubmoduleRecurse

-- | Describes how a submodule should be updated.
data SubmoduleUpdate

-- | checkout the submodule.
SubmoduleUpdateCheckout :: SubmoduleUpdate

-- | rebase the current branch onto the commit recorded in the
--   superproject.
SubmoduleUpdateRebase :: SubmoduleUpdate

-- | merge the commit recorded in the superproject into the current branch.
SubmoduleUpdateMerge :: SubmoduleUpdate

-- | do not update this submodule.
SubmoduleUpdateNone :: SubmoduleUpdate

-- | not used except as static initializer when we don't want any
--   particular update rule to be specified.
SubmoduleUpdateDefault :: SubmoduleUpdate

-- | Catch-all for unknown values
AnotherSubmoduleUpdate :: Int -> SubmoduleUpdate

-- | Describes in which order a tree walk should be performed.
data TreeWalkMode

-- | walk tree in pre-order
TreeWalkModePre :: TreeWalkMode

-- | walk tree in post-order
TreeWalkModePost :: TreeWalkMode

-- | Catch-all for unknown values
AnotherTreeWalkMode :: Int -> TreeWalkMode
instance GHC.Classes.Eq GI.Ggit.Enums.BranchType
instance GHC.Show.Show GI.Ggit.Enums.BranchType
instance GHC.Classes.Eq GI.Ggit.Enums.CloneLocal
instance GHC.Show.Show GI.Ggit.Enums.CloneLocal
instance GHC.Classes.Eq GI.Ggit.Enums.ConfigLevel
instance GHC.Show.Show GI.Ggit.Enums.ConfigLevel
instance GHC.Classes.Eq GI.Ggit.Enums.DeltaType
instance GHC.Show.Show GI.Ggit.Enums.DeltaType
instance GHC.Classes.Eq GI.Ggit.Enums.DiffBinaryType
instance GHC.Show.Show GI.Ggit.Enums.DiffBinaryType
instance GHC.Classes.Eq GI.Ggit.Enums.DiffFormatType
instance GHC.Show.Show GI.Ggit.Enums.DiffFormatType
instance GHC.Classes.Eq GI.Ggit.Enums.DiffLineType
instance GHC.Show.Show GI.Ggit.Enums.DiffLineType
instance GHC.Classes.Eq GI.Ggit.Enums.Direction
instance GHC.Show.Show GI.Ggit.Enums.Direction
instance GHC.Classes.Eq GI.Ggit.Enums.Error
instance GHC.Show.Show GI.Ggit.Enums.Error
instance GHC.Classes.Eq GI.Ggit.Enums.FileMode
instance GHC.Show.Show GI.Ggit.Enums.FileMode
instance GHC.Classes.Eq GI.Ggit.Enums.MergeFileFavor
instance GHC.Show.Show GI.Ggit.Enums.MergeFileFavor
instance GHC.Classes.Eq GI.Ggit.Enums.PackbuilderStage
instance GHC.Show.Show GI.Ggit.Enums.PackbuilderStage
instance GHC.Classes.Eq GI.Ggit.Enums.ProxyType
instance GHC.Show.Show GI.Ggit.Enums.ProxyType
instance GHC.Classes.Eq GI.Ggit.Enums.RebaseOperationType
instance GHC.Show.Show GI.Ggit.Enums.RebaseOperationType
instance GHC.Classes.Eq GI.Ggit.Enums.RefType
instance GHC.Show.Show GI.Ggit.Enums.RefType
instance GHC.Classes.Eq GI.Ggit.Enums.RemoteCompletionType
instance GHC.Show.Show GI.Ggit.Enums.RemoteCompletionType
instance GHC.Classes.Eq GI.Ggit.Enums.RemoteDownloadTagsType
instance GHC.Show.Show GI.Ggit.Enums.RemoteDownloadTagsType
instance GHC.Classes.Eq GI.Ggit.Enums.ResetType
instance GHC.Show.Show GI.Ggit.Enums.ResetType
instance GHC.Classes.Eq GI.Ggit.Enums.StatusShow
instance GHC.Show.Show GI.Ggit.Enums.StatusShow
instance GHC.Classes.Eq GI.Ggit.Enums.SubmoduleIgnore
instance GHC.Show.Show GI.Ggit.Enums.SubmoduleIgnore
instance GHC.Classes.Eq GI.Ggit.Enums.SubmoduleRecurse
instance GHC.Show.Show GI.Ggit.Enums.SubmoduleRecurse
instance GHC.Classes.Eq GI.Ggit.Enums.SubmoduleUpdate
instance GHC.Show.Show GI.Ggit.Enums.SubmoduleUpdate
instance GHC.Classes.Eq GI.Ggit.Enums.TreeWalkMode
instance GHC.Show.Show GI.Ggit.Enums.TreeWalkMode
instance GHC.Enum.Enum GI.Ggit.Enums.BranchType
instance GHC.Classes.Ord GI.Ggit.Enums.BranchType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.BranchType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.BranchType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.BranchType
instance GHC.Enum.Enum GI.Ggit.Enums.CloneLocal
instance GHC.Classes.Ord GI.Ggit.Enums.CloneLocal
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.CloneLocal
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.CloneLocal
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.CloneLocal
instance GHC.Enum.Enum GI.Ggit.Enums.ConfigLevel
instance GHC.Classes.Ord GI.Ggit.Enums.ConfigLevel
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.ConfigLevel
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.ConfigLevel
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.ConfigLevel
instance GHC.Enum.Enum GI.Ggit.Enums.DeltaType
instance GHC.Classes.Ord GI.Ggit.Enums.DeltaType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.DeltaType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.DeltaType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.DeltaType
instance GHC.Enum.Enum GI.Ggit.Enums.DiffBinaryType
instance GHC.Classes.Ord GI.Ggit.Enums.DiffBinaryType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.DiffBinaryType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.DiffBinaryType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.DiffBinaryType
instance GHC.Enum.Enum GI.Ggit.Enums.DiffFormatType
instance GHC.Classes.Ord GI.Ggit.Enums.DiffFormatType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.DiffFormatType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.DiffFormatType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.DiffFormatType
instance GHC.Enum.Enum GI.Ggit.Enums.DiffLineType
instance GHC.Classes.Ord GI.Ggit.Enums.DiffLineType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.DiffLineType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.DiffLineType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.DiffLineType
instance GHC.Enum.Enum GI.Ggit.Enums.Direction
instance GHC.Classes.Ord GI.Ggit.Enums.Direction
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.Direction
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.Direction
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.Direction
instance GHC.Enum.Enum GI.Ggit.Enums.Error
instance GHC.Classes.Ord GI.Ggit.Enums.Error
instance Data.GI.Base.GError.GErrorClass GI.Ggit.Enums.Error
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.Error
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.Error
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.Error
instance GHC.Enum.Enum GI.Ggit.Enums.FileMode
instance GHC.Classes.Ord GI.Ggit.Enums.FileMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.FileMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.FileMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.FileMode
instance GHC.Enum.Enum GI.Ggit.Enums.MergeFileFavor
instance GHC.Classes.Ord GI.Ggit.Enums.MergeFileFavor
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.MergeFileFavor
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.MergeFileFavor
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.MergeFileFavor
instance GHC.Enum.Enum GI.Ggit.Enums.PackbuilderStage
instance GHC.Classes.Ord GI.Ggit.Enums.PackbuilderStage
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.PackbuilderStage
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.PackbuilderStage
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.PackbuilderStage
instance GHC.Enum.Enum GI.Ggit.Enums.ProxyType
instance GHC.Classes.Ord GI.Ggit.Enums.ProxyType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.ProxyType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.ProxyType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.ProxyType
instance GHC.Enum.Enum GI.Ggit.Enums.RebaseOperationType
instance GHC.Classes.Ord GI.Ggit.Enums.RebaseOperationType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.RebaseOperationType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.RebaseOperationType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.RebaseOperationType
instance GHC.Enum.Enum GI.Ggit.Enums.RefType
instance GHC.Classes.Ord GI.Ggit.Enums.RefType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.RefType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.RefType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.RefType
instance GHC.Enum.Enum GI.Ggit.Enums.RemoteCompletionType
instance GHC.Classes.Ord GI.Ggit.Enums.RemoteCompletionType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.RemoteCompletionType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.RemoteCompletionType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.RemoteCompletionType
instance GHC.Enum.Enum GI.Ggit.Enums.RemoteDownloadTagsType
instance GHC.Classes.Ord GI.Ggit.Enums.RemoteDownloadTagsType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.RemoteDownloadTagsType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.RemoteDownloadTagsType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.RemoteDownloadTagsType
instance GHC.Enum.Enum GI.Ggit.Enums.ResetType
instance GHC.Classes.Ord GI.Ggit.Enums.ResetType
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.ResetType
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.ResetType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.ResetType
instance GHC.Enum.Enum GI.Ggit.Enums.StatusShow
instance GHC.Classes.Ord GI.Ggit.Enums.StatusShow
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.StatusShow
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.StatusShow
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.StatusShow
instance GHC.Enum.Enum GI.Ggit.Enums.SubmoduleIgnore
instance GHC.Classes.Ord GI.Ggit.Enums.SubmoduleIgnore
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.SubmoduleIgnore
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.SubmoduleIgnore
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.SubmoduleIgnore
instance GHC.Enum.Enum GI.Ggit.Enums.SubmoduleRecurse
instance GHC.Classes.Ord GI.Ggit.Enums.SubmoduleRecurse
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.SubmoduleRecurse
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.SubmoduleRecurse
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.SubmoduleRecurse
instance GHC.Enum.Enum GI.Ggit.Enums.SubmoduleUpdate
instance GHC.Classes.Ord GI.Ggit.Enums.SubmoduleUpdate
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.SubmoduleUpdate
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.SubmoduleUpdate
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.SubmoduleUpdate
instance GHC.Enum.Enum GI.Ggit.Enums.TreeWalkMode
instance GHC.Classes.Ord GI.Ggit.Enums.TreeWalkMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Enums.TreeWalkMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Enums.TreeWalkMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Ggit.Enums.TreeWalkMode


module GI.Ggit.Flags

-- | Attribute check flags indicate the order in which to check for
--   gitattributes. git core uses
--   <i><tt>gGITATTRIBUTECHECKFILETHENINDEX</tt></i> for all operations,
--   except on checkout, where it uses
--   <i><tt>gGITATTRIBUTECHECKINDEXTHENFILE</tt></i>.
data AttributeCheckFlags

-- | check working directory, then index.
AttributeCheckFlagsFileThenIndex :: AttributeCheckFlags

-- | check index, then working directory.
AttributeCheckFlagsIndexThenFile :: AttributeCheckFlags

-- | check only index.
AttributeCheckFlagsIndexOnly :: AttributeCheckFlags

-- | ignore system wide attributes.
AttributeCheckFlagsNoSystem :: AttributeCheckFlags

-- | Catch-all for unknown values
AnotherAttributeCheckFlags :: Int -> AttributeCheckFlags

-- | <i>No description available in the introspection data.</i>
data BlameFlags

-- | Normal blame, the default.
BlameFlagsNormal :: BlameFlags

-- | Track lines that have moved within a file (like git blame -M)
BlameFlagsTrackCopiesSameFile :: BlameFlags

-- | Catch-all for unknown values
AnotherBlameFlags :: Int -> BlameFlags

-- | <i>No description available in the introspection data.</i>
data CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
CheckoutNotifyFlagsNone :: CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
CheckoutNotifyFlagsConflict :: CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
CheckoutNotifyFlagsDirty :: CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
CheckoutNotifyFlagsUpdated :: CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
CheckoutNotifyFlagsUntracked :: CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
CheckoutNotifyFlagsIgnored :: CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
CheckoutNotifyFlagsAll :: CheckoutNotifyFlags

-- | Catch-all for unknown values
AnotherCheckoutNotifyFlags :: Int -> CheckoutNotifyFlags

-- | <i>No description available in the introspection data.</i>
data CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyNone :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategySafe :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyForce :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyRecreateMissing :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyAllowConflicts :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyRemoveUntracked :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyRemoveIgnored :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyUpdateOnly :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyDontUpdateIndex :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyNoRefresh :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategySkipUnmerged :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyUseOurs :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyUseTheirs :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyDisablePathspecMatch :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategySkipLockedDirectories :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyDontOverwriteIgnored :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyConflictStyleMerge :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyConflictStyleDiff3 :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyDontRemoveExisting :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyDontWriteIndex :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyUpdateSubmodules :: CheckoutStrategy

-- | <i>No description available in the introspection data.</i>
CheckoutStrategyUpdateSubmodulesIfChanged :: CheckoutStrategy

-- | Catch-all for unknown values
AnotherCheckoutStrategy :: Int -> CheckoutStrategy

-- | Describes how something should be created.
data CreateFlags

-- | attempt to create.
CreateFlagsNone :: CreateFlags

-- | force creation.
CreateFlagsForce :: CreateFlags

-- | Catch-all for unknown values
AnotherCreateFlags :: Int -> CreateFlags

-- | <i>No description available in the introspection data.</i>
data Credtype

-- | <i>No description available in the introspection data.</i>
CredtypeUserpassPlaintext :: Credtype

-- | <i>No description available in the introspection data.</i>
CredtypeSshKey :: Credtype

-- | <i>No description available in the introspection data.</i>
CredtypeSshCustom :: Credtype

-- | <i>No description available in the introspection data.</i>
CredtypeDefault :: Credtype

-- | <i>No description available in the introspection data.</i>
CredtypeSshInteractive :: Credtype

-- | Catch-all for unknown values
AnotherCredtype :: Int -> Credtype

-- | <i>No description available in the introspection data.</i>
data DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindByConfig :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindRenames :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindRenamesFromRewrites :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindCopies :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindCopiesFromUnmodified :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindRewrites :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsBreakRewrites :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindAndBreakRewrites :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindForUntracked :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindAll :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindIgnoreLeadingWhitespace :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindIgnoreWhitespace :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindDontIgnoreWhitespace :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindExactMatchOnly :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsBreakRewritesForRenamesOnly :: DiffFindFlags

-- | <i>No description available in the introspection data.</i>
DiffFindFlagsFindRemoveUnmodified :: DiffFindFlags

-- | Catch-all for unknown values
AnotherDiffFindFlags :: Int -> DiffFindFlags

-- | Describes the diff file and/or delta flags
data DiffFlag

-- | if the file is binary.
DiffFlagBinary :: DiffFlag

-- | if the file is not binary.
DiffFlagNotBinary :: DiffFlag

-- | if the ID is valid.
DiffFlagValidId :: DiffFlag

-- | Catch-all for unknown values
AnotherDiffFlag :: Int -> DiffFlag

-- | <i>No description available in the introspection data.</i>
data DiffFormatEmailFlags

-- | <i>No description available in the introspection data.</i>
DiffFormatEmailFlagsNone :: DiffFormatEmailFlags

-- | <i>No description available in the introspection data.</i>
DiffFormatEmailFlagsExcludeSubjectPatchMarker :: DiffFormatEmailFlags

-- | Catch-all for unknown values
AnotherDiffFormatEmailFlags :: Int -> DiffFormatEmailFlags

-- | How the diff should be generated.
data DiffOption

-- | normal.
DiffOptionNormal :: DiffOption

-- | reverse the sides of the diff.
DiffOptionReverse :: DiffOption

-- | include ignored files.
DiffOptionIncludeIgnored :: DiffOption

-- | also add all files under ignored dirs.
DiffOptionRecurseIgnoredDirs :: DiffOption

-- | include untracked files.
DiffOptionIncludeUntracked :: DiffOption

-- | recurse to untracked directories.
DiffOptionRecurseUntrackedDirs :: DiffOption

-- | include unmodified files.
DiffOptionIncludeUnmodified :: DiffOption

-- | enable generation of typechange detal records.
DiffOptionIncludeTypechange :: DiffOption

-- | try to label tree transitions as type changes.
DiffOptionIncludeTypechangeTrees :: DiffOption

-- | ignore file mode changes.
DiffOptionIgnoreFileMode :: DiffOption

-- | ignore submodules.
DiffOptionIgnoreSubmodules :: DiffOption

-- | use case insensitive filename comparison.
DiffOptionIgnoreCase :: DiffOption

-- | use exact path matching.
DiffOptionDisablePathspecMatch :: DiffOption

-- | disable updating the binary flag in delta records.
DiffOptionSkipBinaryCheck :: DiffOption

-- | immediately label untracked directories as untracked, without checking
--   inside.
DiffOptionEnableFastUntrackedDirs :: DiffOption

-- | force text.
DiffOptionForceText :: DiffOption

-- | treat all files as binary, disabling text diffs.
DiffOptionForceBinary :: DiffOption

-- | ignore whitespace.
DiffOptionIgnoreWhitespace :: DiffOption

-- | ignore whitespace change.
DiffOptionIgnoreWhitespaceChange :: DiffOption

-- | ignore whitespace at end-of-line.
DiffOptionIgnoreWhitespaceEol :: DiffOption

-- | include content of untracked files. this implies
--   GGIT_DIFF_INCLUDE_UNTRACKED but not GGIT_DIFF_RECURSE_UNTRACKED_DIRS.
DiffOptionShowUntrackedContent :: DiffOption

-- | show unmodified files.
DiffOptionShowUnmodified :: DiffOption

-- | generate using the "patience diff" algorithm.
DiffOptionPatience :: DiffOption

-- | take extra time to find minimal diff.
DiffOptionMinimal :: DiffOption

-- | include deflate/delta information for binary files.
DiffOptionShowBinary :: DiffOption

-- | Catch-all for unknown values
AnotherDiffOption :: Int -> DiffOption

-- | <i>No description available in the introspection data.</i>
data FeatureFlags

-- | <i>No description available in the introspection data.</i>
FeatureFlagsThreads :: FeatureFlags

-- | <i>No description available in the introspection data.</i>
FeatureFlagsHttps :: FeatureFlags

-- | <i>No description available in the introspection data.</i>
FeatureFlagsSsh :: FeatureFlags

-- | Catch-all for unknown values
AnotherFeatureFlags :: Int -> FeatureFlags

-- | GGIT_MERGE_FILE_DEFAULT: Defaults. GGIT_MERGE_FILE_STYLE_MERGE: Create
--   standard conflicted merge files. GGIT_MERGE_FILE_STYLE_DIFF3: Create
--   diff3-style files. GGIT_MERGE_FILE_SIMPLIFY_ALNUM: Condense
--   non-alphanumeric regions for simplified diff file.
--   GGIT_MERGE_FILE_IGNORE_WHITESPACE: Ignore all whitespace.
--   GGIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE: Ignore changes in amount of
--   whitespace. GGIT_MERGE_FILE_IGNORE_WHITESPACE_EOL: Ignore whitespace
--   at end of line. GGIT_MERGE_FILE_DIFF_PATIENCE: Use the "patience diff"
--   algorithm. GGIT_MERGE_FILE_DIFF_MINIMAL: Take extra time to find
--   minimal diff.
data MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsDefault :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsStyleMerge :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsStyleDiff3 :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsSimplifyAlnum :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsIgnoreWhitespace :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsIgnoreWhitespaceChange :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsIgnoreWhitespaceEol :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsDiffPatience :: MergeFileFlags

-- | <i>No description available in the introspection data.</i>
MergeFileFlagsDiffMinimal :: MergeFileFlags

-- | Catch-all for unknown values
AnotherMergeFileFlags :: Int -> MergeFileFlags

-- | <i>No description available in the introspection data.</i>
data MergeFlags

-- | detect renames that occur between the common ancestor and the "ours"
--   side or the common ancestor and the "theirs" side. This will enable
--   the ability to merge between a modified and renamed file.
MergeFlagsFindRenames :: MergeFlags

-- | If a conflict occurs, exit immediately instead of attempting to
--   continue resolving conflicts. The merge operation will fail with
--   <i><tt>gGITEMERGECONFLICT</tt></i> and no index will be returned.
MergeFlagsFailOnConflict :: MergeFlags

-- | do not write the REUC extension on the generated index.
MergeFlagsSkipReuc :: MergeFlags

-- | If the commits being merged have multiple merge bases, do not build a
--   recursive merge base (by merging the multiple merge bases), instead
--   simply use the first base. This flag provides a similar merge base to
--   <tt>git-merge-resolve</tt>.
MergeFlagsNoRecursive :: MergeFlags

-- | Catch-all for unknown values
AnotherMergeFlags :: Int -> MergeFlags

-- | The type of sorting mode for the revision walker.
data SortMode

-- | Sorts the repository contents in no particular ordering; this sorting
--   is arbitrary, implementation-specific and subject to change at any
--   time.
SortModeNone :: SortMode

-- | Sorts the repository contents in topological order (parents before
--   children); this sorting mode can be combined with time sorting.
SortModeTopological :: SortMode

-- | Sort the repository contents by commit time; this sorting mode can be
--   combined with topological sorting.
SortModeTime :: SortMode

-- | Iterate through the repository contents in reverse order; this sorting
--   mode can be combined with any of the above.
SortModeReverse :: SortMode

-- | Catch-all for unknown values
AnotherSortMode :: Int -> SortMode

-- | Describes how a stash should be applied.
data StashFlags

-- | default stash.
StashFlagsDefault :: StashFlags

-- | All changes already added to the index are left intact in the working
--   directory.
StashFlagsKeepIndex :: StashFlags

-- | All untracked files are also stashed and then cleaned up from the
--   working directory.
StashFlagsIncludeUntracked :: StashFlags

-- | All ignored files are also stashed and then cleaned up from the
--   working directory.
StashFlagsIncludeIgnored :: StashFlags

-- | Catch-all for unknown values
AnotherStashFlags :: Int -> StashFlags

-- | Describes a file's status.
data StatusFlags

-- | file is current.
StatusFlagsCurrent :: StatusFlags

-- | file in index is new.
StatusFlagsIndexNew :: StatusFlags

-- | file in index is modified.
StatusFlagsIndexModified :: StatusFlags

-- | file in index is deleted.
StatusFlagsIndexDeleted :: StatusFlags

-- | <i>No description available in the introspection data.</i>
StatusFlagsIndexRenamed :: StatusFlags

-- | <i>No description available in the introspection data.</i>
StatusFlagsIndexTypechange :: StatusFlags

-- | file in working tree is new.
StatusFlagsWorkingTreeNew :: StatusFlags

-- | file in working tree is modified.
StatusFlagsWorkingTreeModified :: StatusFlags

-- | file in working tree is deleted.
StatusFlagsWorkingTreeDeleted :: StatusFlags

-- | <i>No description available in the introspection data.</i>
StatusFlagsWorkingTreeTypechange :: StatusFlags

-- | file is ignored.
StatusFlagsIgnored :: StatusFlags

-- | Catch-all for unknown values
AnotherStatusFlags :: Int -> StatusFlags

-- | GGIT_STATUS_OPTION_INCLUDE_UNTRACKED: include untracked files
--   (default). GGIT_STATUS_OPTION_INCLUDE_IGNORED: include ignored files
--   (default). GGIT_STATUS_OPTION_INCLUDE_UNMODIFIED: include unmodified
--   files. GGIT_STATUS_OPTION_EXCLUDE_SUBMODULES: exclude submodules.
--   GGIT_STATUS_OPTION_RECURSE_UNTRACKED_DIRS: search untracked
--   directories recursively (default).
--   GGIT_STATUS_OPTION_DISABLE_PATHSPEC_MATCH: do not match path
--   specifications. GGIT_STATUS_OPTION_RECURSE_IGNORED_DIRS: search
--   ignored directories recursively.
--   GGIT_STATUS_OPTION_RENAMES_HEAD_TO_INDEX: indicates that rename
--   detection should be processed between the head and the index and
--   enables the GIT_STATUS_INDEX_RENAMED as a possible status flag.
--   GGIT_STATUS_OPTION_RENAMES_INDEX_TO_WORKDIR: indicates tha rename
--   detection should be run between the index and the working directory
--   and enabled GIT_STATUS_WT_RENAMED as a possible status flag.
--   GGIT_STATUS_OPTION_SORT_CASE_SENSITIVELY: sort case sensitive.
--   GGIT_STATUS_OPTION_SORT_CASE_INSENSITIVELY: sort case insensitive.
--   GGIT_STATUS_OPTION_DEFAULT: default flags. Status options specified
--   when using <tt><i>ggit_repository_file_status_foreach</i></tt>.
data StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionIncludeUntracked :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionIncludeIgnored :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionIncludeUnmodified :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionExcludeSubmodules :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionRecurseUntrackedDirs :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionDisablePathspecMatch :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionRecurseIgnoredDirs :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionRenamesHeadToIndex :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionRenamesIndexToWorkdir :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionSortCaseSensitively :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionSortCaseInsensitively :: StatusOption

-- | <i>No description available in the introspection data.</i>
StatusOptionDefault :: StatusOption

-- | Catch-all for unknown values
AnotherStatusOption :: Int -> StatusOption

-- | FIXME
data SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusInHead :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusInIndex :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusInConfig :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusInWd :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusIndexAdded :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusIndexDeleted :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusIndexModified :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusWdUninitialized :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusWdAdded :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusWdDeleted :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusWdModified :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusWdIndexModified :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusWdWdModified :: SubmoduleStatus

-- | <i>No description available in the introspection data.</i>
SubmoduleStatusWdUntracked :: SubmoduleStatus

-- | Catch-all for unknown values
AnotherSubmoduleStatus :: Int -> SubmoduleStatus
instance GHC.Classes.Eq GI.Ggit.Flags.AttributeCheckFlags
instance GHC.Show.Show GI.Ggit.Flags.AttributeCheckFlags
instance GHC.Classes.Eq GI.Ggit.Flags.BlameFlags
instance GHC.Show.Show GI.Ggit.Flags.BlameFlags
instance GHC.Classes.Eq GI.Ggit.Flags.CheckoutNotifyFlags
instance GHC.Show.Show GI.Ggit.Flags.CheckoutNotifyFlags
instance GHC.Classes.Eq GI.Ggit.Flags.CheckoutStrategy
instance GHC.Show.Show GI.Ggit.Flags.CheckoutStrategy
instance GHC.Classes.Eq GI.Ggit.Flags.CreateFlags
instance GHC.Show.Show GI.Ggit.Flags.CreateFlags
instance GHC.Classes.Eq GI.Ggit.Flags.Credtype
instance GHC.Show.Show GI.Ggit.Flags.Credtype
instance GHC.Classes.Eq GI.Ggit.Flags.DiffFindFlags
instance GHC.Show.Show GI.Ggit.Flags.DiffFindFlags
instance GHC.Classes.Eq GI.Ggit.Flags.DiffFlag
instance GHC.Show.Show GI.Ggit.Flags.DiffFlag
instance GHC.Classes.Eq GI.Ggit.Flags.DiffFormatEmailFlags
instance GHC.Show.Show GI.Ggit.Flags.DiffFormatEmailFlags
instance GHC.Classes.Eq GI.Ggit.Flags.DiffOption
instance GHC.Show.Show GI.Ggit.Flags.DiffOption
instance GHC.Classes.Eq GI.Ggit.Flags.FeatureFlags
instance GHC.Show.Show GI.Ggit.Flags.FeatureFlags
instance GHC.Classes.Eq GI.Ggit.Flags.MergeFileFlags
instance GHC.Show.Show GI.Ggit.Flags.MergeFileFlags
instance GHC.Classes.Eq GI.Ggit.Flags.MergeFlags
instance GHC.Show.Show GI.Ggit.Flags.MergeFlags
instance GHC.Classes.Eq GI.Ggit.Flags.SortMode
instance GHC.Show.Show GI.Ggit.Flags.SortMode
instance GHC.Classes.Eq GI.Ggit.Flags.StashFlags
instance GHC.Show.Show GI.Ggit.Flags.StashFlags
instance GHC.Classes.Eq GI.Ggit.Flags.StatusFlags
instance GHC.Show.Show GI.Ggit.Flags.StatusFlags
instance GHC.Classes.Eq GI.Ggit.Flags.StatusOption
instance GHC.Show.Show GI.Ggit.Flags.StatusOption
instance GHC.Classes.Eq GI.Ggit.Flags.SubmoduleStatus
instance GHC.Show.Show GI.Ggit.Flags.SubmoduleStatus
instance GHC.Enum.Enum GI.Ggit.Flags.AttributeCheckFlags
instance GHC.Classes.Ord GI.Ggit.Flags.AttributeCheckFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.AttributeCheckFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.AttributeCheckFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.AttributeCheckFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.AttributeCheckFlags
instance GHC.Enum.Enum GI.Ggit.Flags.BlameFlags
instance GHC.Classes.Ord GI.Ggit.Flags.BlameFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.BlameFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.BlameFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.BlameFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.BlameFlags
instance GHC.Enum.Enum GI.Ggit.Flags.CheckoutNotifyFlags
instance GHC.Classes.Ord GI.Ggit.Flags.CheckoutNotifyFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.CheckoutNotifyFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.CheckoutNotifyFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.CheckoutNotifyFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.CheckoutNotifyFlags
instance GHC.Enum.Enum GI.Ggit.Flags.CheckoutStrategy
instance GHC.Classes.Ord GI.Ggit.Flags.CheckoutStrategy
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.CheckoutStrategy
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.CheckoutStrategy
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.CheckoutStrategy
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.CheckoutStrategy
instance GHC.Enum.Enum GI.Ggit.Flags.CreateFlags
instance GHC.Classes.Ord GI.Ggit.Flags.CreateFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.CreateFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.CreateFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.CreateFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.CreateFlags
instance GHC.Enum.Enum GI.Ggit.Flags.Credtype
instance GHC.Classes.Ord GI.Ggit.Flags.Credtype
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.Credtype
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.Credtype
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.Credtype
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.Credtype
instance GHC.Enum.Enum GI.Ggit.Flags.DiffFindFlags
instance GHC.Classes.Ord GI.Ggit.Flags.DiffFindFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.DiffFindFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.DiffFindFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.DiffFindFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.DiffFindFlags
instance GHC.Enum.Enum GI.Ggit.Flags.DiffFlag
instance GHC.Classes.Ord GI.Ggit.Flags.DiffFlag
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.DiffFlag
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.DiffFlag
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.DiffFlag
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.DiffFlag
instance GHC.Enum.Enum GI.Ggit.Flags.DiffFormatEmailFlags
instance GHC.Classes.Ord GI.Ggit.Flags.DiffFormatEmailFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.DiffFormatEmailFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.DiffFormatEmailFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.DiffFormatEmailFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.DiffFormatEmailFlags
instance GHC.Enum.Enum GI.Ggit.Flags.DiffOption
instance GHC.Classes.Ord GI.Ggit.Flags.DiffOption
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.DiffOption
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.DiffOption
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.DiffOption
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.DiffOption
instance GHC.Enum.Enum GI.Ggit.Flags.FeatureFlags
instance GHC.Classes.Ord GI.Ggit.Flags.FeatureFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.FeatureFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.FeatureFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.FeatureFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.FeatureFlags
instance GHC.Enum.Enum GI.Ggit.Flags.MergeFileFlags
instance GHC.Classes.Ord GI.Ggit.Flags.MergeFileFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.MergeFileFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.MergeFileFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.MergeFileFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.MergeFileFlags
instance GHC.Enum.Enum GI.Ggit.Flags.MergeFlags
instance GHC.Classes.Ord GI.Ggit.Flags.MergeFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.MergeFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.MergeFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.MergeFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.MergeFlags
instance GHC.Enum.Enum GI.Ggit.Flags.SortMode
instance GHC.Classes.Ord GI.Ggit.Flags.SortMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.SortMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.SortMode
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.SortMode
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.SortMode
instance GHC.Enum.Enum GI.Ggit.Flags.StashFlags
instance GHC.Classes.Ord GI.Ggit.Flags.StashFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.StashFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.StashFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.StashFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.StashFlags
instance GHC.Enum.Enum GI.Ggit.Flags.StatusFlags
instance GHC.Classes.Ord GI.Ggit.Flags.StatusFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.StatusFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.StatusFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.StatusFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.StatusFlags
instance GHC.Enum.Enum GI.Ggit.Flags.StatusOption
instance GHC.Classes.Ord GI.Ggit.Flags.StatusOption
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.StatusOption
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.StatusOption
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.StatusOption
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.StatusOption
instance GHC.Enum.Enum GI.Ggit.Flags.SubmoduleStatus
instance GHC.Classes.Ord GI.Ggit.Flags.SubmoduleStatus
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Flags.SubmoduleStatus
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Flags.SubmoduleStatus
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Ggit.Flags.SubmoduleStatus
instance Data.GI.Base.BasicTypes.IsGFlag GI.Ggit.Flags.SubmoduleStatus


module GI.Ggit.Functions

-- | Gets the features of the library.
getFeatures :: (HasCallStack, MonadIO m) => m [FeatureFlags]

-- | Call this function before using any other libgit2-glib function.
init :: (HasCallStack, MonadIO m) => m ()

-- | Prettify a commit message by removing excess whitespace and making
--   sure the last line ends with a newline. If
--   <i><tt>stripComments</tt></i> is <a>True</a>, then lines starting with
--   a <i><tt>commentChar</tt></i> will be removed.
messagePrettify :: (HasCallStack, MonadIO m) => Text -> Bool -> Int8 -> m Text


-- | Represents the options used when creating a <a>Diff</a>.
module GI.Ggit.Objects.DiffOptions

-- | Memory-managed wrapper type.
newtype DiffOptions
DiffOptions :: ManagedPtr DiffOptions -> DiffOptions

-- | Type class for types which can be safely cast to <a>DiffOptions</a>,
--   for instance with <a>toDiffOptions</a>.
class (GObject o, IsDescendantOf DiffOptions o) => IsDiffOptions o

-- | Cast to <a>DiffOptions</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDiffOptions :: (MonadIO m, IsDiffOptions o) => o -> m DiffOptions

-- | Get the diff flags.
diffOptionsGetFlags :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> m [DiffOption]

-- | Get the number of context lines to include in the diff.
diffOptionsGetNContextLines :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> m Int32

-- | Get the number of interhunk lines to include in the diff.
diffOptionsGetNInterhunkLines :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> m Int32

-- | Get the diff new-prefix string.
diffOptionsGetNewPrefix :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> m (Maybe Text)

-- | Get the diff old-prefix string.
diffOptionsGetOldPrefix :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> m (Maybe Text)

-- | Get the pathspec.
diffOptionsGetPathspec :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> m (Maybe [Text])

-- | Create a new diff options object.
diffOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe DiffOptions)

-- | Set the diff flags.
diffOptionsSetFlags :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> [DiffOption] -> m ()

-- | Set the number of context lines to include in the diff.
diffOptionsSetNContextLines :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> Int32 -> m ()

-- | Set the number of interhunk lines to include in the diff.
diffOptionsSetNInterhunkLines :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> Int32 -> m ()

-- | Set the diff new-prefix string.
diffOptionsSetNewPrefix :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> Text -> m ()

-- | Get the diff old-prefix string.
diffOptionsSetOldPrefix :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> Text -> m ()

-- | Set the pathspec.
diffOptionsSetPathspec :: (HasCallStack, MonadIO m, IsDiffOptions a) => a -> Maybe [Text] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDiffOptionsFlags :: (IsDiffOptions o, MonadIO m) => [DiffOption] -> m (GValueConstruct o)

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffOptions #flags
--   </pre>
getDiffOptionsFlags :: (MonadIO m, IsDiffOptions o) => o -> m [DiffOption]

-- | Set the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffOptions [ #flags <a>:=</a> value ]
--   </pre>
setDiffOptionsFlags :: (MonadIO m, IsDiffOptions o) => o -> [DiffOption] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-context-lines</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDiffOptionsNContextLines :: (IsDiffOptions o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-context-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffOptions #nContextLines
--   </pre>
getDiffOptionsNContextLines :: (MonadIO m, IsDiffOptions o) => o -> m Int32

-- | Set the value of the “<tt>n-context-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffOptions [ #nContextLines <a>:=</a> value ]
--   </pre>
setDiffOptionsNContextLines :: (MonadIO m, IsDiffOptions o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>n-interhunk-lines</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDiffOptionsNInterhunkLines :: (IsDiffOptions o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>n-interhunk-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffOptions #nInterhunkLines
--   </pre>
getDiffOptionsNInterhunkLines :: (MonadIO m, IsDiffOptions o) => o -> m Int32

-- | Set the value of the “<tt>n-interhunk-lines</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffOptions [ #nInterhunkLines <a>:=</a> value ]
--   </pre>
setDiffOptionsNInterhunkLines :: (MonadIO m, IsDiffOptions o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>new-prefix</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDiffOptionsNewPrefix :: (IsDiffOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>new-prefix</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffOptions #newPrefix
--   </pre>
getDiffOptionsNewPrefix :: (MonadIO m, IsDiffOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>new-prefix</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffOptions [ #newPrefix <a>:=</a> value ]
--   </pre>
setDiffOptionsNewPrefix :: (MonadIO m, IsDiffOptions o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>old-prefix</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDiffOptionsOldPrefix :: (IsDiffOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>old-prefix</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffOptions #oldPrefix
--   </pre>
getDiffOptionsOldPrefix :: (MonadIO m, IsDiffOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>old-prefix</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffOptions [ #oldPrefix <a>:=</a> value ]
--   </pre>
setDiffOptionsOldPrefix :: (MonadIO m, IsDiffOptions o) => o -> Text -> m ()

-- | Set the value of the “<tt>pathspec</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #pathspec
--   </pre>
clearDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>pathspec</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDiffOptionsPathspec :: (IsDiffOptions o, MonadIO m) => [Text] -> m (GValueConstruct o)

-- | Get the value of the “<tt>pathspec</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffOptions #pathspec
--   </pre>
getDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> m (Maybe [Text])

-- | Set the value of the “<tt>pathspec</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffOptions [ #pathspec <a>:=</a> value ]
--   </pre>
setDiffOptionsPathspec :: (MonadIO m, IsDiffOptions o) => o -> [Text] -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.DiffOptions.DiffOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.DiffOptions.DiffOptions o) => GI.Ggit.Objects.DiffOptions.IsDiffOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.DiffOptions.DiffOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.DiffOptions.DiffOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.DiffOptions.DiffOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.DiffOptions.DiffOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.DiffOptions.DiffOptions


-- | Represents a generic native object.
module GI.Ggit.Objects.Native

-- | Memory-managed wrapper type.
newtype Native
Native :: ManagedPtr Native -> Native

-- | Type class for types which can be safely cast to <a>Native</a>, for
--   instance with <a>toNative</a>.
class (GObject o, IsDescendantOf Native o) => IsNative o

-- | Cast to <a>Native</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toNative :: (MonadIO m, IsNative o) => o -> m Native

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>native</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructNativeNative :: (IsNative o, MonadIO m) => Ptr () -> m (GValueConstruct o)
instance GHC.Classes.Eq GI.Ggit.Objects.Native.Native
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Native.Native o) => GI.Ggit.Objects.Native.IsNative o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Native.Native
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Native.Native
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Native.Native
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Native.Native
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Native.Native


-- | Represents a ssh key agent credential.
module GI.Ggit.Objects.CredSshKeyFromAgent

-- | Memory-managed wrapper type.
newtype CredSshKeyFromAgent
CredSshKeyFromAgent :: ManagedPtr CredSshKeyFromAgent -> CredSshKeyFromAgent

-- | Type class for types which can be safely cast to
--   <a>CredSshKeyFromAgent</a>, for instance with
--   <a>toCredSshKeyFromAgent</a>.
class (GObject o, IsDescendantOf CredSshKeyFromAgent o) => IsCredSshKeyFromAgent o

-- | Cast to <a>CredSshKeyFromAgent</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCredSshKeyFromAgent :: (MonadIO m, IsCredSshKeyFromAgent o) => o -> m CredSshKeyFromAgent

-- | Gets the username for the credential.
credSshKeyFromAgentGetUsername :: (HasCallStack, MonadIO m, IsCredSshKeyFromAgent a) => a -> m (Maybe Text)

-- | Creates a new <a>CredSshKeyFromAgent</a>.
credSshKeyFromAgentNew :: (HasCallStack, MonadIO m) => Text -> m (Maybe CredSshKeyFromAgent)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>username</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCredSshKeyFromAgentUsername :: (IsCredSshKeyFromAgent o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>username</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> credSshKeyFromAgent #username
--   </pre>
getCredSshKeyFromAgentUsername :: (MonadIO m, IsCredSshKeyFromAgent o) => o -> m (Maybe Text)
instance GHC.Classes.Eq GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent o) => GI.Ggit.Objects.CredSshKeyFromAgent.IsCredSshKeyFromAgent o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent


-- | Represents a ssh interactive credential.
module GI.Ggit.Objects.CredSshInteractive

-- | Memory-managed wrapper type.
newtype CredSshInteractive
CredSshInteractive :: ManagedPtr CredSshInteractive -> CredSshInteractive

-- | Type class for types which can be safely cast to
--   <a>CredSshInteractive</a>, for instance with
--   <a>toCredSshInteractive</a>.
class (GObject o, IsDescendantOf CredSshInteractive o) => IsCredSshInteractive o

-- | Cast to <a>CredSshInteractive</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toCredSshInteractive :: (MonadIO m, IsCredSshInteractive o) => o -> m CredSshInteractive

-- | <i>No description available in the introspection data.</i>
credSshInteractiveGetUsername :: (HasCallStack, MonadIO m, IsCredSshInteractive a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
credSshInteractiveNew :: (HasCallStack, MonadIO m) => Text -> m CredSshInteractive

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>username</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCredSshInteractiveUsername :: (IsCredSshInteractive o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>username</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> credSshInteractive #username
--   </pre>
getCredSshInteractiveUsername :: (MonadIO m, IsCredSshInteractive o) => o -> m Text
instance GHC.Classes.Eq GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.CredSshInteractive.CredSshInteractive o) => GI.Ggit.Objects.CredSshInteractive.IsCredSshInteractive o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.CredSshInteractive.CredSshInteractive


-- | Represents a plain text credential.
module GI.Ggit.Objects.CredPlaintext

-- | Memory-managed wrapper type.
newtype CredPlaintext
CredPlaintext :: ManagedPtr CredPlaintext -> CredPlaintext

-- | Type class for types which can be safely cast to <a>CredPlaintext</a>,
--   for instance with <a>toCredPlaintext</a>.
class (GObject o, IsDescendantOf CredPlaintext o) => IsCredPlaintext o

-- | Cast to <a>CredPlaintext</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCredPlaintext :: (MonadIO m, IsCredPlaintext o) => o -> m CredPlaintext

-- | <i>No description available in the introspection data.</i>
credPlaintextGetPassword :: (HasCallStack, MonadIO m, IsCredPlaintext a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
credPlaintextGetUsername :: (HasCallStack, MonadIO m, IsCredPlaintext a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
credPlaintextNew :: (HasCallStack, MonadIO m) => Text -> Text -> m CredPlaintext

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>password</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCredPlaintextPassword :: (IsCredPlaintext o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>password</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> credPlaintext #password
--   </pre>
getCredPlaintextPassword :: (MonadIO m, IsCredPlaintext o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>username</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCredPlaintextUsername :: (IsCredPlaintext o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>username</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> credPlaintext #username
--   </pre>
getCredPlaintextUsername :: (MonadIO m, IsCredPlaintext o) => o -> m Text
instance GHC.Classes.Eq GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.CredPlaintext.CredPlaintext o) => GI.Ggit.Objects.CredPlaintext.IsCredPlaintext o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.CredPlaintext.CredPlaintext


-- | Represents a git credential.
module GI.Ggit.Objects.Cred

-- | Memory-managed wrapper type.
newtype Cred
Cred :: ManagedPtr Cred -> Cred

-- | Type class for types which can be safely cast to <a>Cred</a>, for
--   instance with <a>toCred</a>.
class (GObject o, IsDescendantOf Cred o) => IsCred o

-- | Cast to <a>Cred</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toCred :: (MonadIO m, IsCred o) => o -> m Cred
instance GHC.Classes.Eq GI.Ggit.Objects.Cred.Cred
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Cred.Cred o) => GI.Ggit.Objects.Cred.IsCred o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Cred.Cred
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Cred.Cred
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Cred.Cred
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Cred.Cred
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Cred.Cred


-- | Represents a blob object.
module GI.Ggit.Objects.Blob

-- | Memory-managed wrapper type.
newtype Blob
Blob :: ManagedPtr Blob -> Blob

-- | Type class for types which can be safely cast to <a>Blob</a>, for
--   instance with <a>toBlob</a>.
class (GObject o, IsDescendantOf Blob o) => IsBlob o

-- | Cast to <a>Blob</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toBlob :: (MonadIO m, IsBlob o) => o -> m Blob

-- | Gets a read-only buffer with the raw contents of <i><tt>blob</tt></i>.
--   
--   A pointer to the raw contents of <i><tt>blob</tt></i> is returned.
--   This pointer is owned internally by <i><tt>object</tt></i> and must
--   not be free'd. The pointer may be invalidated at a later time.
blobGetRawContent :: (HasCallStack, MonadIO m, IsBlob a) => a -> m (Maybe ByteString)

-- | Check whether the blob is binary.
blobIsBinary :: (HasCallStack, MonadIO m, IsBlob a) => a -> m Bool
instance GHC.Classes.Eq GI.Ggit.Objects.Blob.Blob
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Blob.Blob o) => GI.Ggit.Objects.Blob.IsBlob o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Blob.Blob
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Blob.Blob
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Blob.Blob
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Blob.Blob
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Blob.Blob


-- | Represents the base type for objects created by an object factory.
module GI.Ggit.Objects.ObjectFactoryBase

-- | Memory-managed wrapper type.
newtype ObjectFactoryBase
ObjectFactoryBase :: ManagedPtr ObjectFactoryBase -> ObjectFactoryBase

-- | Type class for types which can be safely cast to
--   <a>ObjectFactoryBase</a>, for instance with
--   <a>toObjectFactoryBase</a>.
class (GObject o, IsDescendantOf ObjectFactoryBase o) => IsObjectFactoryBase o

-- | Cast to <a>ObjectFactoryBase</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toObjectFactoryBase :: (MonadIO m, IsObjectFactoryBase o) => o -> m ObjectFactoryBase
instance GHC.Classes.Eq GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase o) => GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase


-- | Represents a git proxy options.
module GI.Ggit.Objects.ProxyOptions

-- | Memory-managed wrapper type.
newtype ProxyOptions
ProxyOptions :: ManagedPtr ProxyOptions -> ProxyOptions

-- | Type class for types which can be safely cast to <a>ProxyOptions</a>,
--   for instance with <a>toProxyOptions</a>.
class (GObject o, IsDescendantOf ProxyOptions o) => IsProxyOptions o

-- | Cast to <a>ProxyOptions</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toProxyOptions :: (MonadIO m, IsProxyOptions o) => o -> m ProxyOptions

-- | Create a new proxy options object.
proxyOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe ProxyOptions)
instance GHC.Classes.Eq GI.Ggit.Objects.ProxyOptions.ProxyOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.ProxyOptions.ProxyOptions o) => GI.Ggit.Objects.ProxyOptions.IsProxyOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.ProxyOptions.ProxyOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.ProxyOptions.ProxyOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.ProxyOptions.ProxyOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.ProxyOptions.ProxyOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.ProxyOptions.ProxyOptions


-- | Represents a branch object.
module GI.Ggit.Objects.Branch

-- | Memory-managed wrapper type.
newtype Branch
Branch :: ManagedPtr Branch -> Branch

-- | Type class for types which can be safely cast to <a>Branch</a>, for
--   instance with <a>toBranch</a>.
class (GObject o, IsDescendantOf Branch o) => IsBranch o

-- | Cast to <a>Branch</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toBranch :: (MonadIO m, IsBranch o) => o -> m Branch

-- | Deletes an existing branch reference.
--   
--   If the branch is successfully deleted, this object is not useful
--   anymore and if should be freed with <a>objectUnref</a>.
branchDelete :: (HasCallStack, MonadIO m, IsBranch a) => a -> m ()

-- | Gets the name of the given local or remote branch.
branchGetName :: (HasCallStack, MonadIO m, IsBranch a) => a -> m (Maybe Text)

-- | Gets the reference supporting the remote tracking branch, given a
--   local branch reference.
branchGetUpstream :: (HasCallStack, MonadIO m, IsBranch a) => a -> m (Maybe Ref)

-- | Determines if the current local branch is pointed at by HEAD.
branchIsHead :: (HasCallStack, MonadIO m, IsBranch a) => a -> m ()

-- | Moves/renames an existing branch reference.
branchMove :: (HasCallStack, MonadIO m, IsBranch a) => a -> Text -> [CreateFlags] -> m (Maybe Branch)

-- | Sets the upstream branch, for a given local branch reference
branchSetUpstream :: (HasCallStack, MonadIO m, IsBranch a) => a -> Text -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.Branch.Branch
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Branch.Branch o) => GI.Ggit.Objects.Branch.IsBranch o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Branch.Branch
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Branch.Branch
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Branch.Branch
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Branch.Branch
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Branch.Branch


-- | Represents a git push options.
module GI.Ggit.Objects.PushOptions

-- | Memory-managed wrapper type.
newtype PushOptions
PushOptions :: ManagedPtr PushOptions -> PushOptions

-- | Type class for types which can be safely cast to <a>PushOptions</a>,
--   for instance with <a>toPushOptions</a>.
class (GObject o, IsDescendantOf PushOptions o) => IsPushOptions o

-- | Cast to <a>PushOptions</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPushOptions :: (MonadIO m, IsPushOptions o) => o -> m PushOptions

-- | Get the number of parallel threads to use when creating the pack file
--   to push. The special value 0 indicates that the number of threads will
--   be automatically detected.
pushOptionsGetParallelism :: (HasCallStack, MonadIO m, IsPushOptions a) => a -> m Int32

-- | gets the remote callbacks object
pushOptionsGetRemoteCallbacks :: (HasCallStack, MonadIO m, IsPushOptions a) => a -> m (Maybe RemoteCallbacks)

-- | Create a new push options object.
pushOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe PushOptions)

-- | Set the number of parallel threads to use when creating the pack file
--   to push. The special value 0 can be specified for
--   <i><tt>parallelism</tt></i> indicating that the number of threads will
--   be automatically detected.
pushOptionsSetParallelism :: (HasCallStack, MonadIO m, IsPushOptions a) => a -> Int32 -> m ()

-- | Set the remote callbacks for the push options
pushOptionsSetRemoteCallbacks :: (HasCallStack, MonadIO m, IsPushOptions a, IsRemoteCallbacks b) => a -> b -> m ()

-- | Set the value of the “<tt>callbacks</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #callbacks
--   </pre>
clearPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>callbacks</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructPushOptionsCallbacks :: (IsPushOptions o, MonadIO m, IsRemoteCallbacks a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>callbacks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pushOptions #callbacks
--   </pre>
getPushOptionsCallbacks :: (MonadIO m, IsPushOptions o) => o -> m (Maybe RemoteCallbacks)

-- | Set the value of the “<tt>callbacks</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pushOptions [ #callbacks <a>:=</a> value ]
--   </pre>
setPushOptionsCallbacks :: (MonadIO m, IsPushOptions o, IsRemoteCallbacks a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>parallelism</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructPushOptionsParallelism :: (IsPushOptions o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>parallelism</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pushOptions #parallelism
--   </pre>
getPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> m Int32

-- | Set the value of the “<tt>parallelism</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pushOptions [ #parallelism <a>:=</a> value ]
--   </pre>
setPushOptionsParallelism :: (MonadIO m, IsPushOptions o) => o -> Int32 -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.PushOptions.PushOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.PushOptions.PushOptions o) => GI.Ggit.Objects.PushOptions.IsPushOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.PushOptions.PushOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.PushOptions.PushOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.PushOptions.PushOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.PushOptions.PushOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.PushOptions.PushOptions


-- | Represents an action signature.
module GI.Ggit.Objects.Signature

-- | Memory-managed wrapper type.
newtype Signature
Signature :: ManagedPtr Signature -> Signature

-- | Type class for types which can be safely cast to <a>Signature</a>, for
--   instance with <a>toSignature</a>.
class (GObject o, IsDescendantOf Signature o) => IsSignature o

-- | Cast to <a>Signature</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSignature :: (MonadIO m, IsSignature o) => o -> m Signature

-- | Create a copy of the signature.
signatureCopy :: (HasCallStack, MonadIO m, IsSignature a) => a -> m (Maybe Signature)

-- | Gets the email of the person.
signatureGetEmail :: (HasCallStack, MonadIO m, IsSignature a) => a -> m (Maybe Text)

-- | Gets the name of the person.
signatureGetName :: (HasCallStack, MonadIO m, IsSignature a) => a -> m (Maybe Text)

-- | Gets the time when the action happened. Note that the time is returned
--   in the timezone of the commit (see
--   <tt><i>ggit_signature_get_time_zone</i></tt>).
signatureGetTime :: (HasCallStack, MonadIO m, IsSignature a) => a -> m (Maybe DateTime)

-- | Gets the timezone in which the action happened.
signatureGetTimeZone :: (HasCallStack, MonadIO m, IsSignature a) => a -> m (Maybe TimeZone)

-- | Creates a new <a>Signature</a>. Name and e-mail are assumed to be in
--   UTF-8.
signatureNew :: (HasCallStack, MonadIO m) => Text -> Text -> DateTime -> m (Maybe Signature)

-- | Creates a new <a>Signature</a> with a timestamp of 'now'. Name and
--   e-mail are assumed to be in UTF-8.
signatureNewNow :: (HasCallStack, MonadIO m) => Text -> Text -> m (Maybe Signature)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>encoding</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSignatureEncoding :: (IsSignature o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>encoding</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signature #encoding
--   </pre>
getSignatureEncoding :: (MonadIO m, IsSignature o) => o -> m (Maybe Text)
instance GHC.Classes.Eq GI.Ggit.Objects.Signature.Signature
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Signature.Signature o) => GI.Ggit.Objects.Signature.IsSignature o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Signature.Signature
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Signature.Signature
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Signature.Signature
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Signature.Signature
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Signature.Signature


-- | Represents the options used when doign a checkout.
module GI.Ggit.Objects.CheckoutOptions

-- | Memory-managed wrapper type.
newtype CheckoutOptions
CheckoutOptions :: ManagedPtr CheckoutOptions -> CheckoutOptions

-- | Type class for types which can be safely cast to
--   <a>CheckoutOptions</a>, for instance with <a>toCheckoutOptions</a>.
class (GObject o, IsDescendantOf CheckoutOptions o) => IsCheckoutOptions o

-- | Cast to <a>CheckoutOptions</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCheckoutOptions :: (MonadIO m, IsCheckoutOptions o) => o -> m CheckoutOptions

-- | Get the checkout ancestor label.
checkoutOptionsGetAncestorLabel :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m (Maybe Text)

-- | Get the baseline, i.e. the expected content of workdir. Defaults to
--   HEAD.
checkoutOptionsGetBaseline :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m (Maybe Tree)

-- | Get the default checkout directory mode.
checkoutOptionsGetDirMode :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m Word32

-- | Get whether filters are disabled.
checkoutOptionsGetDisableFilters :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m Bool

-- | Get the default checkout file mode.
checkoutOptionsGetFileMode :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m Word32

-- | Get the checkout file open flags. These flags are platform specific,
--   e.g. on Unix these would include O_CREAT, O_TRUNC, etc.
checkoutOptionsGetFileOpenFlags :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m Int32

-- | Get the checkout notify flags.
checkoutOptionsGetNotifyFlags :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m [CheckoutNotifyFlags]

-- | Get the checkout our label.
checkoutOptionsGetOurLabel :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m (Maybe Text)

-- | Get the list of file paths to checkout.
checkoutOptionsGetPaths :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m (Maybe [Text])

-- | Get the checkout strategy.
checkoutOptionsGetStrategy :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m [CheckoutStrategy]

-- | Get the checkout target directory.
checkoutOptionsGetTargetDirectory :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m (Maybe Text)

-- | Get the checkout their label.
checkoutOptionsGetTheirLabel :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> m (Maybe Text)

-- | Create a new checkout options object.
checkoutOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe CheckoutOptions)

-- | Set the checkout ancestor label.
checkoutOptionsSetAncestorLabel :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Maybe Text -> m ()

-- | Set the baseline, i.e. the expected content of workdir. If
--   <i><tt>tree</tt></i> is set to <a>Nothing</a>, the default (HEAD) will
--   be used as the baseline.
checkoutOptionsSetBaseline :: (HasCallStack, MonadIO m, IsCheckoutOptions a, IsTree b) => a -> Maybe b -> m ()

-- | Set the default checkout directory mode.
checkoutOptionsSetDirMode :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Word32 -> m ()

-- | Set whether to disable filters.
checkoutOptionsSetDisableFilters :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Bool -> m ()

-- | Set the default checkout file mode.
checkoutOptionsSetFileMode :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Word32 -> m ()

-- | Set the checkout file open flags. These flags are platform dependent,
--   e.g. on Unix use O_CREAT, O_TRUNC, etc.
checkoutOptionsSetFileOpenFlags :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Int32 -> m ()

-- | Set the checkout notify flags.
checkoutOptionsSetNotifyFlags :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> [CheckoutNotifyFlags] -> m ()

-- | Set the checkout our label.
checkoutOptionsSetOurLabel :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Maybe Text -> m ()

-- | Set the list of file paths to checkout. If <i><tt>paths</tt></i> is
--   <a>Nothing</a>, then all files will be checked out.
checkoutOptionsSetPaths :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Maybe [Text] -> m ()

-- | Set the checkout strategy.
checkoutOptionsSetStrategy :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> [CheckoutStrategy] -> m ()

-- | Set the checkout target directory.
checkoutOptionsSetTargetDirectory :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Maybe Text -> m ()

-- | Set the checkout their label.
checkoutOptionsSetTheirLabel :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => a -> Maybe Text -> m ()

-- | Set the value of the “<tt>ancestor-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #ancestorLabel
--   </pre>
clearCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>ancestor-label</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCheckoutOptionsAncestorLabel :: (IsCheckoutOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>ancestor-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #ancestorLabel
--   </pre>
getCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>ancestor-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #ancestorLabel <a>:=</a> value ]
--   </pre>
setCheckoutOptionsAncestorLabel :: (MonadIO m, IsCheckoutOptions o) => o -> Text -> m ()

-- | Set the value of the “<tt>baseline</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #baseline
--   </pre>
clearCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>baseline</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCheckoutOptionsBaseline :: (IsCheckoutOptions o, MonadIO m, IsTree a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>baseline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #baseline
--   </pre>
getCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe Tree)

-- | Set the value of the “<tt>baseline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #baseline <a>:=</a> value ]
--   </pre>
setCheckoutOptionsBaseline :: (MonadIO m, IsCheckoutOptions o, IsTree a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>dir-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCheckoutOptionsDirMode :: (IsCheckoutOptions o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>dir-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #dirMode
--   </pre>
getCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32

-- | Set the value of the “<tt>dir-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #dirMode <a>:=</a> value ]
--   </pre>
setCheckoutOptionsDirMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>disable-filters</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCheckoutOptionsDisableFilters :: (IsCheckoutOptions o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>disable-filters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #disableFilters
--   </pre>
getCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> m Bool

-- | Set the value of the “<tt>disable-filters</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #disableFilters <a>:=</a> value ]
--   </pre>
setCheckoutOptionsDisableFilters :: (MonadIO m, IsCheckoutOptions o) => o -> Bool -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file-mode</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCheckoutOptionsFileMode :: (IsCheckoutOptions o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>file-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #fileMode
--   </pre>
getCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> m Word32

-- | Set the value of the “<tt>file-mode</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #fileMode <a>:=</a> value ]
--   </pre>
setCheckoutOptionsFileMode :: (MonadIO m, IsCheckoutOptions o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file-open-flags</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCheckoutOptionsFileOpenFlags :: (IsCheckoutOptions o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>file-open-flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #fileOpenFlags
--   </pre>
getCheckoutOptionsFileOpenFlags :: (MonadIO m, IsCheckoutOptions o) => o -> m Int32

-- | Set the value of the “<tt>file-open-flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #fileOpenFlags <a>:=</a> value ]
--   </pre>
setCheckoutOptionsFileOpenFlags :: (MonadIO m, IsCheckoutOptions o) => o -> Int32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>notify-flags</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCheckoutOptionsNotifyFlags :: (IsCheckoutOptions o, MonadIO m) => [CheckoutNotifyFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>notify-flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #notifyFlags
--   </pre>
getCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> m [CheckoutNotifyFlags]

-- | Set the value of the “<tt>notify-flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #notifyFlags <a>:=</a> value ]
--   </pre>
setCheckoutOptionsNotifyFlags :: (MonadIO m, IsCheckoutOptions o) => o -> [CheckoutNotifyFlags] -> m ()

-- | Set the value of the “<tt>our-label</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #ourLabel
--   </pre>
clearCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>our-label</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCheckoutOptionsOurLabel :: (IsCheckoutOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>our-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #ourLabel
--   </pre>
getCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>our-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #ourLabel <a>:=</a> value ]
--   </pre>
setCheckoutOptionsOurLabel :: (MonadIO m, IsCheckoutOptions o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>strategy</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCheckoutOptionsStrategy :: (IsCheckoutOptions o, MonadIO m) => [CheckoutStrategy] -> m (GValueConstruct o)

-- | Get the value of the “<tt>strategy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #strategy
--   </pre>
getCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> m [CheckoutStrategy]

-- | Set the value of the “<tt>strategy</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #strategy <a>:=</a> value ]
--   </pre>
setCheckoutOptionsStrategy :: (MonadIO m, IsCheckoutOptions o) => o -> [CheckoutStrategy] -> m ()

-- | Set the value of the “<tt>target-directory</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #targetDirectory
--   </pre>
clearCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>target-directory</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCheckoutOptionsTargetDirectory :: (IsCheckoutOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>target-directory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #targetDirectory
--   </pre>
getCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>target-directory</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #targetDirectory <a>:=</a> value ]
--   </pre>
setCheckoutOptionsTargetDirectory :: (MonadIO m, IsCheckoutOptions o) => o -> Text -> m ()

-- | Set the value of the “<tt>their-label</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #theirLabel
--   </pre>
clearCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>their-label</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCheckoutOptionsTheirLabel :: (IsCheckoutOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>their-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> checkoutOptions #theirLabel
--   </pre>
getCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>their-label</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> checkoutOptions [ #theirLabel <a>:=</a> value ]
--   </pre>
setCheckoutOptionsTheirLabel :: (MonadIO m, IsCheckoutOptions o) => o -> Text -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.CheckoutOptions.CheckoutOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.CheckoutOptions.CheckoutOptions o) => GI.Ggit.Objects.CheckoutOptions.IsCheckoutOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.CheckoutOptions.CheckoutOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.CheckoutOptions.CheckoutOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CheckoutOptions.CheckoutOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.CheckoutOptions.CheckoutOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.CheckoutOptions.CheckoutOptions


-- | Represents a blame.
module GI.Ggit.Objects.Blame

-- | Memory-managed wrapper type.
newtype Blame
Blame :: ManagedPtr Blame -> Blame

-- | Type class for types which can be safely cast to <a>Blame</a>, for
--   instance with <a>toBlame</a>.
class (GObject o, IsDescendantOf Blame o) => IsBlame o

-- | Cast to <a>Blame</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toBlame :: (MonadIO m, IsBlame o) => o -> m Blame

-- | Get blame data for a file that has been modified in memory.
--   <i><tt>blame</tt></i> is a pre-calculated blame for the in-odb history
--   of the file. This means that once a file blame is completed (which can
--   be expensitve), updating the buffer blame is very fast.
--   
--   Lines that differ between the buffer and the committed version are
--   marked as having a zero id for their
--   <tt><i>ggit_blame_hunk_get_final_commit_id</i></tt>.
blameFromBuffer :: (HasCallStack, MonadIO m, IsBlame a) => a -> ByteString -> m (Maybe Blame)

-- | Get the blame options flags.
blameGetFlags :: (HasCallStack, MonadIO m) => BlameOptions -> m [BlameFlags]

-- | <i>No description available in the introspection data.</i>
blameGetHunkByIndex :: (HasCallStack, MonadIO m, IsBlame a) => a -> Word32 -> m BlameHunk

-- | <i>No description available in the introspection data.</i>
blameGetHunkByLine :: (HasCallStack, MonadIO m, IsBlame a) => a -> Word32 -> m BlameHunk

-- | <i>No description available in the introspection data.</i>
blameGetHunkCount :: (HasCallStack, MonadIO m, IsBlame a) => a -> m Word32

-- | Set the blame options flags.
blameSetFlags :: (HasCallStack, MonadIO m) => BlameOptions -> [BlameFlags] -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.Blame.Blame
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Blame.Blame o) => GI.Ggit.Objects.Blame.IsBlame o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Blame.Blame
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Blame.Blame
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Blame.Blame
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Blame.Blame
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Blame.Blame


-- | Represents a branch enumerator.
module GI.Ggit.Structs.BranchEnumerator

-- | Memory-managed wrapper type.
newtype BranchEnumerator
BranchEnumerator :: ManagedPtr BranchEnumerator -> BranchEnumerator

-- | Returns the currently being enumerated branch, or <a>Nothing</a>. Note
--   that the returned GgitRef will be of type GgitBranch if the ref
--   represents a local branch.
branchEnumeratorGet :: (HasCallStack, MonadIO m) => BranchEnumerator -> m (Maybe Ref)

-- | Get an iterator for the enumerator.
branchEnumeratorIterator :: (HasCallStack, MonadIO m) => BranchEnumerator -> m (Maybe BranchEnumerator)

-- | Move the enumerator to the next branch.
branchEnumeratorNext :: (HasCallStack, MonadIO m) => BranchEnumerator -> m Bool

-- | <i>No description available in the introspection data.</i>
branchEnumeratorRef :: (HasCallStack, MonadIO m) => BranchEnumerator -> m (Maybe BranchEnumerator)

-- | <i>No description available in the introspection data.</i>
branchEnumeratorUnref :: (HasCallStack, MonadIO m) => BranchEnumerator -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.BranchEnumerator.BranchEnumerator
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.BranchEnumerator.BranchEnumerator
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.BranchEnumerator.BranchEnumerator
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.BranchEnumerator.BranchEnumerator
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.BranchEnumerator.BranchEnumerator
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.BranchEnumerator.BranchEnumerator


-- | Represents a git configuration entry.
module GI.Ggit.Structs.ConfigEntry

-- | Memory-managed wrapper type.
newtype ConfigEntry
ConfigEntry :: ManagedPtr ConfigEntry -> ConfigEntry

-- | Gets the <a>ConfigLevel</a> of <i><tt>entry</tt></i>.
configEntryGetLevel :: (HasCallStack, MonadIO m) => ConfigEntry -> m ConfigLevel

-- | Gets the name of <i><tt>entry</tt></i>.
configEntryGetName :: (HasCallStack, MonadIO m) => ConfigEntry -> m (Maybe Text)

-- | Gets the value of <i><tt>entry</tt></i>.
configEntryGetValue :: (HasCallStack, MonadIO m) => ConfigEntry -> m (Maybe Text)

-- | Atomically increments the reference count of <i><tt>entry</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
configEntryRef :: (HasCallStack, MonadIO m) => ConfigEntry -> m (Maybe ConfigEntry)

-- | Atomically decrements the reference count of <i><tt>entry</tt></i> by
--   one. If the reference count drops to 0, <i><tt>entry</tt></i> is
--   freed.
configEntryUnref :: (HasCallStack, MonadIO m) => ConfigEntry -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.ConfigEntry.ConfigEntry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.ConfigEntry.ConfigEntry
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.ConfigEntry.ConfigEntry
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.ConfigEntry.ConfigEntry
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.ConfigEntry.ConfigEntry
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.ConfigEntry.ConfigEntry


-- | Represents a ssh interactive prompt.
module GI.Ggit.Structs.CredSshInteractivePrompt

-- | Memory-managed wrapper type.
newtype CredSshInteractivePrompt
CredSshInteractivePrompt :: ManagedPtr CredSshInteractivePrompt -> CredSshInteractivePrompt

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptGetInstruction :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> m Text

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptGetName :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> m Text

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptGetResponse :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> m Text

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptGetText :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> m Text

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptIsMasked :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> m Bool

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptNew :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Bool -> m CredSshInteractivePrompt

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptRef :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> m CredSshInteractivePrompt

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptSetResponse :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> Text -> m ()

-- | <i>No description available in the introspection data.</i>
credSshInteractivePromptUnref :: (HasCallStack, MonadIO m) => CredSshInteractivePrompt -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.CredSshInteractivePrompt.CredSshInteractivePrompt
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.CredSshInteractivePrompt.CredSshInteractivePrompt
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.CredSshInteractivePrompt.CredSshInteractivePrompt
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.CredSshInteractivePrompt.CredSshInteractivePrompt
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.CredSshInteractivePrompt.CredSshInteractivePrompt
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.CredSshInteractivePrompt.CredSshInteractivePrompt


-- | Represents a diff binary.
module GI.Ggit.Structs.DiffBinary

-- | Memory-managed wrapper type.
newtype DiffBinary
DiffBinary :: ManagedPtr DiffBinary -> DiffBinary

-- | Gets the <a>DiffBinaryFile</a> new file for <i><tt>binary</tt></i>.
diffBinaryGetNewFile :: (HasCallStack, MonadIO m) => DiffBinary -> m (Maybe DiffBinaryFile)

-- | Gets the <a>DiffBinaryFile</a> old file for <i><tt>binary</tt></i>.
diffBinaryGetOldFile :: (HasCallStack, MonadIO m) => DiffBinary -> m (Maybe DiffBinaryFile)

-- | Atomically increments the reference count of <i><tt>binary</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
diffBinaryRef :: (HasCallStack, MonadIO m) => DiffBinary -> m (Maybe DiffBinary)

-- | Atomically decrements the reference count of <i><tt>binary</tt></i> by
--   one. If the reference count drops to 0, <i><tt>binary</tt></i> is
--   freed.
diffBinaryUnref :: (HasCallStack, MonadIO m) => DiffBinary -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.DiffBinary.DiffBinary
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.DiffBinary.DiffBinary
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.DiffBinary.DiffBinary
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.DiffBinary.DiffBinary
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.DiffBinary.DiffBinary
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.DiffBinary.DiffBinary


-- | Represents a diff binary file.
module GI.Ggit.Structs.DiffBinaryFile

-- | Memory-managed wrapper type.
newtype DiffBinaryFile
DiffBinaryFile :: ManagedPtr DiffBinaryFile -> DiffBinaryFile

-- | Gets the <a>DiffBinaryType</a> for <i><tt>file</tt></i>.
diffBinaryFileGetBinaryType :: (HasCallStack, MonadIO m) => DiffBinaryFile -> m DiffBinaryType

-- | Get the binary data. This data should not be modified.
diffBinaryFileGetData :: (HasCallStack, MonadIO m) => DiffBinaryFile -> Word32 -> m Word8

-- | Gets the length of the binary data after inflation.
diffBinaryFileGetInflatedSize :: (HasCallStack, MonadIO m) => DiffBinaryFile -> m Word32

-- | Atomically increments the reference count of <i><tt>file</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
diffBinaryFileRef :: (HasCallStack, MonadIO m) => DiffBinaryFile -> m DiffBinaryFile

-- | Atomically decrements the reference count of <i><tt>file</tt></i> by
--   one. If the reference count drops to 0, <i><tt>file</tt></i> is freed.
diffBinaryFileUnref :: (HasCallStack, MonadIO m) => DiffBinaryFile -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.DiffBinaryFile.DiffBinaryFile


-- | Represents the changes done to one file.
module GI.Ggit.Structs.DiffDelta

-- | Memory-managed wrapper type.
newtype DiffDelta
DiffDelta :: ManagedPtr DiffDelta -> DiffDelta

-- | Gets flags for <i><tt>delta</tt></i>.
diffDeltaGetFlags :: (HasCallStack, MonadIO m) => DiffDelta -> m [DiffFlag]

-- | Gets the new file for <i><tt>delta</tt></i>.
diffDeltaGetNewFile :: (HasCallStack, MonadIO m) => DiffDelta -> m (Maybe DiffFile)

-- | Gets the old file for <i><tt>delta</tt></i>.
diffDeltaGetOldFile :: (HasCallStack, MonadIO m) => DiffDelta -> m (Maybe DiffFile)

-- | Gets the similarity between <i><tt>delta</tt></i> files.
diffDeltaGetSimilarity :: (HasCallStack, MonadIO m) => DiffDelta -> m Word32

-- | Gets the <a>DeltaType</a> for <i><tt>delta</tt></i>.
diffDeltaGetStatus :: (HasCallStack, MonadIO m) => DiffDelta -> m DeltaType

-- | Atomically increments the reference count of <i><tt>delta</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
diffDeltaRef :: (HasCallStack, MonadIO m) => DiffDelta -> m (Maybe DiffDelta)

-- | Atomically decrements the reference count of <i><tt>delta</tt></i> by
--   one. If the reference count drops to 0, <i><tt>delta</tt></i> is
--   freed.
diffDeltaUnref :: (HasCallStack, MonadIO m) => DiffDelta -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.DiffDelta.DiffDelta
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.DiffDelta.DiffDelta
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.DiffDelta.DiffDelta
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.DiffDelta.DiffDelta
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.DiffDelta.DiffDelta
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.DiffDelta.DiffDelta


-- | Represents the hunk of a diff.
module GI.Ggit.Structs.DiffHunk

-- | Memory-managed wrapper type.
newtype DiffHunk
DiffHunk :: ManagedPtr DiffHunk -> DiffHunk

-- | <i>No description available in the introspection data.</i>
diffHunkGetHeader :: (HasCallStack, MonadIO m) => DiffHunk -> m Text

-- | Gets the number of lines in the new file.
diffHunkGetNewLines :: (HasCallStack, MonadIO m) => DiffHunk -> m Int32

-- | Gets the starting line number in the new file.
diffHunkGetNewStart :: (HasCallStack, MonadIO m) => DiffHunk -> m Int32

-- | Gets the number of lines in the old file.
diffHunkGetOldLines :: (HasCallStack, MonadIO m) => DiffHunk -> m Int32

-- | Gets the starting line number in the old file.
diffHunkGetOldStart :: (HasCallStack, MonadIO m) => DiffHunk -> m Int32

-- | Atomically increments the reference count of <i><tt>hunk</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
diffHunkRef :: (HasCallStack, MonadIO m) => DiffHunk -> m (Maybe DiffHunk)

-- | Atomically decrements the reference count of <i><tt>hunk</tt></i> by
--   one. If the reference count drops to 0, <i><tt>hunk</tt></i> is freed.
diffHunkUnref :: (HasCallStack, MonadIO m) => DiffHunk -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.DiffHunk.DiffHunk
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.DiffHunk.DiffHunk
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.DiffHunk.DiffHunk
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.DiffHunk.DiffHunk
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.DiffHunk.DiffHunk
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.DiffHunk.DiffHunk


-- | Represents the line of a diff.
module GI.Ggit.Structs.DiffLine

-- | Memory-managed wrapper type.
newtype DiffLine
DiffLine :: ManagedPtr DiffLine -> DiffLine

-- | Gets the content in bytes.
diffLineGetContent :: (HasCallStack, MonadIO m) => DiffLine -> m ByteString

-- | Gets the content offset.
diffLineGetContentOffset :: (HasCallStack, MonadIO m) => DiffLine -> m Int64

-- | Gets the Line number in new file or -1 for deleted line.
diffLineGetNewLineno :: (HasCallStack, MonadIO m) => DiffLine -> m Int32

-- | Gets the line number in old file or -1 for added line.
diffLineGetOldLineno :: (HasCallStack, MonadIO m) => DiffLine -> m Int32

-- | Gets the <a>DiffLineType</a> value.
diffLineGetOrigin :: (HasCallStack, MonadIO m) => DiffLine -> m DiffLineType

-- | Get the content of the diff line as UTF-8 encoded text.
diffLineGetText :: (HasCallStack, MonadIO m) => DiffLine -> m (Maybe Text)

-- | Atomically increments the reference count of <i><tt>line</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
diffLineRef :: (HasCallStack, MonadIO m) => DiffLine -> m (Maybe DiffLine)

-- | Atomically decrements the reference count of <i><tt>line</tt></i> by
--   one. If the reference count drops to 0, <i><tt>line</tt></i> is freed.
diffLineUnref :: (HasCallStack, MonadIO m) => DiffLine -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.DiffLine.DiffLine
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.DiffLine.DiffLine
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.DiffLine.DiffLine
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.DiffLine.DiffLine
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.DiffLine.DiffLine
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.DiffLine.DiffLine


-- | Represents options for finding diff similarity.
module GI.Ggit.Objects.DiffFindOptions

-- | Memory-managed wrapper type.
newtype DiffFindOptions
DiffFindOptions :: ManagedPtr DiffFindOptions -> DiffFindOptions

-- | Type class for types which can be safely cast to
--   <a>DiffFindOptions</a>, for instance with <a>toDiffFindOptions</a>.
class (GObject o, IsDescendantOf DiffFindOptions o) => IsDiffFindOptions o

-- | Cast to <a>DiffFindOptions</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toDiffFindOptions :: (MonadIO m, IsDiffFindOptions o) => o -> m DiffFindOptions

-- | Get the find options copy threshold.
diffFindOptionsGetCopyThreshold :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> m Word32

-- | Get the find options flags.
diffFindOptionsGetFlags :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> m [DiffFindFlags]

-- | Get the find options metric.
diffFindOptionsGetMetric :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> m (Maybe DiffSimilarityMetric)

-- | Get the find options rename from rewrite threshold.
diffFindOptionsGetRenameFromRewriteThreshold :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> m Word32

-- | Get the find options rename limit.
diffFindOptionsGetRenameLimit :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> m Word32

-- | Get the find options rename threshold.
diffFindOptionsGetRenameThreshold :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> m Word32

-- | Creates a new <a>DiffFindOptions</a>.
diffFindOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe DiffFindOptions)

-- | Set the find options copy threshold.
diffFindOptionsSetCopyThreshold :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> Word32 -> m ()

-- | Set the find options flags.
diffFindOptionsSetFlags :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> [DiffFindFlags] -> m ()

-- | Set the find options metric.
diffFindOptionsSetMetric :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> DiffSimilarityMetric -> m ()

-- | Set the find options rename from rewrite threshold.
diffFindOptionsSetRenameFromRewriteThreshold :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> Word32 -> m ()

-- | Set the find options rename limit.
diffFindOptionsSetRenameLimit :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> Word32 -> m ()

-- | Set the find options rename threshold.
diffFindOptionsSetRenameThreshold :: (HasCallStack, MonadIO m, IsDiffFindOptions a) => a -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>copy-threshold</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDiffFindOptionsCopyThreshold :: (IsDiffFindOptions o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>copy-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFindOptions #copyThreshold
--   </pre>
getDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32

-- | Set the value of the “<tt>copy-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFindOptions [ #copyThreshold <a>:=</a> value ]
--   </pre>
setDiffFindOptionsCopyThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDiffFindOptionsFlags :: (IsDiffFindOptions o, MonadIO m) => [DiffFindFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFindOptions #flags
--   </pre>
getDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> m [DiffFindFlags]

-- | Set the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFindOptions [ #flags <a>:=</a> value ]
--   </pre>
setDiffFindOptionsFlags :: (MonadIO m, IsDiffFindOptions o) => o -> [DiffFindFlags] -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>metric</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDiffFindOptionsMetric :: (IsDiffFindOptions o, MonadIO m) => DiffSimilarityMetric -> m (GValueConstruct o)

-- | Get the value of the “<tt>metric</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFindOptions #metric
--   </pre>
getDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> m (Maybe DiffSimilarityMetric)

-- | Set the value of the “<tt>metric</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFindOptions [ #metric <a>:=</a> value ]
--   </pre>
setDiffFindOptionsMetric :: (MonadIO m, IsDiffFindOptions o) => o -> DiffSimilarityMetric -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rename-from-rewrite-threshold</tt>” property. This is rarely
--   needed directly, but it is used by <a>new</a>.
constructDiffFindOptionsRenameFromRewriteThreshold :: (IsDiffFindOptions o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rename-from-rewrite-threshold</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFindOptions #renameFromRewriteThreshold
--   </pre>
getDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32

-- | Set the value of the “<tt>rename-from-rewrite-threshold</tt>”
--   property. When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFindOptions [ #renameFromRewriteThreshold <a>:=</a> value ]
--   </pre>
setDiffFindOptionsRenameFromRewriteThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rename-limit</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructDiffFindOptionsRenameLimit :: (IsDiffFindOptions o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rename-limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFindOptions #renameLimit
--   </pre>
getDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32

-- | Set the value of the “<tt>rename-limit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFindOptions [ #renameLimit <a>:=</a> value ]
--   </pre>
setDiffFindOptionsRenameLimit :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rename-threshold</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructDiffFindOptionsRenameThreshold :: (IsDiffFindOptions o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rename-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFindOptions #renameThreshold
--   </pre>
getDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> m Word32

-- | Set the value of the “<tt>rename-threshold</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFindOptions [ #renameThreshold <a>:=</a> value ]
--   </pre>
setDiffFindOptionsRenameThreshold :: (MonadIO m, IsDiffFindOptions o) => o -> Word32 -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.DiffFindOptions.DiffFindOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.DiffFindOptions.DiffFindOptions o) => GI.Ggit.Objects.DiffFindOptions.IsDiffFindOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.DiffFindOptions.DiffFindOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.DiffFindOptions.DiffFindOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.DiffFindOptions.DiffFindOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.DiffFindOptions.DiffFindOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.DiffFindOptions.DiffFindOptions


-- | Represents options for a submodule update.
module GI.Ggit.Objects.SubmoduleUpdateOptions

-- | Memory-managed wrapper type.
newtype SubmoduleUpdateOptions
SubmoduleUpdateOptions :: ManagedPtr SubmoduleUpdateOptions -> SubmoduleUpdateOptions

-- | Type class for types which can be safely cast to
--   <a>SubmoduleUpdateOptions</a>, for instance with
--   <a>toSubmoduleUpdateOptions</a>.
class (GObject o, IsDescendantOf SubmoduleUpdateOptions o) => IsSubmoduleUpdateOptions o

-- | Cast to <a>SubmoduleUpdateOptions</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toSubmoduleUpdateOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m SubmoduleUpdateOptions

-- | Get the checkout options.
submoduleUpdateOptionsGetCheckoutOptions :: (HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a) => a -> m (Maybe CheckoutOptions)

-- | <i>No description available in the introspection data.</i>
submoduleUpdateOptionsGetFetchOptions :: (HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a) => a -> m FetchOptions

-- | Creates a new submodule options object.
submoduleUpdateOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe SubmoduleUpdateOptions)

-- | Set the checkout options.
submoduleUpdateOptionsSetCheckoutOptions :: (HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a, IsCheckoutOptions b) => a -> Maybe b -> m ()

-- | Sets the fetch options.
submoduleUpdateOptionsSetFetchOptions :: (HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a) => a -> Maybe FetchOptions -> m ()

-- | Set the value of the “<tt>checkout-options</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #checkoutOptions
--   </pre>
clearSubmoduleUpdateOptionsCheckoutOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>checkout-options</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructSubmoduleUpdateOptionsCheckoutOptions :: (IsSubmoduleUpdateOptions o, MonadIO m, IsCheckoutOptions a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>checkout-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> submoduleUpdateOptions #checkoutOptions
--   </pre>
getSubmoduleUpdateOptionsCheckoutOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m (Maybe CheckoutOptions)

-- | Set the value of the “<tt>checkout-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> submoduleUpdateOptions [ #checkoutOptions <a>:=</a> value ]
--   </pre>
setSubmoduleUpdateOptionsCheckoutOptions :: (MonadIO m, IsSubmoduleUpdateOptions o, IsCheckoutOptions a) => o -> a -> m ()

-- | Set the value of the “<tt>fetch-options</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #fetchOptions
--   </pre>
clearSubmoduleUpdateOptionsFetchOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>fetch-options</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSubmoduleUpdateOptionsFetchOptions :: (IsSubmoduleUpdateOptions o, MonadIO m) => FetchOptions -> m (GValueConstruct o)

-- | Get the value of the “<tt>fetch-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> submoduleUpdateOptions #fetchOptions
--   </pre>
getSubmoduleUpdateOptionsFetchOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> m (Maybe FetchOptions)

-- | Set the value of the “<tt>fetch-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> submoduleUpdateOptions [ #fetchOptions <a>:=</a> value ]
--   </pre>
setSubmoduleUpdateOptionsFetchOptions :: (MonadIO m, IsSubmoduleUpdateOptions o) => o -> FetchOptions -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions o) => GI.Ggit.Objects.SubmoduleUpdateOptions.IsSubmoduleUpdateOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions


-- | Represents the options used when cloning.
module GI.Ggit.Objects.CloneOptions

-- | Memory-managed wrapper type.
newtype CloneOptions
CloneOptions :: ManagedPtr CloneOptions -> CloneOptions

-- | Type class for types which can be safely cast to <a>CloneOptions</a>,
--   for instance with <a>toCloneOptions</a>.
class (GObject o, IsDescendantOf CloneOptions o) => IsCloneOptions o

-- | Cast to <a>CloneOptions</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCloneOptions :: (MonadIO m, IsCloneOptions o) => o -> m CloneOptions

-- | Gets the name of the branch to checkout or <a>Nothing</a>.
cloneOptionsGetCheckoutBranch :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> m Text

-- | Get the fetch options object or <a>Nothing</a> if not set.
cloneOptionsGetFetchOptions :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> m FetchOptions

-- | Gets if the repository will be bare.
cloneOptionsGetIsBare :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> m Bool

-- | Get setting for bypassing the git-aware transport when cloning. The
--   default auto setting bypasses the git-aware transport for local paths,
--   but use a normal fetch for file:// URIs.
cloneOptionsGetLocal :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> m CloneLocal

-- | Creates a new <a>CloneOptions</a>.
cloneOptionsNew :: (HasCallStack, MonadIO m) => m CloneOptions

-- | Gives the name of the branch to checkout. <a>Nothing</a> means use the
--   remote's HEAD.
cloneOptionsSetCheckoutBranch :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> Maybe Text -> m ()

-- | Set the fetch options object.
cloneOptionsSetFetchOptions :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> Maybe FetchOptions -> m ()

-- | Sets whether to clone a bare repository.
cloneOptionsSetIsBare :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> Bool -> m ()

-- | Set setting for bypassing the git-aware transport when cloning. The
--   default auto setting bypasses the git-aware transport for local paths,
--   but use a normal fetch for file:// URIs.
cloneOptionsSetLocal :: (HasCallStack, MonadIO m, IsCloneOptions a) => a -> CloneLocal -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.CloneOptions.CloneOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.CloneOptions.CloneOptions o) => GI.Ggit.Objects.CloneOptions.IsCloneOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.CloneOptions.CloneOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.CloneOptions.CloneOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CloneOptions.CloneOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.CloneOptions.CloneOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.CloneOptions.CloneOptions


-- | Represents a git fetch options.
module GI.Ggit.Structs.FetchOptions

-- | Memory-managed wrapper type.
newtype FetchOptions
FetchOptions :: ManagedPtr FetchOptions -> FetchOptions

-- | Copies <i><tt>fetchOptions</tt></i> into a newly allocated
--   <a>FetchOptions</a>.
fetchOptionsCopy :: (HasCallStack, MonadIO m) => FetchOptions -> m (Maybe FetchOptions)

-- | Frees <i><tt>fetchOptions</tt></i>.
fetchOptionsFree :: (HasCallStack, MonadIO m) => FetchOptions -> m ()

-- | Get how tags are being handled when fetching/downloading.
fetchOptionsGetDownloadTags :: (HasCallStack, MonadIO m) => FetchOptions -> m RemoteDownloadTagsType

-- | Get the remote callbacks object or <a>Nothing</a> if not set.
fetchOptionsGetRemoteCallbacks :: (HasCallStack, MonadIO m) => FetchOptions -> m (Maybe RemoteCallbacks)

-- | Creates a new <a>FetchOptions</a>.
fetchOptionsNew :: (HasCallStack, MonadIO m) => m FetchOptions

-- | Set how tags are being handled when fetching/downloading.
fetchOptionsSetDownloadTags :: (HasCallStack, MonadIO m) => FetchOptions -> RemoteDownloadTagsType -> m ()

-- | Set the fetch options object.
fetchOptionsSetRemoteCallbacks :: (HasCallStack, MonadIO m, IsRemoteCallbacks a) => FetchOptions -> Maybe a -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.FetchOptions.FetchOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.FetchOptions.FetchOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.FetchOptions.FetchOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.FetchOptions.FetchOptions
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.FetchOptions.FetchOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.FetchOptions.FetchOptions


-- | Represents the entries in an index object.
module GI.Ggit.Structs.IndexEntries

-- | Memory-managed wrapper type.
newtype IndexEntries
IndexEntries :: ManagedPtr IndexEntries -> IndexEntries

-- | Get a <a>IndexEntry</a> by index. Note that the returned
--   <a>IndexEntry</a> is _only_ valid as long as:
--   
--   1) The associated index has been closed 2) The entry has not been
--   removed (see <a>indexRemove</a>) 3) The index has not been refreshed
--   (see <a>indexRead</a>)
--   
--   Changes to the <a>IndexEntry</a> will be reflected in the index once
--   written back to disk using <a>indexWrite</a>.
indexEntriesGetByIndex :: (HasCallStack, MonadIO m) => IndexEntries -> Word32 -> m (Maybe IndexEntry)

-- | Get a <a>IndexEntry</a> by index. Note that the returned
--   <a>IndexEntry</a> is _only_ valid as long as:
--   
--   1) The associated index has not been closed 2) The entry has not been
--   removed (see <a>indexRemove</a>) 3) The index has not been refreshed
--   (see <a>indexRead</a>)
--   
--   Changes to the <a>IndexEntry</a> will be reflected in the index once
--   written back to disk using <a>indexWrite</a>.
--   
--   <i><tt>stage</tt></i> indicates the stage to search the file for.
--   Stages are used in the index when merge conflicts occur, such that
--   multiple versions of the same file can be represented in the index.
--   Stage 0 is associated with the working tree, while stages 1 to 3 are
--   associated with the various versions of the file in a merge conflict.
--   The special value -1 can be used to match the first file encountered
--   in any stage.
indexEntriesGetByPath :: (HasCallStack, MonadIO m, IsFile a) => IndexEntries -> a -> Int32 -> m (Maybe IndexEntry)

-- | Atomically increments the reference count of <i><tt>entries</tt></i>
--   by one. This function is MT-safe and may be called from any thread.
indexEntriesRef :: (HasCallStack, MonadIO m) => IndexEntries -> m (Maybe IndexEntries)

-- | Get the number of <a>IndexEntry</a> entries.
indexEntriesSize :: (HasCallStack, MonadIO m) => IndexEntries -> m Word32

-- | Atomically decrements the reference count of <i><tt>entries</tt></i>
--   by one. If the reference count drops to 0, <i><tt>entries</tt></i> is
--   freed.
indexEntriesUnref :: (HasCallStack, MonadIO m) => IndexEntries -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.IndexEntries.IndexEntries
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.IndexEntries.IndexEntries
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.IndexEntries.IndexEntries
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.IndexEntries.IndexEntries
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.IndexEntries.IndexEntries
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.IndexEntries.IndexEntries


-- | Represents the resolve undo entries in an index object.
module GI.Ggit.Structs.IndexEntriesResolveUndo

-- | Memory-managed wrapper type.
newtype IndexEntriesResolveUndo
IndexEntriesResolveUndo :: ManagedPtr IndexEntriesResolveUndo -> IndexEntriesResolveUndo

-- | Get a <a>IndexEntryResolveUndo</a> by index. Note that the returned
--   <a>IndexEntryResolveUndo</a> is _only_ valid as long as:
--   
--   1) The associated index has been closed 2) The entry has not been
--   removed (see <a>indexRemove</a>) 3) The index has not been refreshed
--   (see <a>indexRead</a>)
indexEntriesResolveUndoGet :: (HasCallStack, MonadIO m) => IndexEntriesResolveUndo -> Word32 -> m (Maybe IndexEntryResolveUndo)

-- | Get an resolve_undo entry specified by path. The returned entry is
--   read only and should not be modified by the caller. If the entry could
--   not be found, <a>Nothing</a> is returned.
indexEntriesResolveUndoGetByFile :: (HasCallStack, MonadIO m, IsFile a) => IndexEntriesResolveUndo -> a -> m (Maybe IndexEntryResolveUndo)

-- | Atomically increments the reference count of <i><tt>entries</tt></i>
--   by one. This function is MT-safe and may be called from any thread.
indexEntriesResolveUndoRef :: (HasCallStack, MonadIO m) => IndexEntriesResolveUndo -> m (Maybe IndexEntriesResolveUndo)

-- | Get the number of <a>IndexEntryResolveUndo</a> entries.
indexEntriesResolveUndoSize :: (HasCallStack, MonadIO m) => IndexEntriesResolveUndo -> m Word32

-- | Atomically decrements the reference count of <i><tt>entries</tt></i>
--   by one. If the reference count drops to 0, <i><tt>entries</tt></i> is
--   freed.
indexEntriesResolveUndoUnref :: (HasCallStack, MonadIO m) => IndexEntriesResolveUndo -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.IndexEntriesResolveUndo.IndexEntriesResolveUndo


-- | Represents the options used when doign a cherry-pick.
module GI.Ggit.Objects.CherryPickOptions

-- | Memory-managed wrapper type.
newtype CherryPickOptions
CherryPickOptions :: ManagedPtr CherryPickOptions -> CherryPickOptions

-- | Type class for types which can be safely cast to
--   <a>CherryPickOptions</a>, for instance with
--   <a>toCherryPickOptions</a>.
class (GObject o, IsDescendantOf CherryPickOptions o) => IsCherryPickOptions o

-- | Cast to <a>CherryPickOptions</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toCherryPickOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m CherryPickOptions

-- | Get the checkout options.
cherryPickOptionsGetCheckoutOptions :: (HasCallStack, MonadIO m, IsCherryPickOptions a) => a -> m CheckoutOptions

-- | Get the mainline parent to use when cherry-picking a merge commit.
cherryPickOptionsGetMainline :: (HasCallStack, MonadIO m, IsCherryPickOptions a) => a -> m Word32

-- | Get the merge options.
cherryPickOptionsGetMergeOptions :: (HasCallStack, MonadIO m, IsCherryPickOptions a) => a -> m MergeOptions

-- | Create a new cherry-pick options object.
cherryPickOptionsNew :: (HasCallStack, MonadIO m) => m CherryPickOptions

-- | Set the checkout options.
cherryPickOptionsSetCheckoutOptions :: (HasCallStack, MonadIO m, IsCherryPickOptions a, IsCheckoutOptions b) => a -> Maybe b -> m ()

-- | Set the mainline parent to use when cherry-picking a merge commit.
cherryPickOptionsSetMainline :: (HasCallStack, MonadIO m, IsCherryPickOptions a) => a -> Word32 -> m ()

-- | Set the merge options.
cherryPickOptionsSetMergeOptions :: (HasCallStack, MonadIO m, IsCherryPickOptions a) => a -> Maybe MergeOptions -> m ()

-- | Set the value of the “<tt>checkout-options</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #checkoutOptions
--   </pre>
clearCherryPickOptionsCheckoutOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>checkout-options</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructCherryPickOptionsCheckoutOptions :: (IsCherryPickOptions o, MonadIO m, IsCheckoutOptions a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>checkout-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cherryPickOptions #checkoutOptions
--   </pre>
getCherryPickOptionsCheckoutOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m CheckoutOptions

-- | Set the value of the “<tt>checkout-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cherryPickOptions [ #checkoutOptions <a>:=</a> value ]
--   </pre>
setCherryPickOptionsCheckoutOptions :: (MonadIO m, IsCherryPickOptions o, IsCheckoutOptions a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>mainline</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructCherryPickOptionsMainline :: (IsCherryPickOptions o, MonadIO m) => Word32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>mainline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cherryPickOptions #mainline
--   </pre>
getCherryPickOptionsMainline :: (MonadIO m, IsCherryPickOptions o) => o -> m Word32

-- | Set the value of the “<tt>mainline</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cherryPickOptions [ #mainline <a>:=</a> value ]
--   </pre>
setCherryPickOptionsMainline :: (MonadIO m, IsCherryPickOptions o) => o -> Word32 -> m ()

-- | Set the value of the “<tt>merge-options</tt>” property to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #mergeOptions
--   </pre>
clearCherryPickOptionsMergeOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>merge-options</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructCherryPickOptionsMergeOptions :: (IsCherryPickOptions o, MonadIO m) => MergeOptions -> m (GValueConstruct o)

-- | Get the value of the “<tt>merge-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cherryPickOptions #mergeOptions
--   </pre>
getCherryPickOptionsMergeOptions :: (MonadIO m, IsCherryPickOptions o) => o -> m (Maybe MergeOptions)

-- | Set the value of the “<tt>merge-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cherryPickOptions [ #mergeOptions <a>:=</a> value ]
--   </pre>
setCherryPickOptionsMergeOptions :: (MonadIO m, IsCherryPickOptions o) => o -> MergeOptions -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.CherryPickOptions.CherryPickOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.CherryPickOptions.CherryPickOptions o) => GI.Ggit.Objects.CherryPickOptions.IsCherryPickOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.CherryPickOptions.CherryPickOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.CherryPickOptions.CherryPickOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CherryPickOptions.CherryPickOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.CherryPickOptions.CherryPickOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.CherryPickOptions.CherryPickOptions


-- | Represents the options used when merging.
module GI.Ggit.Structs.MergeOptions

-- | Memory-managed wrapper type.
newtype MergeOptions
MergeOptions :: ManagedPtr MergeOptions -> MergeOptions

-- | Copies <i><tt>mergeOptions</tt></i> into a newly allocated
--   <a>MergeOptions</a>.
mergeOptionsCopy :: (HasCallStack, MonadIO m) => MergeOptions -> m (Maybe MergeOptions)

-- | Frees <i><tt>mergeOptions</tt></i>.
mergeOptionsFree :: (HasCallStack, MonadIO m) => MergeOptions -> m ()

-- | Get flags for handling conflicting content.
mergeOptionsGetFileFavor :: (HasCallStack, MonadIO m) => MergeOptions -> m MergeFileFavor

-- | Get file merging flags.
mergeOptionsGetFileFlags :: (HasCallStack, MonadIO m) => MergeOptions -> m [MergeFileFlags]

-- | Get the tree flags to use for merging.
mergeOptionsGetFlags :: (HasCallStack, MonadIO m) => MergeOptions -> m [MergeFlags]

-- | Get the rename threshold (defaults to 50). If
--   <tt><i>GGIT_MERGE_TREE_FIND_RENAMES</i></tt> is enabled, added files
--   will be compared with deleted files to determine their similarity.
--   Files that are more similar than the rename threshold
--   (percentage-wise) will be treated as a rename.
mergeOptionsGetRenameThreshold :: (HasCallStack, MonadIO m) => MergeOptions -> m Word32

-- | Get the similarity metric.
mergeOptionsGetSimilarityMetric :: (HasCallStack, MonadIO m) => MergeOptions -> m (Maybe DiffSimilarityMetric)

-- | Get the maximum number of similarity sources to examine for renames
--   (defaults to 200). If the number of rename candidates (add / delete
--   pairs) is greater than this value, inexact rename detection is
--   aborted.
mergeOptionsGetTargetLimit :: (HasCallStack, MonadIO m) => MergeOptions -> m Word32

-- | Creates a new <a>MergeOptions</a>.
mergeOptionsNew :: (HasCallStack, MonadIO m) => m MergeOptions

-- | Set flags for handling conflicting content.
mergeOptionsSetFileFavor :: (HasCallStack, MonadIO m) => MergeOptions -> MergeFileFavor -> m ()

-- | Set file merging flags.
mergeOptionsSetFileFlags :: (HasCallStack, MonadIO m) => MergeOptions -> [MergeFileFlags] -> m ()

-- | <i>No description available in the introspection data.</i>
mergeOptionsSetFlags :: (HasCallStack, MonadIO m) => MergeOptions -> [MergeFlags] -> m ()

-- | Set the rename threshold (defaults to 50). If
--   <tt><i>GGIT_MERGE_TREE_FIND_RENAMES</i></tt> is enabled, added files
--   will be compared with deleted files to determine their similarity.
--   Files that are more similar than the rename threshold
--   (percentage-wise) will be treated as a rename.
mergeOptionsSetRenameThreshold :: (HasCallStack, MonadIO m) => MergeOptions -> Word32 -> m ()

-- | Set the similarity metric, or <a>Nothing</a> for the default
--   similarity metric.
mergeOptionsSetSimilarityMetric :: (HasCallStack, MonadIO m) => MergeOptions -> DiffSimilarityMetric -> m ()

-- | Set the maximum number of similarity sources to examine for renames
--   (defaults to 200). If the number of rename candidates (add / delete
--   pairs) is greater than this value, inexact rename detection is
--   aborted.
mergeOptionsSetTargetLimit :: (HasCallStack, MonadIO m) => MergeOptions -> Word32 -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.MergeOptions.MergeOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.MergeOptions.MergeOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.MergeOptions.MergeOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.MergeOptions.MergeOptions
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.MergeOptions.MergeOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.MergeOptions.MergeOptions


-- | Represents a note object.
module GI.Ggit.Structs.Note

-- | Memory-managed wrapper type.
newtype Note
Note :: ManagedPtr Note -> Note

-- | Gets the note object's id.
noteGetId :: (HasCallStack, MonadIO m) => Note -> m (Maybe OId)

-- | Gets the note message.
noteGetMessage :: (HasCallStack, MonadIO m) => Note -> m (Maybe Text)

-- | Atomically increments the reference count of <i><tt>note</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
noteRef :: (HasCallStack, MonadIO m) => Note -> m (Maybe Note)

-- | Atomically decrements the reference count of <i><tt>note</tt></i> by
--   one. If the reference count drops to 0, <i><tt>note</tt></i> is freed.
noteUnref :: (HasCallStack, MonadIO m) => Note -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.Note.Note
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.Note.Note
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.Note.Note
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.Note.Note
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.Note.Note
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.Note.Note


-- | Represents an resolve undo index entry object.
module GI.Ggit.Structs.IndexEntryResolveUndo

-- | Memory-managed wrapper type.
newtype IndexEntryResolveUndo
IndexEntryResolveUndo :: ManagedPtr IndexEntryResolveUndo -> IndexEntryResolveUndo

-- | Get the file of the index entry.
indexEntryResolveUndoGetFile :: (HasCallStack, MonadIO m) => IndexEntryResolveUndo -> m (Maybe File)

-- | Get the oid of the index entry.
indexEntryResolveUndoGetId :: (HasCallStack, MonadIO m) => IndexEntryResolveUndo -> Int32 -> m (Maybe OId)

-- | Get the mode of the index entry. The returned mode contains the modes
--   from stage 1, 2 and 3.
indexEntryResolveUndoGetMode :: (HasCallStack, MonadIO m) => IndexEntryResolveUndo -> Int32 -> m Word32

-- | Atomically increments the reference count of <i><tt>entry</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
indexEntryResolveUndoRef :: (HasCallStack, MonadIO m) => IndexEntryResolveUndo -> m (Maybe IndexEntryResolveUndo)

-- | Atomically decrements the reference count of <i><tt>entry</tt></i> by
--   one. If the reference count drops to 0, <i><tt>entry</tt></i> is
--   freed.
indexEntryResolveUndoUnref :: (HasCallStack, MonadIO m) => IndexEntryResolveUndo -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.IndexEntryResolveUndo.IndexEntryResolveUndo


-- | Represents an index entry object.
module GI.Ggit.Structs.IndexEntry

-- | Memory-managed wrapper type.
newtype IndexEntry
IndexEntry :: ManagedPtr IndexEntry -> IndexEntry

-- | Get the dev of the index entry.
indexEntryGetDev :: (HasCallStack, MonadIO m) => IndexEntry -> m Word32

-- | Get the file size of the index entry.
indexEntryGetFileSize :: (HasCallStack, MonadIO m) => IndexEntry -> m Int64

-- | Get the flags of the index entry.
indexEntryGetFlags :: (HasCallStack, MonadIO m) => IndexEntry -> m Word32

-- | Get the extended flags of the index entry.
indexEntryGetFlagsExtended :: (HasCallStack, MonadIO m) => IndexEntry -> m Word32

-- | Get the gid of the index entry.
indexEntryGetGid :: (HasCallStack, MonadIO m) => IndexEntry -> m Word32

-- | Get the oid of the index entry.
indexEntryGetId :: (HasCallStack, MonadIO m) => IndexEntry -> m (Maybe OId)

-- | Get the ino of the index entry.
indexEntryGetIno :: (HasCallStack, MonadIO m) => IndexEntry -> m Word32

-- | Get the mode of the index entry.
indexEntryGetMode :: (HasCallStack, MonadIO m) => IndexEntry -> m Word32

-- | <i>No description available in the introspection data.</i>
indexEntryGetPath :: (HasCallStack, MonadIO m) => IndexEntry -> m Text

-- | Get the uid of the index entry.
indexEntryGetUid :: (HasCallStack, MonadIO m) => IndexEntry -> m Word32

-- | Get whether the entry represents a conflict.
indexEntryIsConflict :: (HasCallStack, MonadIO m) => IndexEntry -> m Bool

-- | Atomically increments the reference count of <i><tt>entry</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
indexEntryRef :: (HasCallStack, MonadIO m) => IndexEntry -> m (Maybe IndexEntry)

-- | Set the index entry to point to a given commit. This sets the index
--   entry id to the commit id, changes the mode to
--   <tt><i>GGIT_FILE_MODE_COMMIT</i></tt> and updates the timestamps to
--   when the commit was made.
indexEntrySetCommit :: (HasCallStack, MonadIO m, IsCommit a) => IndexEntry -> a -> m ()

-- | Set the dev of the index entry.
indexEntrySetDev :: (HasCallStack, MonadIO m) => IndexEntry -> Word32 -> m ()

-- | Set the file size of the index entry.
indexEntrySetFileSize :: (HasCallStack, MonadIO m) => IndexEntry -> Int64 -> m ()

-- | Set the flags of the index entry.
indexEntrySetFlags :: (HasCallStack, MonadIO m) => IndexEntry -> Word32 -> m ()

-- | Set the extended flags of the index entry.
indexEntrySetFlagsExtended :: (HasCallStack, MonadIO m) => IndexEntry -> Word32 -> m ()

-- | Set the gid of the index entry.
indexEntrySetGid :: (HasCallStack, MonadIO m) => IndexEntry -> Word32 -> m ()

-- | Set the oid of the index entry.
indexEntrySetId :: (HasCallStack, MonadIO m) => IndexEntry -> Maybe OId -> m ()

-- | Set the ino of the index entry.
indexEntrySetIno :: (HasCallStack, MonadIO m) => IndexEntry -> Word32 -> m ()

-- | Set the mode of the index entry.
indexEntrySetMode :: (HasCallStack, MonadIO m) => IndexEntry -> Word32 -> m ()

-- | Set the path of the index entry. The path should be relative to the
--   working directory.
indexEntrySetPath :: (HasCallStack, MonadIO m) => IndexEntry -> Maybe Text -> m ()

-- | Set the uid of the index entry.
indexEntrySetUid :: (HasCallStack, MonadIO m) => IndexEntry -> Word32 -> m ()

-- | Fill the entry fields from statting <i><tt>file</tt></i>.
indexEntryStat :: (HasCallStack, MonadIO m, IsFile a) => IndexEntry -> a -> m ()

-- | Atomically decrements the reference count of <i><tt>entry</tt></i> by
--   one. If the reference count drops to 0, <i><tt>entry</tt></i> is
--   freed.
indexEntryUnref :: (HasCallStack, MonadIO m) => IndexEntry -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.IndexEntry.IndexEntry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.IndexEntry.IndexEntry
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.IndexEntry.IndexEntry
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.IndexEntry.IndexEntry
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.IndexEntry.IndexEntry
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.IndexEntry.IndexEntry


-- | Represents a file in a <a>Diff</a>.
module GI.Ggit.Structs.DiffFile

-- | Memory-managed wrapper type.
newtype DiffFile
DiffFile :: ManagedPtr DiffFile -> DiffFile

-- | Gets the <tt><i>GgitDifflags</i></tt> for <i><tt>file</tt></i>.
diffFileGetFlags :: (HasCallStack, MonadIO m) => DiffFile -> m [DiffFlag]

-- | Gets the mode for <i><tt>file</tt></i>.
diffFileGetMode :: (HasCallStack, MonadIO m) => DiffFile -> m Word16

-- | Gets the <a>OId</a> for <i><tt>file</tt></i>.
diffFileGetOid :: (HasCallStack, MonadIO m) => DiffFile -> m (Maybe OId)

-- | Gets the path of <i><tt>file</tt></i> or <a>Nothing</a> if it is
--   unknown.
diffFileGetPath :: (HasCallStack, MonadIO m) => DiffFile -> m (Maybe Text)

-- | Gets the size for <i><tt>file</tt></i>.
diffFileGetSize :: (HasCallStack, MonadIO m) => DiffFile -> m Int64

-- | Atomically increments the reference count of <i><tt>file</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
diffFileRef :: (HasCallStack, MonadIO m) => DiffFile -> m (Maybe DiffFile)

-- | Atomically decrements the reference count of <i><tt>file</tt></i> by
--   one. If the reference count drops to 0, <i><tt>file</tt></i> is freed.
diffFileUnref :: (HasCallStack, MonadIO m) => DiffFile -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.DiffFile.DiffFile
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.DiffFile.DiffFile
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.DiffFile.DiffFile
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.DiffFile.DiffFile
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.DiffFile.DiffFile
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.DiffFile.DiffFile


-- | Represents blame options.
module GI.Ggit.Structs.BlameOptions

-- | Memory-managed wrapper type.
newtype BlameOptions
BlameOptions :: ManagedPtr BlameOptions -> BlameOptions

-- | Copies <i><tt>blameOptions</tt></i> into a newly allocated
--   <a>BlameOptions</a>.
blameOptionsCopy :: (HasCallStack, MonadIO m) => BlameOptions -> m (Maybe BlameOptions)

-- | Frees <i><tt>blameOptions</tt></i>.
blameOptionsFree :: (HasCallStack, MonadIO m) => BlameOptions -> m ()

-- | Get the last line in the file to consider. The default is 1.
blameOptionsGetMaximumLine :: (HasCallStack, MonadIO m) => BlameOptions -> m Word32

-- | Get the first line in the file to consider. The default is 1.
blameOptionsGetMinimumLine :: (HasCallStack, MonadIO m) => BlameOptions -> m Word32

-- | Get the minimum number of characters that must be detected as
--   moving/copying within a file for it to associate those lines with a
--   parent commit. This is only used when any of the
--   <tt><i>GGIT_BLAME_TRACK_COPIES_SAME_FILE</i></tt> flag is specified.
--   The default value is 20.
blameOptionsGetMinimumMatchCharacters :: (HasCallStack, MonadIO m) => BlameOptions -> m Word16

-- | Get the id of the newest commit to consider in the blame. The default
--   value of <a>Nothing</a> indicates to use HEAD.
blameOptionsGetNewestCommit :: (HasCallStack, MonadIO m) => BlameOptions -> m (Maybe OId)

-- | Get the id of the oldest commit to consider in the blame. Teh default
--   value of <a>Nothing</a> indicates to used HEAD.
blameOptionsGetOldestCommit :: (HasCallStack, MonadIO m) => BlameOptions -> m (Maybe OId)

-- | Create a new, empty <a>BlameOptions</a>.
blameOptionsNew :: (HasCallStack, MonadIO m) => m BlameOptions

-- | Set the last line in the file to consider. Lines start at 1.
blameOptionsSetMaximumLine :: (HasCallStack, MonadIO m) => BlameOptions -> Word32 -> m ()

-- | Set the first line in the file to consider. Lines start at 1.
blameOptionsSetMinimumLine :: (HasCallStack, MonadIO m) => BlameOptions -> Word32 -> m ()

-- | Set the minimum number of characters that must be detected as
--   moving/copying within a file for it to associate those lines with a
--   parent commit. This is only used when any of the
--   <tt><i>GGIT_BLAME_TRACK_COPIES_</i></tt> flags are specified. The
--   default value is 20.
blameOptionsSetMinimumMatchCharacters :: (HasCallStack, MonadIO m) => BlameOptions -> Word16 -> m ()

-- | Set the id of the newest commit to consider in the blame. Specify
--   <a>Nothing</a> to set the default value which indicates to use HEAD.
blameOptionsSetNewestCommit :: (HasCallStack, MonadIO m) => BlameOptions -> Maybe OId -> m ()

-- | Set the id of the oldest commit to consider in the blame. Specify
--   <a>Nothing</a> to set the default value which indicates to consider
--   the first commit without a parent.
blameOptionsSetOldestCommit :: (HasCallStack, MonadIO m) => BlameOptions -> Maybe OId -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.BlameOptions.BlameOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.BlameOptions.BlameOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.BlameOptions.BlameOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.BlameOptions.BlameOptions
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.BlameOptions.BlameOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.BlameOptions.BlameOptions


-- | Represents a blame hunk.
module GI.Ggit.Structs.BlameHunk

-- | Memory-managed wrapper type.
newtype BlameHunk
BlameHunk :: ManagedPtr BlameHunk -> BlameHunk

-- | Get the id of the commit where this hunk was last changed.
blameHunkGetFinalCommitId :: (HasCallStack, MonadIO m) => BlameHunk -> m (Maybe OId)

-- | Get the signature of the final version of the hunk.
blameHunkGetFinalSignature :: (HasCallStack, MonadIO m) => BlameHunk -> m (Maybe Signature)

-- | Get the line number where the hunk begins in the final version of the
--   file. Line numbers start at 1.
blameHunkGetFinalStartLineNumber :: (HasCallStack, MonadIO m) => BlameHunk -> m Word16

-- | Get the number of lines in the hunk.
blameHunkGetLinesInHunk :: (HasCallStack, MonadIO m) => BlameHunk -> m Word16

-- | Get the id of the commit where the hunk was found. This is usually the
--   same the final commit id, except when
--   <tt><i>GGIT_BLAME_TRACK_COPIES_ANY_COMMIT</i></tt> was used.
blameHunkGetOrigCommitId :: (HasCallStack, MonadIO m) => BlameHunk -> m (Maybe OId)

-- | Get the path of the file where this hunk originated, as of the commit
--   specified by <tt><i>ggit_blame_hunk_get_orig_commit_id</i></tt>.
blameHunkGetOrigPath :: (HasCallStack, MonadIO m) => BlameHunk -> m (Maybe Text)

-- | Get the signature of the commit specified by
--   <tt><i>ggit_blame_hunk_get_orig_commit_id</i></tt>.
blameHunkGetOrigSignature :: (HasCallStack, MonadIO m) => BlameHunk -> m (Maybe Signature)

-- | Get the line number where the hunk begins in the file specified by
--   <tt><i>ggit_blame_hunk_get_orig_path</i></tt> at the commit specified
--   by <tt><i>ggit_blame_hunk_get_orig_commit_id</i></tt>. Line numbers
--   start at 1.
blameHunkGetOrigStartLineNumber :: (HasCallStack, MonadIO m) => BlameHunk -> m Word16

-- | Get whether the hunk has been tracked to a boundary commit (the root,
--   or the commit specified in
--   <tt><i>ggit_blame_options_set_oldest_commit</i></tt>).
blameHunkIsBoundary :: (HasCallStack, MonadIO m) => BlameHunk -> m Bool

-- | Atomically increments the reference count of <i><tt>blameHunk</tt></i>
--   by one. This function is MT-safe and may be called from any thread.
blameHunkRef :: (HasCallStack, MonadIO m) => BlameHunk -> m (Maybe BlameHunk)

-- | Atomically decrements the reference count of <i><tt>blameHunk</tt></i>
--   by one. If the reference count drops to 0, <i><tt>blameHunk</tt></i>
--   is freed.
blameHunkUnref :: (HasCallStack, MonadIO m) => BlameHunk -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.BlameHunk.BlameHunk
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.BlameHunk.BlameHunk
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.BlameHunk.BlameHunk
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.BlameHunk.BlameHunk
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.BlameHunk.BlameHunk
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.BlameHunk.BlameHunk


-- | Represents an annotated commit object.
module GI.Ggit.Structs.AnnotatedCommit

-- | Memory-managed wrapper type.
newtype AnnotatedCommit
AnnotatedCommit :: ManagedPtr AnnotatedCommit -> AnnotatedCommit

-- | Gets the commit ID that the given <i><tt>annotatedCommit</tt></i> refs
--   to.
annotatedCommitGetId :: (HasCallStack, MonadIO m) => AnnotatedCommit -> m (Maybe OId)

-- | Create a GgitAnnotatedCommit from the given reference
annotatedCommitNewFromRef :: (HasCallStack, MonadIO m, IsRepository a, IsRef b) => a -> b -> m AnnotatedCommit

-- | Atomically increments the reference count of
--   <i><tt>annotatedCommit</tt></i> by one. This function is MT-safe and
--   may be called from any thread.
annotatedCommitRef :: (HasCallStack, MonadIO m) => AnnotatedCommit -> m (Maybe AnnotatedCommit)

-- | Atomically decrements the reference count of
--   <i><tt>annotatedCommit</tt></i> by one. If the reference count drops
--   to 0, <i><tt>annotatedCommit</tt></i> is freed.
annotatedCommitUnref :: (HasCallStack, MonadIO m) => AnnotatedCommit -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.AnnotatedCommit.AnnotatedCommit


-- | Represents a tag object.
module GI.Ggit.Objects.Tag

-- | Memory-managed wrapper type.
newtype Tag
Tag :: ManagedPtr Tag -> Tag

-- | Type class for types which can be safely cast to <a>Tag</a>, for
--   instance with <a>toTag</a>.
class (GObject o, IsDescendantOf Tag o) => IsTag o

-- | Cast to <a>Tag</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toTag :: (MonadIO m, IsTag o) => o -> m Tag

-- | Gets the message of <i><tt>tag</tt></i>.
tagGetMessage :: (HasCallStack, MonadIO m, IsTag a) => a -> m (Maybe Text)

-- | Gets the name of <i><tt>tag</tt></i>.
tagGetName :: (HasCallStack, MonadIO m, IsTag a) => a -> m (Maybe Text)

-- | Get the tagger (author) of <i><tt>tag</tt></i>. The returned value
--   must be free with <a>objectUnref</a>.
tagGetTagger :: (HasCallStack, MonadIO m, IsTag a) => a -> m (Maybe Signature)

-- | Gets the target <a>Object</a> of <i><tt>tag</tt></i>.
--   
--   This method performs a repository lookup for the given object and
--   returns it.
tagGetTarget :: (HasCallStack, MonadIO m, IsTag a) => a -> m (Maybe Object)

-- | Gets the target <a>OId</a> of <i><tt>tag</tt></i>.
tagGetTargetId :: (HasCallStack, MonadIO m, IsTag a) => a -> m (Maybe OId)

-- | Get the target object type.
tagGetTargetType :: (HasCallStack, MonadIO m, IsTag a) => a -> m GType

-- | Recursively peel a tag until a non tag object is found.
tagPeel :: (HasCallStack, MonadIO m, IsTag a) => a -> m (Maybe Object)
instance GHC.Classes.Eq GI.Ggit.Objects.Tag.Tag
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Tag.Tag o) => GI.Ggit.Objects.Tag.IsTag o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Tag.Tag
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Tag.Tag
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Tag.Tag
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Tag.Tag
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Tag.Tag


-- | Represents a revision walker.
module GI.Ggit.Objects.RevisionWalker

-- | Memory-managed wrapper type.
newtype RevisionWalker
RevisionWalker :: ManagedPtr RevisionWalker -> RevisionWalker

-- | Type class for types which can be safely cast to
--   <a>RevisionWalker</a>, for instance with <a>toRevisionWalker</a>.
class (GObject o, IsDescendantOf RevisionWalker o) => IsRevisionWalker o

-- | Cast to <a>RevisionWalker</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRevisionWalker :: (MonadIO m, IsRevisionWalker o) => o -> m RevisionWalker

-- | Gets the repository on which this walker is operating.
revisionWalkerGetRepository :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> m (Maybe Repository)

-- | Marks a commit (and its ancestors) uninteresting for the output.
--   
--   The given OID must belong to a commit on the walked repository.
--   
--   The resolved commit and all its parents will be hidden from the output
--   on the revision walk.
revisionWalkerHide :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> OId -> m ()

-- | Hide all OIDs pointed to by references that match the given glob
--   pattern to the revsision walker. A leading 'refs/' is implied if not
--   present, as well as a trailing '/ \ *' if the glob lacks '?', '\ *' or
--   '['.
revisionWalkerHideGlob :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> Text -> m ()

-- | Hide the OID of the current HEAD to the revision walker.
revisionWalkerHideHead :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> m ()

-- | Hide the OID pointed to by the named reference to the revision walker.
revisionWalkerHideRef :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> Text -> m ()

-- | Creates a new revision walker to iterate through
--   <i><tt>repository</tt></i>.
--   
--   This revision walker uses a custom memory pool and an internal commit
--   cache, so it is relatively expensive to allocate.
--   
--   For maximum performance, this revision walker should be reused for
--   different walks.
--   
--   This revision walker is *not* thread safe: it may only be used to walk
--   a repository on a single thread; however, it is possible to have
--   several revision walkers in several different threads walking the same
--   repository.
revisionWalkerNew :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe RevisionWalker)

-- | Gets the next commit from the revision walk.
--   
--   The initial call to this method is *not* blocking when iterating
--   through a repository with a time-sorting mode.
--   
--   Iterating with Topological or inverted modes makes the initial call
--   blocking to preprocess the commit list, but this block should be
--   mostly unnoticeable on most repositories (topological preprocessing
--   times at 0.3s on the git.git repo).
--   
--   The revision walker is reset when the walk is over.
revisionWalkerNext :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> m (Maybe OId)

-- | Marks a commit to start traversal from.
--   
--   The given OID must belong to a commit on the walked repository.
--   
--   The given commit will be used as one of the roots when starting the
--   revision walk. At least one commit must be pushed the repository
--   before a walk can be started.
revisionWalkerPush :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> OId -> m ()

-- | Push all OIDs pointed to by references that match the given glob
--   pattern to the revsision walker. A leading 'refs/' is implied if not
--   present, as well as a trailing '/ \ *' if the glob lacks '?', '\ *' or
--   '['.
revisionWalkerPushGlob :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> Text -> m ()

-- | Push the OID of the current HEAD to the revision walker.
revisionWalkerPushHead :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> m ()

-- | Push and hide the respective endpoints of the given range. The range
--   should be of the form: &amp;ltcommit&amp;gt..&amp;lt;commit&amp;gt;,
--   where each &amp;lt;commit&amp;gt; is in the form accepted by revparse.
--   The left-hand commit will be hidden and the right-hand commit pushed.
revisionWalkerPushRange :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> Text -> m ()

-- | Push the OID pointed to by the named reference to the revision walker.
revisionWalkerPushRef :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> Text -> m ()

-- | Resets the revision walker for reuse.
--   
--   This will clear all the pushed and hidden commits, and leave the
--   walker in a blank state (just like at creation) ready to receive new
--   commit pushes and start a new walk.
--   
--   The revision walk is automatically reset when a walk is over.
revisionWalkerReset :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> m ()

-- | Change the sorting mode when iterating through the repository's
--   contents.
--   
--   Changing the sorting mode resets the walker.
revisionWalkerSetSortMode :: (HasCallStack, MonadIO m, IsRevisionWalker a) => a -> [SortMode] -> m ()

-- | Set the value of the “<tt>repository</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #repository
--   </pre>
clearRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>repository</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRevisionWalkerRepository :: (IsRevisionWalker o, MonadIO m, IsRepository a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>repository</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> revisionWalker #repository
--   </pre>
getRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o) => o -> m (Maybe Repository)

-- | Set the value of the “<tt>repository</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> revisionWalker [ #repository <a>:=</a> value ]
--   </pre>
setRevisionWalkerRepository :: (MonadIO m, IsRevisionWalker o, IsRepository a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.RevisionWalker.RevisionWalker o) => GI.Ggit.Objects.RevisionWalker.IsRevisionWalker o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.RevisionWalker.RevisionWalker


-- | Represents a generic object in a repository.
module GI.Ggit.Objects.Object

-- | Memory-managed wrapper type.
newtype Object
Object :: ManagedPtr Object -> Object

-- | Type class for types which can be safely cast to <a>Object</a>, for
--   instance with <a>toObject</a>.
class (GObject o, IsDescendantOf Object o) => IsObject o

-- | Cast to <a>Object</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toObject :: (MonadIO m, IsObject o) => o -> m Object

-- | Gets the <a>OId</a> of <i><tt>object</tt></i>.
objectGetId :: (HasCallStack, MonadIO m, IsObject a) => a -> m (Maybe OId)

-- | Gets the <a>Repository</a> that owns <i><tt>object</tt></i>.
objectGetOwner :: (HasCallStack, MonadIO m, IsObject a) => a -> m (Maybe Repository)
instance GHC.Classes.Eq GI.Ggit.Objects.Object.Object
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Object.Object o) => GI.Ggit.Objects.Object.IsObject o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Object.Object
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Object.Object
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Object.Object
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Object.Object
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Object.Object


-- | Represents an index object.
module GI.Ggit.Objects.Index

-- | Memory-managed wrapper type.
newtype Index
Index :: ManagedPtr Index -> Index

-- | Type class for types which can be safely cast to <a>Index</a>, for
--   instance with <a>toIndex</a>.
class (GObject o, IsDescendantOf Index o) => IsIndex o

-- | Cast to <a>Index</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toIndex :: (MonadIO m, IsIndex o) => o -> m Index

-- | Add a file to the index.
indexAdd :: (HasCallStack, MonadIO m, IsIndex a) => a -> IndexEntry -> m ()

-- | Add a file to the index. The specified file must be in the working
--   directory and must exist and be readable.
indexAddFile :: (HasCallStack, MonadIO m, IsIndex a, IsFile b) => a -> b -> m ()

-- | Add a file to the index by path. You can specify both relative paths
--   (to the working directory) and absolute paths. Absolute paths however
--   must reside in the working directory. The specified path must exist
--   and must be readable.
indexAddPath :: (HasCallStack, MonadIO m, IsIndex a) => a -> Text -> m ()

-- | Get the index entries enumerator.
indexGetEntries :: (HasCallStack, MonadIO m, IsIndex a) => a -> m (Maybe IndexEntries)

-- | Get the resolve undo entries enumerator.
indexGetEntriesResolveUndo :: (HasCallStack, MonadIO m, IsIndex a) => a -> m (Maybe IndexEntriesResolveUndo)

-- | Get the <a>Repository</a> that owns the index.
indexGetOwner :: (HasCallStack, MonadIO m, IsIndex a) => a -> m (Maybe Repository)

-- | Get whether the index has any conflicts.
indexHasConflicts :: (HasCallStack, MonadIO m, IsIndex a) => a -> m Bool

-- | Create a new bare Git index object as a memory representation of the
--   Git index file in <i><tt>file</tt></i>, without a repository to back
--   it.
indexOpen :: (HasCallStack, MonadIO m, IsFile a) => a -> m (Maybe Index)

-- | Update the contents of an existing index object in memory by reading
--   from the hard disk.
--   
--   If <i><tt>force</tt></i> is true, this performs a "hard" read that
--   discards in-memory changes and always reloads the on-disk index data.
--   If there is no on-disk version, the index will be cleared.
--   
--   If <i><tt>force</tt></i> is false, this does a "soft" read that
--   reloads the index data from disk only if it has changed since the last
--   time it was loaded. Purely in-memory index data will be untouched. Be
--   aware: if there are changes on disk, unwritten in-memory changes are
--   discarded.
indexRead :: (HasCallStack, MonadIO m, IsIndex a) => a -> Bool -> m ()

-- | Remove a file from the index (specified by position).
indexRemove :: (HasCallStack, MonadIO m, IsIndex a, IsFile b) => a -> b -> Int32 -> m ()

-- | Write an existing index object from memory back to disk using an
--   atomic file lock.
indexWrite :: (HasCallStack, MonadIO m, IsIndex a) => a -> m ()

-- | Write a new tree object to disk containing a representation of the
--   current state of the index. The index must be associated to an
--   existing repository and must not contain any files in conflict. You
--   can use the resulting tree to for instance create a commit.
indexWriteTree :: (HasCallStack, MonadIO m, IsIndex a) => a -> m (Maybe OId)

-- | Write a new tree object to <i><tt>repository</tt></i> containing a
--   representation of the current state of the index. The index must not
--   contain any files in conflict. You can use the resulting tree to for
--   instance create a commit.
indexWriteTreeTo :: (HasCallStack, MonadIO m, IsIndex a, IsRepository b) => a -> b -> m (Maybe OId)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>file</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructIndexFile :: (IsIndex o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>file</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> index #file
--   </pre>
getIndexFile :: (MonadIO m, IsIndex o) => o -> m (Maybe File)
instance GHC.Classes.Eq GI.Ggit.Objects.Index.Index
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Index.Index o) => GI.Ggit.Objects.Index.IsIndex o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Index.Index
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Index.Index
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Index.Index
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Index.Index
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Index.Index


-- | <i>No description available in the introspection data.</i>
module GI.Ggit.Objects.DiffFormatEmailOptions

-- | Memory-managed wrapper type.
newtype DiffFormatEmailOptions
DiffFormatEmailOptions :: ManagedPtr DiffFormatEmailOptions -> DiffFormatEmailOptions

-- | Type class for types which can be safely cast to
--   <a>DiffFormatEmailOptions</a>, for instance with
--   <a>toDiffFormatEmailOptions</a>.
class (GObject o, IsDescendantOf DiffFormatEmailOptions o) => IsDiffFormatEmailOptions o

-- | Cast to <a>DiffFormatEmailOptions</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toDiffFormatEmailOptions :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m DiffFormatEmailOptions

-- | Get the author.
diffFormatEmailOptionsGetAuthor :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> m (Maybe Signature)

-- | Get the body.
diffFormatEmailOptionsGetBody :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> m (Maybe Text)

-- | Get the flags.
diffFormatEmailOptionsGetFlags :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> m [DiffFormatEmailFlags]

-- | Get the object id.
diffFormatEmailOptionsGetId :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> m (Maybe OId)

-- | Get the patch number.
diffFormatEmailOptionsGetPatchNumber :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> m Word32

-- | Get the summary.
diffFormatEmailOptionsGetSummary :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> m (Maybe Text)

-- | Get the total number of patches.
diffFormatEmailOptionsGetTotalPatches :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> m Word32

-- | Create a new checkout options object.
diffFormatEmailOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe DiffFormatEmailOptions)

-- | Set the author.
diffFormatEmailOptionsSetAuthor :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a, IsSignature b) => a -> Maybe b -> m ()

-- | Set the body.
diffFormatEmailOptionsSetBody :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> Maybe Text -> m ()

-- | Set the flags.
diffFormatEmailOptionsSetFlags :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> [DiffFormatEmailFlags] -> m ()

-- | Set the object id.
diffFormatEmailOptionsSetId :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> Maybe OId -> m ()

-- | Set the patch number.
diffFormatEmailOptionsSetPatchNumber :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> Word32 -> m ()

-- | Set the summary.
diffFormatEmailOptionsSetSummary :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> Maybe Text -> m ()

-- | Set the total number of patches.
diffFormatEmailOptionsSetTotalPatches :: (HasCallStack, MonadIO m, IsDiffFormatEmailOptions a) => a -> Word32 -> m ()

-- | Set the value of the “<tt>author</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #author
--   </pre>
clearDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>author</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDiffFormatEmailOptionsAuthor :: (IsDiffFormatEmailOptions o, MonadIO m, IsSignature a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>author</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFormatEmailOptions #author
--   </pre>
getDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe Signature)

-- | Set the value of the “<tt>author</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFormatEmailOptions [ #author <a>:=</a> value ]
--   </pre>
setDiffFormatEmailOptionsAuthor :: (MonadIO m, IsDiffFormatEmailOptions o, IsSignature a) => o -> a -> m ()

-- | Set the value of the “<tt>body</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #body
--   </pre>
clearDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>body</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDiffFormatEmailOptionsBody :: (IsDiffFormatEmailOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>body</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFormatEmailOptions #body
--   </pre>
getDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>body</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFormatEmailOptions [ #body <a>:=</a> value ]
--   </pre>
setDiffFormatEmailOptionsBody :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDiffFormatEmailOptionsFlags :: (IsDiffFormatEmailOptions o, MonadIO m) => [DiffFormatEmailFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFormatEmailOptions #flags
--   </pre>
getDiffFormatEmailOptionsFlags :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m [DiffFormatEmailFlags]

-- | Set the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFormatEmailOptions [ #flags <a>:=</a> value ]
--   </pre>
setDiffFormatEmailOptionsFlags :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> [DiffFormatEmailFlags] -> m ()

-- | Set the value of the “<tt>id</tt>” property to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #id
--   </pre>
clearDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>id</tt>” property. This is rarely needed directly, but it is used
--   by <a>new</a>.
constructDiffFormatEmailOptionsId :: (IsDiffFormatEmailOptions o, MonadIO m) => OId -> m (GValueConstruct o)

-- | Get the value of the “<tt>id</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFormatEmailOptions #id
--   </pre>
getDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe OId)

-- | Set the value of the “<tt>id</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFormatEmailOptions [ #id <a>:=</a> value ]
--   </pre>
setDiffFormatEmailOptionsId :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> OId -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>patch-number</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructDiffFormatEmailOptionsPatchNumber :: (IsDiffFormatEmailOptions o, MonadIO m) => Word64 -> m (GValueConstruct o)

-- | Get the value of the “<tt>patch-number</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFormatEmailOptions #patchNumber
--   </pre>
getDiffFormatEmailOptionsPatchNumber :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m Word64

-- | Set the value of the “<tt>patch-number</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFormatEmailOptions [ #patchNumber <a>:=</a> value ]
--   </pre>
setDiffFormatEmailOptionsPatchNumber :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Word64 -> m ()

-- | Set the value of the “<tt>summary</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #summary
--   </pre>
clearDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>summary</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructDiffFormatEmailOptionsSummary :: (IsDiffFormatEmailOptions o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>summary</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFormatEmailOptions #summary
--   </pre>
getDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>summary</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFormatEmailOptions [ #summary <a>:=</a> value ]
--   </pre>
setDiffFormatEmailOptionsSummary :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Text -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>total-patches</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructDiffFormatEmailOptionsTotalPatches :: (IsDiffFormatEmailOptions o, MonadIO m) => Word64 -> m (GValueConstruct o)

-- | Get the value of the “<tt>total-patches</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffFormatEmailOptions #totalPatches
--   </pre>
getDiffFormatEmailOptionsTotalPatches :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> m Word64

-- | Set the value of the “<tt>total-patches</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffFormatEmailOptions [ #totalPatches <a>:=</a> value ]
--   </pre>
setDiffFormatEmailOptionsTotalPatches :: (MonadIO m, IsDiffFormatEmailOptions o) => o -> Word64 -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions o) => GI.Ggit.Objects.DiffFormatEmailOptions.IsDiffFormatEmailOptions o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions


-- | Represents the parents of a commit object.
module GI.Ggit.Objects.CommitParents

-- | Memory-managed wrapper type.
newtype CommitParents
CommitParents :: ManagedPtr CommitParents -> CommitParents

-- | Type class for types which can be safely cast to <a>CommitParents</a>,
--   for instance with <a>toCommitParents</a>.
class (GObject o, IsDescendantOf CommitParents o) => IsCommitParents o

-- | Cast to <a>CommitParents</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCommitParents :: (MonadIO m, IsCommitParents o) => o -> m CommitParents

-- | Get the <a>Commit</a> of a parent.
commitParentsGet :: (HasCallStack, MonadIO m, IsCommitParents a) => a -> Word32 -> m (Maybe Commit)

-- | Get the <a>OId</a> of a parent.
commitParentsGetId :: (HasCallStack, MonadIO m, IsCommitParents a) => a -> Word32 -> m (Maybe OId)

-- | Get the number of parents in the parents collection.
commitParentsGetSize :: (HasCallStack, MonadIO m, IsCommitParents a) => a -> m Word32

-- | <i>No description available in the introspection data.</i>
commitParentsNew :: (HasCallStack, MonadIO m, IsCommit a) => a -> m CommitParents

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>commit</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructCommitParentsCommit :: (IsCommitParents o, MonadIO m, IsCommit a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>commit</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> commitParents #commit
--   </pre>
getCommitParentsCommit :: (MonadIO m, IsCommitParents o) => o -> m (Maybe Commit)

-- | Get the value of the “<tt>size</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> commitParents #size
--   </pre>
getCommitParentsSize :: (MonadIO m, IsCommitParents o) => o -> m Word32
instance GHC.Classes.Eq GI.Ggit.Objects.CommitParents.CommitParents
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.CommitParents.CommitParents o) => GI.Ggit.Objects.CommitParents.IsCommitParents o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.CommitParents.CommitParents
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.CommitParents.CommitParents
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CommitParents.CommitParents
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.CommitParents.CommitParents
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.CommitParents.CommitParents


-- | Represents a commit object.
module GI.Ggit.Objects.Commit

-- | Memory-managed wrapper type.
newtype Commit
Commit :: ManagedPtr Commit -> Commit

-- | Type class for types which can be safely cast to <a>Commit</a>, for
--   instance with <a>toCommit</a>.
class (GObject o, IsDescendantOf Commit o) => IsCommit o

-- | Cast to <a>Commit</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCommit :: (MonadIO m, IsCommit o) => o -> m Commit

-- | Amend an existing commit. If <i><tt>updateRef</tt></i> is not
--   <a>Nothing</a>, the given reference will be updated to point to the
--   newly created commit. Use "HEAD" to update the HEAD of the current
--   branch and make it point to this commit.
--   
--   If <i><tt>messageEncoding</tt></i> is set to <a>Nothing</a>, "UTF-8"
--   encoding is assumed for the provided <i><tt>message</tt></i>. Note
--   that <i><tt>message</tt></i> will not be cleaned up automatically. You
--   can use <tt><i>ggit_message_prettify</i></tt> to do this yourself if
--   needed.
commitAmend :: (HasCallStack, MonadIO m, IsCommit a, IsSignature b, IsSignature c, IsTree d) => a -> Maybe Text -> b -> c -> Maybe Text -> Text -> d -> m (Maybe OId)

-- | Gets the author of <i><tt>commit</tt></i>. The returned value must be
--   free'd with <a>objectUnref</a>.
commitGetAuthor :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe Signature)

-- | Gets the committer of <i><tt>commit</tt></i>. The returned value must
--   be free'd with <a>objectUnref</a>.
commitGetCommitter :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe Signature)

-- | Gets the full message of <i><tt>commit</tt></i>. The resulting message
--   is always encoded in UTF-8.
commitGetMessage :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe Text)

-- | Get the encoding for the message of a commit, as a string representing
--   a standard encoding name.
--   
--   The encoding may be <a>Nothing</a> if the 'encoding' header in the
--   commit is missing; in that case UTF-8 is assumed.
commitGetMessageEncoding :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe Text)

-- | Gets the commit object that is the n-th generation ancestor of the
--   named commit object, following only the first parents. Passing
--   <tt><i>0</i></tt> to the <i><tt>n</tt></i> parameter returns another
--   instance of <i><tt>commit</tt></i>.
commitGetNthAncestor :: (HasCallStack, MonadIO m, IsCommit a) => a -> Word32 -> m (Maybe Commit)

-- | Gets the parents collection for <i><tt>commit</tt></i>.
commitGetParents :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe CommitParents)

-- | Gets the subject of <i><tt>commit</tt></i>. The subject of a commit is
--   the first line of the commit message (as per convention). The
--   resulting subject is always encoded in UTF-8.
commitGetSubject :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe Text)

-- | Get the tree object for <i><tt>commit</tt></i>.
commitGetTree :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe Tree)

-- | Get the <a>OId</a> of the tree of <i><tt>commit</tt></i>. Note that
--   this is more efficient than getting the tree object with
--   <a>commitGetTree</a> because no additional files need to be read from
--   disk.
commitGetTreeId :: (HasCallStack, MonadIO m, IsCommit a) => a -> m (Maybe OId)
instance GHC.Classes.Eq GI.Ggit.Objects.Commit.Commit
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Commit.Commit o) => GI.Ggit.Objects.Commit.IsCommit o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Commit.Commit
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Commit.Commit
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Commit.Commit
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Commit.Commit
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Commit.Commit


-- | Represents a blob stream object.
module GI.Ggit.Objects.BlobOutputStream

-- | Memory-managed wrapper type.
newtype BlobOutputStream
BlobOutputStream :: ManagedPtr BlobOutputStream -> BlobOutputStream

-- | Type class for types which can be safely cast to
--   <a>BlobOutputStream</a>, for instance with <a>toBlobOutputStream</a>.
class (GObject o, IsDescendantOf BlobOutputStream o) => IsBlobOutputStream o

-- | Cast to <a>BlobOutputStream</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toBlobOutputStream :: (MonadIO m, IsBlobOutputStream o) => o -> m BlobOutputStream

-- | Get the id of the written blob. The blob id is only available after
--   the stream has been properly closed. If an error occurred while
--   writing the blob, the <a>Nothing</a> is returned and
--   <i><tt>error</tt></i> is set accordingly.
blobOutputStreamGetId :: (HasCallStack, MonadIO m, IsBlobOutputStream a) => a -> m (Maybe OId)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>repository</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructBlobOutputStreamRepository :: (IsBlobOutputStream o, MonadIO m, IsRepository a) => a -> m (GValueConstruct o)
instance GHC.Classes.Eq GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.BlobOutputStream.BlobOutputStream o) => GI.Ggit.Objects.BlobOutputStream.IsBlobOutputStream o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.BlobOutputStream.BlobOutputStream


-- | Represents a unique ID of any object.
module GI.Ggit.Structs.OId

-- | Memory-managed wrapper type.
newtype OId
OId :: ManagedPtr OId -> OId

-- | Compare two <a>OId</a> structures.
oIdCompare :: (HasCallStack, MonadIO m) => OId -> OId -> m Int32

-- | Copies <i><tt>oid</tt></i> into a newly allocated <a>OId</a>.
oIdCopy :: (HasCallStack, MonadIO m) => OId -> m (Maybe OId)

-- | Compares two <a>OId</a> for equality.
oIdEqual :: (HasCallStack, MonadIO m) => OId -> OId -> m Bool

-- | Frees <i><tt>oid</tt></i>.
oIdFree :: (HasCallStack, MonadIO m) => OId -> m ()

-- | Check whether the object id has a given prefix. Note that the prefix
--   is specified in hexadecimal ASCII.
oIdHasPrefix :: (HasCallStack, MonadIO m) => OId -> Text -> m Bool

-- | Computes a hash value for a git object identifier.
oIdHash :: (HasCallStack, MonadIO m) => OId -> m Word32

-- | Get whether the oid contains only zeros.
oIdIsZero :: (HasCallStack, MonadIO m) => OId -> m Bool

-- | Creates a new <a>OId</a> from a raw oid.
oIdNewFromRaw :: (HasCallStack, MonadIO m) => ByteString -> m (Maybe OId)

-- | Parses a hex formatted object id into a <a>OId</a>.
oIdNewFromString :: (HasCallStack, MonadIO m) => Text -> m (Maybe OId)

-- | Converts <i><tt>oid</tt></i> into a readable string.
oIdToString :: (HasCallStack, MonadIO m) => OId -> m (Maybe Text)
instance GHC.Classes.Eq GI.Ggit.Structs.OId.OId
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.OId.OId
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.OId.OId
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.OId.OId
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.OId.OId
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.OId.OId


-- | Represents a patch object.
module GI.Ggit.Structs.Patch

-- | Memory-managed wrapper type.
newtype Patch
Patch :: ManagedPtr Patch -> Patch

-- | Get the diff delta corresponding to the patch.
patchGetDelta :: (HasCallStack, MonadIO m) => Patch -> m (Maybe DiffDelta)

-- | Get the <i><tt>idx</tt></i>'th hunk in the patch.
patchGetHunk :: (HasCallStack, MonadIO m) => Patch -> Word32 -> m (Maybe DiffHunk)

-- | Get the line statistics of the patch.
patchGetLineStats :: (HasCallStack, MonadIO m) => Patch -> m (Word32, Word32, Word32)

-- | Get the number of hunks in the patch.
patchGetNumHunks :: (HasCallStack, MonadIO m) => Patch -> m Word32

-- | Get the number of lines in <i><tt>hunk</tt></i>.
patchGetNumLinesInHunk :: (HasCallStack, MonadIO m) => Patch -> Word32 -> m Int32

-- | Directly generate a patch from the difference between two blobs.
--   
--   This is just like <a>diffBlobs</a> except it generates a patch object
--   for the difference instead of directly making callbacks. You can use
--   the standard ggit_patch accessor functions to read the patch data, and
--   you must call ggit_patch_unref on the patch when done.
patchNewFromBlobs :: (HasCallStack, MonadIO m, IsBlob a, IsBlob b, IsDiffOptions c) => Maybe a -> Maybe Text -> Maybe b -> Maybe Text -> Maybe c -> m (Maybe Patch)

-- | The <a>Patch</a> is a newly created object contains the text diffs for
--   the delta. You have to call <a>patchUnref</a> when you are done with
--   it. You can use the patch object to loop over all the hunks and lines
--   in the diff of the one delta.
patchNewFromDiff :: (HasCallStack, MonadIO m, IsDiff a) => a -> Word32 -> m (Maybe Patch)

-- | Atomically increments the reference count of <i><tt>patch</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
patchRef :: (HasCallStack, MonadIO m) => Patch -> m (Maybe Patch)

-- | Write the contents of a patch to the provided stream.
patchToStream :: (HasCallStack, MonadIO m, IsOutputStream a) => Patch -> a -> m ()

-- | Gets the content of a patch as a single diff text.
patchToString :: (HasCallStack, MonadIO m) => Patch -> m (Maybe Text)

-- | Atomically decrements the reference count of <i><tt>patch</tt></i> by
--   one. If the reference count drops to 0, <i><tt>patch</tt></i> is
--   freed.
patchUnref :: (HasCallStack, MonadIO m) => Patch -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.Patch.Patch
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.Patch.Patch
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.Patch.Patch
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.Patch.Patch
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.Patch.Patch
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.Patch.Patch


-- | Represents a rebase object.
module GI.Ggit.Objects.Rebase

-- | Memory-managed wrapper type.
newtype Rebase
Rebase :: ManagedPtr Rebase -> Rebase

-- | Type class for types which can be safely cast to <a>Rebase</a>, for
--   instance with <a>toRebase</a>.
class (GObject o, IsDescendantOf Rebase o) => IsRebase o

-- | Cast to <a>Rebase</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRebase :: (MonadIO m, IsRebase o) => o -> m Rebase

-- | Aborts a rebase that is currently in progress, resetting the
--   repository and working directory to their state before rebase began.
rebaseAbort :: (HasCallStack, MonadIO m, IsRebase a) => a -> m ()

-- | Commits the current patch. You must have resolved any conflicts that
--   were introduced during the patch application from the
--   <a>rebaseNext</a> invocation.
rebaseCommit :: (HasCallStack, MonadIO m, IsRebase a, IsSignature b, IsSignature c) => a -> Maybe b -> c -> Maybe Text -> m (Maybe OId)

-- | Finishes a rebase that is currently in progress once all patches have
--   been applied.
rebaseFinish :: (HasCallStack, MonadIO m, IsRebase a, IsSignature b) => a -> Maybe b -> m ()

-- | Gets the rebase operation specified by <i><tt>idx</tt></i>.
rebaseGetOperationByIndex :: (HasCallStack, MonadIO m, IsRebase a) => a -> Word32 -> m (Maybe RebaseOperation)

-- | Gets the count of rebase operations that are to be applied.
rebaseGetOperationEntryCount :: (HasCallStack, MonadIO m, IsRebase a) => a -> m Word32

-- | Gets the index of the rebase operation that is currently being
--   applied. If the first operation has not yet been applied (because you
--   have called <a>repositoryRebaseInit</a> but not yet <a>rebaseNext</a>)
--   then this returns <i><tt>gGITREBASENOOPERATION</tt></i>.
rebaseGetOperationIndex :: (HasCallStack, MonadIO m, IsRebase a) => a -> m Word32

-- | Performs the next rebase operation and returns the information about
--   it. If the operation is one that applies a patch (which is any
--   operation except <i><tt>gGITREBASEOPERATIONEXEC</tt></i>) then the
--   patch will be applied and the index and working directory will be
--   updated with the changes. If there are conflicts, you will need to
--   address those before committing the changes.
rebaseNext :: (HasCallStack, MonadIO m, IsRebase a) => a -> m (Maybe RebaseOperation)
instance GHC.Classes.Eq GI.Ggit.Objects.Rebase.Rebase
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Rebase.Rebase o) => GI.Ggit.Objects.Rebase.IsRebase o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Rebase.Rebase
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Rebase.Rebase
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Rebase.Rebase
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Rebase.Rebase
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Rebase.Rebase


-- | Represents a rebase operation.
module GI.Ggit.Structs.RebaseOperation

-- | Memory-managed wrapper type.
newtype RebaseOperation
RebaseOperation :: ManagedPtr RebaseOperation -> RebaseOperation

-- | Gets the executable the user has requested be run. This will only be
--   populated for operations of type
--   <i><tt>gGITREBASEOPERATIONEXEC</tt></i>.
rebaseOperationGetExec :: (HasCallStack, MonadIO m) => RebaseOperation -> m (Maybe Text)

-- | Gets the commit ID being cherry-picked. This will be populated for all
--   operations except those of type
--   <i><tt>gGITREBASEOPERATIONEXEC</tt></i>.
rebaseOperationGetId :: (HasCallStack, MonadIO m) => RebaseOperation -> m (Maybe OId)

-- | Gets the type of rebase operation.
rebaseOperationGetOperationType :: (HasCallStack, MonadIO m) => RebaseOperation -> m RebaseOperationType

-- | Atomically increments the reference count of
--   <i><tt>rebaseOperation</tt></i> by one. This function is MT-safe and
--   may be called from any thread.
rebaseOperationRef :: (HasCallStack, MonadIO m) => RebaseOperation -> m (Maybe RebaseOperation)

-- | Atomically decrements the reference count of
--   <i><tt>rebaseOperation</tt></i> by one. If the reference count drops
--   to 0, <i><tt>rebaseOperation</tt></i> is freed.
rebaseOperationUnref :: (HasCallStack, MonadIO m) => RebaseOperation -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.RebaseOperation.RebaseOperation
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.RebaseOperation.RebaseOperation
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.RebaseOperation.RebaseOperation
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.RebaseOperation.RebaseOperation
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.RebaseOperation.RebaseOperation
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.RebaseOperation.RebaseOperation


-- | Represents the options used when rebasing.
module GI.Ggit.Structs.RebaseOptions

-- | Memory-managed wrapper type.
newtype RebaseOptions
RebaseOptions :: ManagedPtr RebaseOptions -> RebaseOptions

-- | Copies <i><tt>rebaseOptions</tt></i> into a newly allocated
--   <a>RebaseOptions</a>.
rebaseOptionsCopy :: (HasCallStack, MonadIO m) => RebaseOptions -> m (Maybe RebaseOptions)

-- | Frees <i><tt>rebaseOptions</tt></i>.
rebaseOptionsFree :: (HasCallStack, MonadIO m) => RebaseOptions -> m ()

-- | Get the checkout options object or <a>Nothing</a> if not set.
rebaseOptionsGetCheckoutOptions :: (HasCallStack, MonadIO m) => RebaseOptions -> m (Maybe CheckoutOptions)

-- | Gets whether you want a quiet rebase experience.
rebaseOptionsGetQuiet :: (HasCallStack, MonadIO m) => RebaseOptions -> m Bool

-- | Gets the the name of the notes reference used to rewrite notes for
--   rebased commits when finishing the rebase or <a>Nothing</a> if not
--   set.
rebaseOptionsGetRewriteNotesRef :: (HasCallStack, MonadIO m) => RebaseOptions -> m (Maybe Text)

-- | Creates a new <a>RebaseOptions</a>.
rebaseOptionsNew :: (HasCallStack, MonadIO m) => m RebaseOptions

-- | <i>No description available in the introspection data.</i>
rebaseOptionsSetCheckoutOptions :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => RebaseOptions -> a -> m ()

-- | Used by <tt><i>ggit_rebase_init()</i></tt>, this will instruct other
--   clients working on this rebase that you want a quiet rebase
--   experience, which they may choose to provide in an
--   application-specific manner. This has no effect upon libgit2-glib
--   directly, but is provided for interoperability between Git tools.
rebaseOptionsSetQuiet :: (HasCallStack, MonadIO m) => RebaseOptions -> Bool -> m ()

-- | Used by <a>rebaseFinish</a>, this is the name of the notes reference
--   used to rewrite notes for rebased commits when finishing the rebase;
--   if <a>Nothing</a>, the contents of the configuration option
--   <tt>notes.rewriteRef</tt> is examined, unless the configuration option
--   <tt>notes.rewrite.rebase</tt> is set to false. If
--   <tt>notes.rewriteRef</tt> is also <a>Nothing</a>, notes will not be
--   rewritten.
rebaseOptionsSetRewriteNotesRef :: (HasCallStack, MonadIO m) => RebaseOptions -> Text -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.RebaseOptions.RebaseOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.RebaseOptions.RebaseOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.RebaseOptions.RebaseOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.RebaseOptions.RebaseOptions
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.RebaseOptions.RebaseOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.RebaseOptions.RebaseOptions


-- | Reprensents a git reference specification.
module GI.Ggit.Structs.RefSpec

-- | Memory-managed wrapper type.
newtype RefSpec
RefSpec :: ManagedPtr RefSpec -> RefSpec

-- | Gets the <i><tt>refspec</tt></i>'s destination.
refSpecGetDestination :: (HasCallStack, MonadIO m) => RefSpec -> m (Maybe Text)

-- | Gets the <i><tt>refspec</tt></i>'s source.
refSpecGetSource :: (HasCallStack, MonadIO m) => RefSpec -> m (Maybe Text)

-- | Whether updating is done forcefully.
refSpecIsForced :: (HasCallStack, MonadIO m) => RefSpec -> m Bool

-- | Atomically increments the reference count of <i><tt>refspec</tt></i>
--   by one. This function is MT-safe and may be called from any thread.
refSpecRef :: (HasCallStack, MonadIO m) => RefSpec -> m (Maybe RefSpec)

-- | Atomically decrements the reference count of <i><tt>refspec</tt></i>
--   by one. If the reference count drops to 0, <i><tt>refspec</tt></i> is
--   freed.
refSpecUnref :: (HasCallStack, MonadIO m) => RefSpec -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.RefSpec.RefSpec
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.RefSpec.RefSpec
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.RefSpec.RefSpec
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.RefSpec.RefSpec
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.RefSpec.RefSpec
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.RefSpec.RefSpec


-- | Reprensents a git reference.
module GI.Ggit.Objects.Ref

-- | Memory-managed wrapper type.
newtype Ref
Ref :: ManagedPtr Ref -> Ref

-- | Type class for types which can be safely cast to <a>Ref</a>, for
--   instance with <a>toRef</a>.
class (GObject o, IsDescendantOf Ref o) => IsRef o

-- | Cast to <a>Ref</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toRef :: (MonadIO m, IsRef o) => o -> m Ref

-- | Deletes <i><tt>ref</tt></i>.
--   
--   This method works for both direct and symbolic references.
--   
--   The reference will be immediately removed on disk and from memory. The
--   given reference pointer will no longer be valid.
refDelete :: (HasCallStack, MonadIO m, IsRef a) => a -> m ()

-- | Deletes the log for <i><tt>ref</tt></i>, on error
--   <i><tt>error</tt></i> is set.
refDeleteLog :: (HasCallStack, MonadIO m, IsRef a) => a -> m ()

-- | Gets the <a>Reflog</a> for <i><tt>ref</tt></i>. The reflog will be
--   created if it doesn't exist yet.
refGetLog :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Reflog)

-- | Gets the full name of <i><tt>ref</tt></i>.
refGetName :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Text)

-- | Gets the repository where <i><tt>ref</tt></i> resides.
refGetOwner :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Repository)

-- | Gets the type of <i><tt>ref</tt></i>. Either direct
--   (<tt><i>GGIT_REF_OID</i></tt>) or symbolic
--   (<tt><i>GGIT_REF_SYMBOLIC</i></tt>).
refGetReferenceType :: (HasCallStack, MonadIO m, IsRef a) => a -> m RefType

-- | Gets the shorthand name of <i><tt>ref</tt></i>.
refGetShorthand :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Text)

-- | Get full name to the reference pointed to by a symbolic reference.
--   Only available if the reference is symbolic.
refGetSymbolicTarget :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Text)

-- | Get the OID pointed to by a direct reference. Only available if the
--   reference is direct (i.e. an object id reference, not a symbolic one).
refGetTarget :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe OId)

-- | Get whether <i><tt>ref</tt></i> has an existing log.
refHasLog :: (HasCallStack, MonadIO m, IsRef a) => a -> m Bool

-- | Check whether the reference is a branch.
refIsBranch :: (HasCallStack, MonadIO m, IsRef a) => a -> m Bool

-- | Check whether the reference is a note.
refIsNote :: (HasCallStack, MonadIO m, IsRef a) => a -> m Bool

-- | Check whether the reference is a remote.
refIsRemote :: (HasCallStack, MonadIO m, IsRef a) => a -> m Bool

-- | Check whether the reference is a tag.
refIsTag :: (HasCallStack, MonadIO m, IsRef a) => a -> m Bool

-- | Check if the given <i><tt>name</tt></i> is a valid name for a
--   reference. Note that <i><tt>name</tt></i> should be the full ref name
--   (including prefixes).
--   
--   Valid toplevel names can contain only capital letters and underscores
--   and must start and end with a letter (e.g. HEAD, ORIG_HEAD).
--   
--   Valid refs/ names may contain any characters, except '~', '^', ':',
--   '\', '?', '[', '*', ".." and "@{", because they are interpreted by
--   revparse.
refIsValidName :: (HasCallStack, MonadIO m) => Text -> m Bool

-- | Convenient method to resolve a reference to an object.
refLookup :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Object)

-- | Rename an existing reference.
--   
--   This method works for both direct and symbolic references.
--   
--   The new name will be checked for validity. See
--   <tt>ggit_ref_create_symbolic()</tt> for rules about valid names.
--   
--   If not error, <i><tt>ref</tt></i> will be deleted from disk and a new
--   <a>Ref</a> will be returned.
--   
--   The reference will be immediately renamed in-memory and on disk.
--   
--   If the <tt>force</tt> flag is not enabled, and there's already a
--   reference with the given name, the renaming will fail.
--   
--   IMPORTANT: The user needs to write a proper reflog entry if the reflog
--   is enabled for the repository. We only rename the reflog if it exists.
refRename :: (HasCallStack, MonadIO m, IsRef a) => a -> Text -> Bool -> Text -> m (Maybe Ref)

-- | Resolves a symbolic reference.
--   
--   This method iteratively peels a symbolic reference until it resolves
--   to a direct reference to an OID.
--   
--   If a direct reference is passed as an argument, that reference is
--   returned immediately.
refResolve :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Ref)

-- | Create a new reference with the same name as the given reference but a
--   different symbolic target. The reference must be a symbolic reference,
--   otherwise this will fail.
--   
--   The new reference will be written to disk, overwriting the given
--   reference.
--   
--   The target name will be checked for validity. See
--   <tt>ggit_ref_create_symbolic()</tt> for rules about valid names.
refSetSymbolicTarget :: (HasCallStack, MonadIO m, IsRef a) => a -> Text -> Text -> m (Maybe Ref)

-- | Create a new reference with the same name as the given reference but a
--   different OID target. The reference must be a direct reference,
--   otherwise this will fail.
--   
--   The new reference will be written to disk, overwriting the given
--   reference.
refSetTarget :: (HasCallStack, MonadIO m, IsRef a) => a -> OId -> Text -> m (Maybe Ref)

-- | Get a string representation of the ref.
refToString :: (HasCallStack, MonadIO m, IsRef a) => a -> m (Maybe Text)
instance GHC.Classes.Eq GI.Ggit.Objects.Ref.Ref
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Ref.Ref o) => GI.Ggit.Objects.Ref.IsRef o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Ref.Ref
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Ref.Ref
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Ref.Ref
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Ref.Ref
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Ref.Ref


-- | Represents a reflog.
module GI.Ggit.Structs.Reflog

-- | Memory-managed wrapper type.
newtype Reflog
Reflog :: ManagedPtr Reflog -> Reflog

-- | Creates a reflog entry.
reflogAppend :: (HasCallStack, MonadIO m, IsSignature a) => Reflog -> OId -> a -> Text -> m ()

-- | Gets the number of log entries in <i><tt>reflog</tt></i>.
reflogGetEntryCount :: (HasCallStack, MonadIO m) => Reflog -> m Word32

-- | Gets the <a>ReflogEntry</a> at <i><tt>idx</tt></i> in
--   <i><tt>reflog</tt></i>, or <a>Nothing</a> if not found.
reflogGetEntryFromIndex :: (HasCallStack, MonadIO m) => Reflog -> Word32 -> m (Maybe ReflogEntry)

-- | Atomically increments the reference count of <i><tt>reflog</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
reflogRef :: (HasCallStack, MonadIO m) => Reflog -> m (Maybe Reflog)

-- | Renames the reflog for to <i><tt>newName</tt></i>, on error
--   <i><tt>error</tt></i> is set.
reflogRename :: (HasCallStack, MonadIO m) => Reflog -> Text -> m ()

-- | Atomically decrements the reference count of <i><tt>reflog</tt></i> by
--   one. If the reference count drops to 0, <i><tt>reflog</tt></i> is
--   freed.
reflogUnref :: (HasCallStack, MonadIO m) => Reflog -> m ()

-- | Write the reflog to disk.
reflogWrite :: (HasCallStack, MonadIO m) => Reflog -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.Reflog.Reflog
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.Reflog.Reflog
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.Reflog.Reflog
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.Reflog.Reflog
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.Reflog.Reflog
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.Reflog.Reflog


-- | Represents a reflog entry.
module GI.Ggit.Structs.ReflogEntry

-- | Memory-managed wrapper type.
newtype ReflogEntry
ReflogEntry :: ManagedPtr ReflogEntry -> ReflogEntry

-- | Gets the committer as a <a>Signature</a>.
reflogEntryGetCommitter :: (HasCallStack, MonadIO m) => ReflogEntry -> m (Maybe Signature)

-- | Gets the message.
reflogEntryGetMessage :: (HasCallStack, MonadIO m) => ReflogEntry -> m (Maybe Text)

-- | Gets the new <a>OId</a>.
reflogEntryGetNewId :: (HasCallStack, MonadIO m) => ReflogEntry -> m (Maybe OId)

-- | Gets the old <a>OId</a>.
reflogEntryGetOldId :: (HasCallStack, MonadIO m) => ReflogEntry -> m (Maybe OId)

-- | Atomically increments the reference count of
--   <i><tt>reflogEntry</tt></i> by one. This function is MT-safe and may
--   be called from any thread.
reflogEntryRef :: (HasCallStack, MonadIO m) => ReflogEntry -> m (Maybe ReflogEntry)

-- | Atomically decrements the reference count of
--   <i><tt>reflogEntry</tt></i> by one. If the reference count drops to 0,
--   <i><tt>reflogEntry</tt></i> is freed.
reflogEntryUnref :: (HasCallStack, MonadIO m) => ReflogEntry -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.ReflogEntry.ReflogEntry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.ReflogEntry.ReflogEntry
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.ReflogEntry.ReflogEntry
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.ReflogEntry.ReflogEntry
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.ReflogEntry.ReflogEntry
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.ReflogEntry.ReflogEntry


-- | Represents a git remote.
module GI.Ggit.Objects.Remote

-- | Memory-managed wrapper type.
newtype Remote
Remote :: ManagedPtr Remote -> Remote

-- | Type class for types which can be safely cast to <a>Remote</a>, for
--   instance with <a>toRemote</a>.
class (GObject o, IsDescendantOf Remote o) => IsRemote o

-- | Cast to <a>Remote</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRemote :: (MonadIO m, IsRemote o) => o -> m Remote

-- | Opens a connection to a remote. The transport is selected based on the
--   URL. The direction argument is due to a limitation of the git protocol
--   (over TCP or SSH) which starts up a specific binary which can only do
--   the one or the other.
remoteConnect :: (HasCallStack, MonadIO m, IsRemote a, IsRemoteCallbacks b, IsProxyOptions c) => a -> Direction -> b -> Maybe c -> Maybe Text -> m ()

-- | Closes the connection to the remote and frees the underlying
--   transport.
remoteDisconnect :: (HasCallStack, MonadIO m, IsRemote a) => a -> m ()

-- | Connect to the remote if not yet connected, negotiate with the remote
--   about which objects are missing and download the resulting packfile
--   and its index.
remoteDownload :: (HasCallStack, MonadIO m, IsRemote a) => a -> Maybe [Text] -> FetchOptions -> m ()

-- | Check whether <i><tt>remote</tt></i> is connected.
remoteGetConnected :: (HasCallStack, MonadIO m, IsRemote a) => a -> m Bool

-- | Get the list of fetch refspecs for the given remote.
remoteGetFetchSpecs :: (HasCallStack, MonadIO m, IsRemote a) => a -> m (Maybe [Text])

-- | Gets the remote's name.
remoteGetName :: (HasCallStack, MonadIO m, IsRemote a) => a -> m (Maybe Text)

-- | Gets the repository where <i><tt>remote</tt></i> resides.
remoteGetOwner :: (HasCallStack, MonadIO m, IsRemote a) => a -> m (Maybe Repository)

-- | Get the list of push refspecs for the given remote.
remoteGetPushSpecs :: (HasCallStack, MonadIO m, IsRemote a) => a -> m (Maybe [Text])

-- | Gets the remote's url.
remoteGetUrl :: (HasCallStack, MonadIO m, IsRemote a) => a -> m (Maybe Text)

-- | Get a list of refs at the remote.
remoteList :: (HasCallStack, MonadIO m, IsRemote a) => a -> m (Maybe [RemoteHead])

-- | Creates a remote with the default refspecs in memory. You can use this
--   when you have a URL instead of a remote's name.
remoteNew :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> Text -> m (Maybe Remote)

-- | Creates a remote with the specified refspec in memory. You can use
--   this when you have a URL instead of a remote's name.
remoteNewAnonymous :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m (Maybe Remote)

-- | Connect to the remote if not yet connected, negotiate with the remote
--   about which objects are missing, create a packfile with the missing
--   objects and send it.
remotePush :: (HasCallStack, MonadIO m, IsRemote a, IsPushOptions b) => a -> Maybe [Text] -> b -> m ()

-- | Update tips to the new state.
remoteUpdateTips :: (HasCallStack, MonadIO m, IsRemote a, IsRemoteCallbacks b) => a -> b -> Bool -> RemoteDownloadTagsType -> Maybe Text -> m ()

-- | Create a packfile and send it to the server
remoteUpload :: (HasCallStack, MonadIO m, IsRemote a, IsPushOptions b) => a -> Maybe [Text] -> b -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.Remote.Remote
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Remote.Remote o) => GI.Ggit.Objects.Remote.IsRemote o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Remote.Remote
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Remote.Remote
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Remote.Remote
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Remote.Remote
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Remote.Remote


-- | Represents a git remote head.
module GI.Ggit.Structs.RemoteHead

-- | Memory-managed wrapper type.
newtype RemoteHead
RemoteHead :: ManagedPtr RemoteHead -> RemoteHead

-- | Get the local oid of the remote head.
remoteHeadGetLocalOid :: (HasCallStack, MonadIO m) => RemoteHead -> m (Maybe OId)

-- | Get the remote head name.
remoteHeadGetName :: (HasCallStack, MonadIO m) => RemoteHead -> m (Maybe Text)

-- | Get the remote oid of the remote head.
remoteHeadGetOid :: (HasCallStack, MonadIO m) => RemoteHead -> m (Maybe OId)

-- | Get whether the remote head is local.
remoteHeadIsLocal :: (HasCallStack, MonadIO m) => RemoteHead -> m Bool

-- | <i>No description available in the introspection data.</i>
remoteHeadRef :: (HasCallStack, MonadIO m) => RemoteHead -> m RemoteHead

-- | <i>No description available in the introspection data.</i>
remoteHeadUnref :: (HasCallStack, MonadIO m) => RemoteHead -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.RemoteHead.RemoteHead
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.RemoteHead.RemoteHead
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.RemoteHead.RemoteHead
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.RemoteHead.RemoteHead
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.RemoteHead.RemoteHead
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.RemoteHead.RemoteHead


-- | Represents the options used when reverting.
module GI.Ggit.Structs.RevertOptions

-- | Memory-managed wrapper type.
newtype RevertOptions
RevertOptions :: ManagedPtr RevertOptions -> RevertOptions

-- | Copies <i><tt>revertOptions</tt></i> into a newly allocated
--   <a>RevertOptions</a>.
revertOptionsCopy :: (HasCallStack, MonadIO m) => RevertOptions -> m (Maybe RevertOptions)

-- | Frees <i><tt>revertOptions</tt></i>.
revertOptionsFree :: (HasCallStack, MonadIO m) => RevertOptions -> m ()

-- | Create a new <a>RevertOptions</a>. Note that the passed in
--   <i><tt>mergeOptions</tt></i> and <i><tt>checkoutOptions</tt></i> are
--   copied by this function, and alterations in either after this call are
--   therefore not reflected in the revert options.
--   
--   The <i><tt>mainline</tt></i> indicates which parent to use for the
--   revert when reverting a merge commit.
revertOptionsNew :: (HasCallStack, MonadIO m, IsCheckoutOptions a) => Word32 -> Maybe MergeOptions -> Maybe a -> m (Maybe RevertOptions)
instance GHC.Classes.Eq GI.Ggit.Structs.RevertOptions.RevertOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.RevertOptions.RevertOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.RevertOptions.RevertOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.RevertOptions.RevertOptions
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.RevertOptions.RevertOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.RevertOptions.RevertOptions


-- | Represents the options used when creating getting file status.
module GI.Ggit.Structs.StatusOptions

-- | Memory-managed wrapper type.
newtype StatusOptions
StatusOptions :: ManagedPtr StatusOptions -> StatusOptions

-- | Copies <i><tt>statusOptions</tt></i> into a newly allocated
--   <a>StatusOptions</a>.
statusOptionsCopy :: (HasCallStack, MonadIO m) => StatusOptions -> m (Maybe StatusOptions)

-- | Frees <i><tt>statusOptions</tt></i>.
statusOptionsFree :: (HasCallStack, MonadIO m) => StatusOptions -> m ()

-- | Creates a new <a>StatusOptions</a> for use in
--   <tt><i>ggit_repository_stash_foreach</i></tt>.
statusOptionsNew :: (HasCallStack, MonadIO m) => [StatusOption] -> StatusShow -> Maybe [Text] -> m StatusOptions
instance GHC.Classes.Eq GI.Ggit.Structs.StatusOptions.StatusOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.StatusOptions.StatusOptions
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.StatusOptions.StatusOptions
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.StatusOptions.StatusOptions
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.StatusOptions.StatusOptions
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.StatusOptions.StatusOptions


-- | Represents a git submodule.
module GI.Ggit.Structs.Submodule

-- | Memory-managed wrapper type.
newtype Submodule
Submodule :: ManagedPtr Submodule -> Submodule

-- | Gets whether to fetch recursively. See see gitmodules(5)
--   fetchRecurseSubmodules.
submoduleGetFetchRecurse :: (HasCallStack, MonadIO m) => Submodule -> m Bool

-- | <i>No description available in the introspection data.</i>
submoduleGetHeadId :: (HasCallStack, MonadIO m) => Submodule -> m OId

-- | Gets a <a>SubmoduleIgnore</a>. See see gitmodules(5) ignore.
submoduleGetIgnore :: (HasCallStack, MonadIO m) => Submodule -> m SubmoduleIgnore

-- | Gets the OID for the submodule in the index or <a>Nothing</a> if there
--   is no index.
submoduleGetIndexId :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe OId)

-- | Gets the name of the submodule from .gitmodules.
submoduleGetName :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe Text)

-- | Gets the containing repository for a submodule.
submoduleGetOwner :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe Repository)

-- | Gets the path to the submodule from the repo working directory. It is
--   almost always the same as the name. See <a>submoduleGetName</a>.
submoduleGetPath :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe Text)

-- | Gets a <a>SubmoduleUpdate</a>. See see gitmodules(5) update.
submoduleGetUpdate :: (HasCallStack, MonadIO m) => Submodule -> m SubmoduleUpdate

-- | Gets the url for the submodule or <a>Nothing</a> if the submodule has
--   been deleted but not yet committed.
submoduleGetUrl :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe Text)

-- | Gets the OID for the submodule in the current working directory.
--   Corresponds to looking up 'HEAD' in the checked out submodule. If
--   there are pending changes in the index or anything else, this won't
--   notice that. You should call <tt><i>ggit_submodule_status()</i></tt>
--   for a more complete picture about the state of the working directory.
submoduleGetWorkdirId :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe OId)

-- | Just like "git submodule init", this copies information about the
--   submodule into ".git/config". You can use the accessor functions above
--   to alter the in-memory git_submodule object and control what is
--   written to the config, overriding what is in .gitmodules.
submoduleInit :: (HasCallStack, MonadIO m) => Submodule -> Bool -> m ()

-- | Open the repository for a submodule. Multiple calls to this function
--   will return distinct <a>Repository</a> objects. Only submodules which
--   are checked out in the working directory can be opened.
submoduleOpen :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe Repository)

-- | Atomically increments the reference count of <i><tt>submodule</tt></i>
--   by one. This function is MT-safe and may be called from any thread.
submoduleRef :: (HasCallStack, MonadIO m) => Submodule -> m (Maybe Submodule)

-- | Rereads submodule info from config, index, and HEAD. Call this if you
--   have reason to believe that it has changed.
submoduleReload :: (HasCallStack, MonadIO m) => Submodule -> Bool -> m ()

-- | Copies the information about the submodules URL into the checked out
--   submodule config, acting like "git submodule sync". This is useful if
--   you have altered the URL for the submodule (or it has been altered by
--   a fetch of upstream changes) and you need to update your local repo.
submoduleSync :: (HasCallStack, MonadIO m) => Submodule -> m ()

-- | Atomically decrements the reference count of <i><tt>submodule</tt></i>
--   by one. If the reference count drops to 0, <i><tt>remote</tt></i> is
--   freed.
submoduleUnref :: (HasCallStack, MonadIO m) => Submodule -> m ()

-- | Update a submodule. This will clone a missing submodule and checkout
--   the subrepository to the commit specified in the index of the
--   containing repository. If the submodule repository doesn't contain the
--   target commit (e.g. because fetchRecurseSubmodules isn't set), then
--   the submodule is fetched using the fetch options supplied in options.
submoduleUpdate :: (HasCallStack, MonadIO m, IsSubmoduleUpdateOptions a) => Submodule -> Bool -> a -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.Submodule.Submodule
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.Submodule.Submodule
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.Submodule.Submodule
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.Submodule.Submodule
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.Submodule.Submodule
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.Submodule.Submodule


-- | Represents a git remote callbacks.
module GI.Ggit.Objects.RemoteCallbacks

-- | Memory-managed wrapper type.
newtype RemoteCallbacks
RemoteCallbacks :: ManagedPtr RemoteCallbacks -> RemoteCallbacks

-- | Type class for types which can be safely cast to
--   <a>RemoteCallbacks</a>, for instance with <a>toRemoteCallbacks</a>.
class (GObject o, IsDescendantOf RemoteCallbacks o) => IsRemoteCallbacks o

-- | Cast to <a>RemoteCallbacks</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRemoteCallbacks :: (MonadIO m, IsRemoteCallbacks o) => o -> m RemoteCallbacks

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksCompletionCallback = Ptr () -> CUInt -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type RemoteCallbacksCompletionCallback = RemoteCompletionType -> IO ()

-- | Connect a signal handler for the <a>completion</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> remoteCallbacks #completion callback
--   </pre>
afterRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RemoteCallbacksCompletion :: MonadIO m => RemoteCallbacksCompletionCallback -> m (GClosure C_RemoteCallbacksCompletionCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RemoteCallbacksCompletionCallback</a>.
mk_RemoteCallbacksCompletionCallback :: C_RemoteCallbacksCompletionCallback -> IO (FunPtr C_RemoteCallbacksCompletionCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteCallbacksCompletionCallback</a></tt>.
noRemoteCallbacksCompletionCallback :: Maybe RemoteCallbacksCompletionCallback

-- | Connect a signal handler for the <a>completion</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> remoteCallbacks #completion callback
--   </pre>
onRemoteCallbacksCompletion :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksCompletionCallback -> m SignalHandlerId

-- | Wrap a <a>RemoteCallbacksCompletionCallback</a> into a
--   <a>C_RemoteCallbacksCompletionCallback</a>.
wrap_RemoteCallbacksCompletionCallback :: RemoteCallbacksCompletionCallback -> C_RemoteCallbacksCompletionCallback

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

-- | <i>No description available in the introspection data.</i>
type RemoteCallbacksProgressCallback = Text -> IO ()

-- | Connect a signal handler for the <a>progress</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> remoteCallbacks #progress callback
--   </pre>
afterRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RemoteCallbacksProgress :: MonadIO m => RemoteCallbacksProgressCallback -> m (GClosure C_RemoteCallbacksProgressCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RemoteCallbacksProgressCallback</a>.
mk_RemoteCallbacksProgressCallback :: C_RemoteCallbacksProgressCallback -> IO (FunPtr C_RemoteCallbacksProgressCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteCallbacksProgressCallback</a></tt>.
noRemoteCallbacksProgressCallback :: Maybe RemoteCallbacksProgressCallback

-- | Connect a signal handler for the <a>progress</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> remoteCallbacks #progress callback
--   </pre>
onRemoteCallbacksProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksProgressCallback -> m SignalHandlerId

-- | Wrap a <a>RemoteCallbacksProgressCallback</a> into a
--   <a>C_RemoteCallbacksProgressCallback</a>.
wrap_RemoteCallbacksProgressCallback :: RemoteCallbacksProgressCallback -> C_RemoteCallbacksProgressCallback

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksTransferProgressCallback = Ptr () -> Ptr TransferProgress -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type RemoteCallbacksTransferProgressCallback = TransferProgress -> IO ()

-- | Connect a signal handler for the <a>transferProgress</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> remoteCallbacks #transferProgress callback
--   </pre>
afterRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RemoteCallbacksTransferProgress :: MonadIO m => RemoteCallbacksTransferProgressCallback -> m (GClosure C_RemoteCallbacksTransferProgressCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RemoteCallbacksTransferProgressCallback</a>.
mk_RemoteCallbacksTransferProgressCallback :: C_RemoteCallbacksTransferProgressCallback -> IO (FunPtr C_RemoteCallbacksTransferProgressCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteCallbacksTransferProgressCallback</a></tt>.
noRemoteCallbacksTransferProgressCallback :: Maybe RemoteCallbacksTransferProgressCallback

-- | Connect a signal handler for the <a>transferProgress</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> remoteCallbacks #transferProgress callback
--   </pre>
onRemoteCallbacksTransferProgress :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksTransferProgressCallback -> m SignalHandlerId

-- | Wrap a <a>RemoteCallbacksTransferProgressCallback</a> into a
--   <a>C_RemoteCallbacksTransferProgressCallback</a>.
wrap_RemoteCallbacksTransferProgressCallback :: RemoteCallbacksTransferProgressCallback -> C_RemoteCallbacksTransferProgressCallback

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteCallbacksUpdateTipsCallback = Ptr () -> CString -> Ptr OId -> Ptr OId -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type RemoteCallbacksUpdateTipsCallback = Text -> OId -> OId -> IO ()

-- | Connect a signal handler for the <a>updateTips</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> remoteCallbacks #updateTips callback
--   </pre>
afterRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RemoteCallbacksUpdateTips :: MonadIO m => RemoteCallbacksUpdateTipsCallback -> m (GClosure C_RemoteCallbacksUpdateTipsCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RemoteCallbacksUpdateTipsCallback</a>.
mk_RemoteCallbacksUpdateTipsCallback :: C_RemoteCallbacksUpdateTipsCallback -> IO (FunPtr C_RemoteCallbacksUpdateTipsCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteCallbacksUpdateTipsCallback</a></tt>.
noRemoteCallbacksUpdateTipsCallback :: Maybe RemoteCallbacksUpdateTipsCallback

-- | Connect a signal handler for the <a>updateTips</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> remoteCallbacks #updateTips callback
--   </pre>
onRemoteCallbacksUpdateTips :: (IsRemoteCallbacks a, MonadIO m) => a -> RemoteCallbacksUpdateTipsCallback -> m SignalHandlerId

-- | Wrap a <a>RemoteCallbacksUpdateTipsCallback</a> into a
--   <a>C_RemoteCallbacksUpdateTipsCallback</a>.
wrap_RemoteCallbacksUpdateTipsCallback :: RemoteCallbacksUpdateTipsCallback -> C_RemoteCallbacksUpdateTipsCallback
instance GHC.Classes.Eq GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks o) => GI.Ggit.Objects.RemoteCallbacks.IsRemoteCallbacks o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks


-- | Represents transfering progress.
module GI.Ggit.Structs.TransferProgress

-- | Memory-managed wrapper type.
newtype TransferProgress
TransferProgress :: ManagedPtr TransferProgress -> TransferProgress

-- | Copies <i><tt>progress</tt></i> into a newly allocated
--   <a>TransferProgress</a>.
transferProgressCopy :: (HasCallStack, MonadIO m) => TransferProgress -> m (Maybe TransferProgress)

-- | Frees <i><tt>progress</tt></i>.
transferProgressFree :: (HasCallStack, MonadIO m) => TransferProgress -> m ()

-- | Gets the indexed objects of the transfer.
transferProgressGetIndexedObjects :: (HasCallStack, MonadIO m) => TransferProgress -> m Word32

-- | Gets the received bytes of the transfer.
transferProgressGetReceivedBytes :: (HasCallStack, MonadIO m) => TransferProgress -> m Word32

-- | Gets the received objects of the transfer.
transferProgressGetReceivedObjects :: (HasCallStack, MonadIO m) => TransferProgress -> m Word32

-- | Gets the total objects of the transfer.
transferProgressGetTotalObjects :: (HasCallStack, MonadIO m) => TransferProgress -> m Word32
instance GHC.Classes.Eq GI.Ggit.Structs.TransferProgress.TransferProgress
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.TransferProgress.TransferProgress
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.TransferProgress.TransferProgress
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.TransferProgress.TransferProgress
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.TransferProgress.TransferProgress
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.TransferProgress.TransferProgress


-- | Represents a tree object.
module GI.Ggit.Objects.TreeBuilder

-- | Memory-managed wrapper type.
newtype TreeBuilder
TreeBuilder :: ManagedPtr TreeBuilder -> TreeBuilder

-- | Type class for types which can be safely cast to <a>TreeBuilder</a>,
--   for instance with <a>toTreeBuilder</a>.
class (GObject o, IsDescendantOf TreeBuilder o) => IsTreeBuilder o

-- | Cast to <a>TreeBuilder</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTreeBuilder :: (MonadIO m, IsTreeBuilder o) => o -> m TreeBuilder

-- | Clear all entries in the tree builder.
treeBuilderClear :: (HasCallStack, MonadIO m, IsTreeBuilder a) => a -> m ()

-- | Get an entry by path.
treeBuilderGetEntry :: (HasCallStack, MonadIO m, IsTreeBuilder a) => a -> Text -> m (Maybe TreeEntry)

-- | Insert a file with a given blob in the tree builder. If the tree
--   builder already contains an entry for the given file, then this entry
--   will be overwritten.
--   
--   Note that the returned <a>TreeEntry</a> is bound to the lifetime of
--   the tree builder and cannot be used after the tree builder has been
--   freed.
treeBuilderInsert :: (HasCallStack, MonadIO m, IsTreeBuilder a) => a -> Text -> OId -> FileMode -> m (Maybe TreeEntry)

-- | Remove an entry from the builder by path.
treeBuilderRemove :: (HasCallStack, MonadIO m, IsTreeBuilder a) => a -> Text -> m ()

-- | Write the contents of the tree builder as a tree object.
treeBuilderWrite :: (HasCallStack, MonadIO m, IsTreeBuilder a) => a -> m (Maybe OId)
instance GHC.Classes.Eq GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.TreeBuilder.TreeBuilder o) => GI.Ggit.Objects.TreeBuilder.IsTreeBuilder o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.TreeBuilder.TreeBuilder


module GI.Ggit.Callbacks

-- | Type for the callback on the (unwrapped) C side.
type C_ConfigCallback = Ptr ConfigEntry -> Ptr () -> IO Int32

-- | The type of the callback functions for retrieving values from a
--   <a>Config</a>. See <a>configForeach</a>.
type ConfigCallback = ConfigEntry " /@entry@/: a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry'." -> IO Int32 " __Returns:__ 0 to go for the next config value or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for retrieving values from a
--   <a>Config</a>. See <a>configForeach</a>.
type ConfigCallback_WithClosures = ConfigEntry " /@entry@/: a t'GI.Ggit.Structs.ConfigEntry.ConfigEntry'." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go for the next config value or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ConfigCallback :: ConfigCallback -> ConfigCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ConfigCallback :: (HasCallStack, MonadIO m) => FunPtr C_ConfigCallback -> ConfigEntry -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ConfigCallback :: MonadIO m => ConfigCallback -> m (GClosure C_ConfigCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ConfigCallback</a>.
mk_ConfigCallback :: C_ConfigCallback -> IO (FunPtr C_ConfigCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ConfigCallback</a></tt>.
noConfigCallback :: Maybe ConfigCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ConfigCallback_WithClosures</a></tt>.
noConfigCallback_WithClosures :: Maybe ConfigCallback_WithClosures

-- | Wrap a <a>ConfigCallback</a> into a <a>C_ConfigCallback</a>.
wrap_ConfigCallback :: Maybe (Ptr (FunPtr C_ConfigCallback)) -> ConfigCallback_WithClosures -> C_ConfigCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ConfigMatchCallback = Ptr MatchInfo -> CString -> Ptr () -> IO Int32

-- | The type of the callback functions for retrieving values from a
--   <a>Config</a> using a regular expression. See
--   <a>configMatchForeach</a>.
type ConfigMatchCallback = MatchInfo " /@matchInfo@/: the match" -> Text " /@value@/: the value" -> IO Int32 " __Returns:__ 0 to go for the next config value or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for retrieving values from a
--   <a>Config</a> using a regular expression. See
--   <a>configMatchForeach</a>.
type ConfigMatchCallback_WithClosures = MatchInfo " /@matchInfo@/: the match" -> Text " /@value@/: the value" -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go for the next config value or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ConfigMatchCallback :: ConfigMatchCallback -> ConfigMatchCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ConfigMatchCallback :: (HasCallStack, MonadIO m) => FunPtr C_ConfigMatchCallback -> MatchInfo -> Text -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ConfigMatchCallback :: MonadIO m => ConfigMatchCallback -> m (GClosure C_ConfigMatchCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ConfigMatchCallback</a>.
mk_ConfigMatchCallback :: C_ConfigMatchCallback -> IO (FunPtr C_ConfigMatchCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ConfigMatchCallback</a></tt>.
noConfigMatchCallback :: Maybe ConfigMatchCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ConfigMatchCallback_WithClosures</a></tt>.
noConfigMatchCallback_WithClosures :: Maybe ConfigMatchCallback_WithClosures

-- | Wrap a <a>ConfigMatchCallback</a> into a <a>C_ConfigMatchCallback</a>.
wrap_ConfigMatchCallback :: Maybe (Ptr (FunPtr C_ConfigMatchCallback)) -> ConfigMatchCallback_WithClosures -> C_ConfigMatchCallback

-- | Type for the callback on the (unwrapped) C side.
type C_CredAcquireCallback = CString -> CString -> Word32 -> Ptr Cred -> Ptr () -> IO Int32

-- | Signature of a function which acquires a credential object.
type CredAcquireCallback = Text " /@url@/: the resource for which we are demanding a credential." -> Maybe Text " /@usernameFromUrl@/: The username that was embedded in a \"user/@host@/\" remote url, or NULL if not included." -> Word32 " /@allowedTypes@/: a bitmask stating which cred types are OK to return." -> Cred " /@cred@/: newly created credential object." -> IO Int32

-- | Signature of a function which acquires a credential object.
type CredAcquireCallback_WithClosures = Text " /@url@/: the resource for which we are demanding a credential." -> Maybe Text " /@usernameFromUrl@/: The username that was embedded in a \"user/@host@/\" remote url, or NULL if not included." -> Word32 " /@allowedTypes@/: a bitmask stating which cred types are OK to return." -> Cred " /@cred@/: newly created credential object." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_CredAcquireCallback :: CredAcquireCallback -> CredAcquireCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_CredAcquireCallback :: (HasCallStack, MonadIO m, IsCred a) => FunPtr C_CredAcquireCallback -> Text -> Maybe Text -> Word32 -> a -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_CredAcquireCallback :: MonadIO m => CredAcquireCallback -> m (GClosure C_CredAcquireCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_CredAcquireCallback</a>.
mk_CredAcquireCallback :: C_CredAcquireCallback -> IO (FunPtr C_CredAcquireCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CredAcquireCallback</a></tt>.
noCredAcquireCallback :: Maybe CredAcquireCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>CredAcquireCallback_WithClosures</a></tt>.
noCredAcquireCallback_WithClosures :: Maybe CredAcquireCallback_WithClosures

-- | Wrap a <a>CredAcquireCallback</a> into a <a>C_CredAcquireCallback</a>.
wrap_CredAcquireCallback :: Maybe (Ptr (FunPtr C_CredAcquireCallback)) -> CredAcquireCallback_WithClosures -> C_CredAcquireCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffBinaryCallback = Ptr DiffDelta -> Ptr DiffBinary -> Ptr () -> IO Int32

-- | Called for each file.
type DiffBinaryCallback = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> DiffBinary " /@binary@/: a t'GI.Ggit.Structs.DiffBinary.DiffBinary'." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | Called for each file.
type DiffBinaryCallback_WithClosures = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> DiffBinary " /@binary@/: a t'GI.Ggit.Structs.DiffBinary.DiffBinary'." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffBinaryCallback :: DiffBinaryCallback -> DiffBinaryCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffBinaryCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffBinaryCallback -> DiffDelta -> DiffBinary -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffBinaryCallback :: MonadIO m => DiffBinaryCallback -> m (GClosure C_DiffBinaryCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffBinaryCallback</a>.
mk_DiffBinaryCallback :: C_DiffBinaryCallback -> IO (FunPtr C_DiffBinaryCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffBinaryCallback</a></tt>.
noDiffBinaryCallback :: Maybe DiffBinaryCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffBinaryCallback_WithClosures</a></tt>.
noDiffBinaryCallback_WithClosures :: Maybe DiffBinaryCallback_WithClosures

-- | Wrap a <a>DiffBinaryCallback</a> into a <a>C_DiffBinaryCallback</a>.
wrap_DiffBinaryCallback :: Maybe (Ptr (FunPtr C_DiffBinaryCallback)) -> DiffBinaryCallback_WithClosures -> C_DiffBinaryCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffFileCallback = Ptr DiffDelta -> CFloat -> Ptr () -> IO Int32

-- | Called for each file.
type DiffFileCallback = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> Float " /@progress@/: the progress." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | Called for each file.
type DiffFileCallback_WithClosures = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> Float " /@progress@/: the progress." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffFileCallback :: DiffFileCallback -> DiffFileCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffFileCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffFileCallback -> DiffDelta -> Float -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffFileCallback :: MonadIO m => DiffFileCallback -> m (GClosure C_DiffFileCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffFileCallback</a>.
mk_DiffFileCallback :: C_DiffFileCallback -> IO (FunPtr C_DiffFileCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffFileCallback</a></tt>.
noDiffFileCallback :: Maybe DiffFileCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffFileCallback_WithClosures</a></tt>.
noDiffFileCallback_WithClosures :: Maybe DiffFileCallback_WithClosures

-- | Wrap a <a>DiffFileCallback</a> into a <a>C_DiffFileCallback</a>.
wrap_DiffFileCallback :: Maybe (Ptr (FunPtr C_DiffFileCallback)) -> DiffFileCallback_WithClosures -> C_DiffFileCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffHunkCallback = Ptr DiffDelta -> Ptr DiffHunk -> Ptr () -> IO Int32

-- | Called for each hunk.
type DiffHunkCallback = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> DiffHunk " /@hunk@/: a t'GI.Ggit.Structs.DiffHunk.DiffHunk'." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | Called for each hunk.
type DiffHunkCallback_WithClosures = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> DiffHunk " /@hunk@/: a t'GI.Ggit.Structs.DiffHunk.DiffHunk'." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffHunkCallback :: DiffHunkCallback -> DiffHunkCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffHunkCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffHunkCallback -> DiffDelta -> DiffHunk -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffHunkCallback :: MonadIO m => DiffHunkCallback -> m (GClosure C_DiffHunkCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffHunkCallback</a>.
mk_DiffHunkCallback :: C_DiffHunkCallback -> IO (FunPtr C_DiffHunkCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffHunkCallback</a></tt>.
noDiffHunkCallback :: Maybe DiffHunkCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffHunkCallback_WithClosures</a></tt>.
noDiffHunkCallback_WithClosures :: Maybe DiffHunkCallback_WithClosures

-- | Wrap a <a>DiffHunkCallback</a> into a <a>C_DiffHunkCallback</a>.
wrap_DiffHunkCallback :: Maybe (Ptr (FunPtr C_DiffHunkCallback)) -> DiffHunkCallback_WithClosures -> C_DiffHunkCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffLineCallback = Ptr DiffDelta -> Ptr DiffHunk -> Ptr DiffLine -> Ptr () -> IO Int32

-- | Called for each line.
type DiffLineCallback = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> Maybe DiffHunk " /@hunk@/: a t'GI.Ggit.Structs.DiffHunk.DiffHunk'." -> DiffLine " /@line@/: a t'GI.Ggit.Structs.DiffLine.DiffLine'." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | Called for each line.
type DiffLineCallback_WithClosures = DiffDelta " /@delta@/: a t'GI.Ggit.Structs.DiffDelta.DiffDelta'." -> Maybe DiffHunk " /@hunk@/: a t'GI.Ggit.Structs.DiffHunk.DiffHunk'." -> DiffLine " /@line@/: a t'GI.Ggit.Structs.DiffLine.DiffLine'." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffLineCallback :: DiffLineCallback -> DiffLineCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffLineCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffLineCallback -> DiffDelta -> Maybe DiffHunk -> DiffLine -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffLineCallback :: MonadIO m => DiffLineCallback -> m (GClosure C_DiffLineCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffLineCallback</a>.
mk_DiffLineCallback :: C_DiffLineCallback -> IO (FunPtr C_DiffLineCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffLineCallback</a></tt>.
noDiffLineCallback :: Maybe DiffLineCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffLineCallback_WithClosures</a></tt>.
noDiffLineCallback_WithClosures :: Maybe DiffLineCallback_WithClosures

-- | Wrap a <a>DiffLineCallback</a> into a <a>C_DiffLineCallback</a>.
wrap_DiffLineCallback :: Maybe (Ptr (FunPtr C_DiffLineCallback)) -> DiffLineCallback_WithClosures -> C_DiffLineCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffSimilarityMetricBufferSignatureCallback = Ptr DiffFile -> CString -> Word32 -> Ptr () -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricBufferSignatureCallback = DiffFile -> Text -> Word32 -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricBufferSignatureCallback_WithClosures = DiffFile -> Text -> Word32 -> Ptr () -> Ptr () -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffSimilarityMetricBufferSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricBufferSignatureCallback -> DiffFile -> Text -> Word32 -> Ptr () -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffSimilarityMetricBufferSignatureCallback :: MonadIO m => DiffSimilarityMetricBufferSignatureCallback -> m (GClosure C_DiffSimilarityMetricBufferSignatureCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffSimilarityMetricBufferSignatureCallback</a>.
mk_DiffSimilarityMetricBufferSignatureCallback :: C_DiffSimilarityMetricBufferSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricBufferSignatureCallback</a></tt>.
noDiffSimilarityMetricBufferSignatureCallback :: Maybe DiffSimilarityMetricBufferSignatureCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricBufferSignatureCallback_WithClosures</a></tt>.
noDiffSimilarityMetricBufferSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricBufferSignatureCallback_WithClosures

-- | Wrap a <a>DiffSimilarityMetricBufferSignatureCallback</a> into a
--   <a>C_DiffSimilarityMetricBufferSignatureCallback</a>.
wrap_DiffSimilarityMetricBufferSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricBufferSignatureCallback)) -> DiffSimilarityMetricBufferSignatureCallback_WithClosures -> C_DiffSimilarityMetricBufferSignatureCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffSimilarityMetricFileSignatureCallback = Ptr DiffFile -> CString -> Ptr () -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricFileSignatureCallback = DiffFile -> Text -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricFileSignatureCallback_WithClosures = DiffFile -> Text -> Ptr () -> Ptr () -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricFileSignatureCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffSimilarityMetricFileSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricFileSignatureCallback -> DiffFile -> Text -> Ptr () -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffSimilarityMetricFileSignatureCallback :: MonadIO m => DiffSimilarityMetricFileSignatureCallback -> m (GClosure C_DiffSimilarityMetricFileSignatureCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffSimilarityMetricFileSignatureCallback</a>.
mk_DiffSimilarityMetricFileSignatureCallback :: C_DiffSimilarityMetricFileSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFileSignatureCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricFileSignatureCallback</a></tt>.
noDiffSimilarityMetricFileSignatureCallback :: Maybe DiffSimilarityMetricFileSignatureCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricFileSignatureCallback_WithClosures</a></tt>.
noDiffSimilarityMetricFileSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFileSignatureCallback_WithClosures

-- | Wrap a <a>DiffSimilarityMetricFileSignatureCallback</a> into a
--   <a>C_DiffSimilarityMetricFileSignatureCallback</a>.
wrap_DiffSimilarityMetricFileSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFileSignatureCallback)) -> DiffSimilarityMetricFileSignatureCallback_WithClosures -> C_DiffSimilarityMetricFileSignatureCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffSimilarityMetricFreeSignatureCallback = Ptr () -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricFreeSignatureCallback = Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricFreeSignatureCallback_WithClosures = Ptr () -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffSimilarityMetricFreeSignatureCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricFreeSignatureCallback -> Ptr () -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffSimilarityMetricFreeSignatureCallback :: MonadIO m => DiffSimilarityMetricFreeSignatureCallback -> m (GClosure C_DiffSimilarityMetricFreeSignatureCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffSimilarityMetricFreeSignatureCallback</a>.
mk_DiffSimilarityMetricFreeSignatureCallback :: C_DiffSimilarityMetricFreeSignatureCallback -> IO (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricFreeSignatureCallback</a></tt>.
noDiffSimilarityMetricFreeSignatureCallback :: Maybe DiffSimilarityMetricFreeSignatureCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricFreeSignatureCallback_WithClosures</a></tt>.
noDiffSimilarityMetricFreeSignatureCallback_WithClosures :: Maybe DiffSimilarityMetricFreeSignatureCallback_WithClosures

-- | Wrap a <a>DiffSimilarityMetricFreeSignatureCallback</a> into a
--   <a>C_DiffSimilarityMetricFreeSignatureCallback</a>.
wrap_DiffSimilarityMetricFreeSignatureCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricFreeSignatureCallback)) -> DiffSimilarityMetricFreeSignatureCallback_WithClosures -> C_DiffSimilarityMetricFreeSignatureCallback

-- | Type for the callback on the (unwrapped) C side.
type C_DiffSimilarityMetricSimilarityCallback = Int32 -> Ptr () -> Ptr () -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricSimilarityCallback = Int32 -> Ptr () -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricSimilarityCallback_WithClosures = Int32 -> Ptr () -> Ptr () -> Ptr () -> IO Int32

-- | A simple wrapper that ignores the closure arguments.
drop_closures_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> DiffSimilarityMetricSimilarityCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_DiffSimilarityMetricSimilarityCallback :: (HasCallStack, MonadIO m) => FunPtr C_DiffSimilarityMetricSimilarityCallback -> Int32 -> Ptr () -> Ptr () -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_DiffSimilarityMetricSimilarityCallback :: MonadIO m => DiffSimilarityMetricSimilarityCallback -> m (GClosure C_DiffSimilarityMetricSimilarityCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_DiffSimilarityMetricSimilarityCallback</a>.
mk_DiffSimilarityMetricSimilarityCallback :: C_DiffSimilarityMetricSimilarityCallback -> IO (FunPtr C_DiffSimilarityMetricSimilarityCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricSimilarityCallback</a></tt>.
noDiffSimilarityMetricSimilarityCallback :: Maybe DiffSimilarityMetricSimilarityCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetricSimilarityCallback_WithClosures</a></tt>.
noDiffSimilarityMetricSimilarityCallback_WithClosures :: Maybe DiffSimilarityMetricSimilarityCallback_WithClosures

-- | Wrap a <a>DiffSimilarityMetricSimilarityCallback</a> into a
--   <a>C_DiffSimilarityMetricSimilarityCallback</a>.
wrap_DiffSimilarityMetricSimilarityCallback :: Maybe (Ptr (FunPtr C_DiffSimilarityMetricSimilarityCallback)) -> DiffSimilarityMetricSimilarityCallback_WithClosures -> C_DiffSimilarityMetricSimilarityCallback

-- | Type for the callback on the (unwrapped) C side.
type C_NoteCallback = Ptr OId -> Ptr OId -> Ptr () -> IO Int32

-- | When iterating over all the notes, callback that will be issued per
--   note. See <a>repositoryNoteForeach</a>.
type NoteCallback = OId " /@blobId@/: id of the blob containing the message." -> OId " /@annotatedObjectId@/: id of the git object being annotated." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | When iterating over all the notes, callback that will be issued per
--   note. See <a>repositoryNoteForeach</a>.
type NoteCallback_WithClosures = OId " /@blobId@/: id of the blob containing the message." -> OId " /@annotatedObjectId@/: id of the git object being annotated." -> Ptr () " /@userData@/: user-suplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_NoteCallback :: NoteCallback -> NoteCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_NoteCallback :: (HasCallStack, MonadIO m) => FunPtr C_NoteCallback -> OId -> OId -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_NoteCallback :: MonadIO m => NoteCallback -> m (GClosure C_NoteCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_NoteCallback</a>.
mk_NoteCallback :: C_NoteCallback -> IO (FunPtr C_NoteCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>NoteCallback</a></tt>.
noNoteCallback :: Maybe NoteCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>NoteCallback_WithClosures</a></tt>.
noNoteCallback_WithClosures :: Maybe NoteCallback_WithClosures

-- | Wrap a <a>NoteCallback</a> into a <a>C_NoteCallback</a>.
wrap_NoteCallback :: Maybe (Ptr (FunPtr C_NoteCallback)) -> NoteCallback_WithClosures -> C_NoteCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ReferencesCallback = Ptr Ref -> Ptr () -> IO Int32

-- | The type of the callback functions for retrieving the references in a
--   <a>Repository</a>. See <a>repositoryReferencesForeach</a>.
type ReferencesCallback = Ref " /@reference@/: the reference." -> IO Int32 " __Returns:__ 0 to go for the next references or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for retrieving the references in a
--   <a>Repository</a>. See <a>repositoryReferencesForeach</a>.
type ReferencesCallback_WithClosures = Ref " /@reference@/: the reference." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go for the next references or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ReferencesCallback :: ReferencesCallback -> ReferencesCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ReferencesCallback :: (HasCallStack, MonadIO m, IsRef a) => FunPtr C_ReferencesCallback -> a -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ReferencesCallback :: MonadIO m => ReferencesCallback -> m (GClosure C_ReferencesCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ReferencesCallback</a>.
mk_ReferencesCallback :: C_ReferencesCallback -> IO (FunPtr C_ReferencesCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ReferencesCallback</a></tt>.
noReferencesCallback :: Maybe ReferencesCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ReferencesCallback_WithClosures</a></tt>.
noReferencesCallback_WithClosures :: Maybe ReferencesCallback_WithClosures

-- | Wrap a <a>ReferencesCallback</a> into a <a>C_ReferencesCallback</a>.
wrap_ReferencesCallback :: Maybe (Ptr (FunPtr C_ReferencesCallback)) -> ReferencesCallback_WithClosures -> C_ReferencesCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ReferencesNameCallback = CString -> Ptr () -> IO Int32

-- | The type of the callback functions for retrieving the references in a
--   <a>Repository</a>. See <a>repositoryReferencesForeachName</a>.
type ReferencesNameCallback = Text " /@name@/: the name of the reference" -> IO Int32 " __Returns:__ 0 to go for the next references or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for retrieving the references in a
--   <a>Repository</a>. See <a>repositoryReferencesForeachName</a>.
type ReferencesNameCallback_WithClosures = Text " /@name@/: the name of the reference" -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go for the next references or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ReferencesNameCallback :: ReferencesNameCallback -> ReferencesNameCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ReferencesNameCallback :: (HasCallStack, MonadIO m) => FunPtr C_ReferencesNameCallback -> Text -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ReferencesNameCallback :: MonadIO m => ReferencesNameCallback -> m (GClosure C_ReferencesNameCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ReferencesNameCallback</a>.
mk_ReferencesNameCallback :: C_ReferencesNameCallback -> IO (FunPtr C_ReferencesNameCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ReferencesNameCallback</a></tt>.
noReferencesNameCallback :: Maybe ReferencesNameCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ReferencesNameCallback_WithClosures</a></tt>.
noReferencesNameCallback_WithClosures :: Maybe ReferencesNameCallback_WithClosures

-- | Wrap a <a>ReferencesNameCallback</a> into a
--   <a>C_ReferencesNameCallback</a>.
wrap_ReferencesNameCallback :: Maybe (Ptr (FunPtr C_ReferencesNameCallback)) -> ReferencesNameCallback_WithClosures -> C_ReferencesNameCallback

-- | Type for the callback on the (unwrapped) C side.
type C_RemoteListCallback = CString -> Ptr OId -> Ptr OId -> CInt -> Ptr () -> IO Int32

-- | The type of the callback functions for listing the references of a
--   <a>Remote</a>. See <a>remoteList</a>.
type RemoteListCallback = Text " /@name@/: the name of the reference." -> OId " /@oid@/: the reference\'s oid." -> OId " /@loid@/: the reference\'s loid." -> Bool " /@local@/: if available locally." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for listing the references of a
--   <a>Remote</a>. See <a>remoteList</a>.
type RemoteListCallback_WithClosures = Text " /@name@/: the name of the reference." -> OId " /@oid@/: the reference\'s oid." -> OId " /@loid@/: the reference\'s loid." -> Bool " /@local@/: if available locally." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RemoteListCallback :: RemoteListCallback -> RemoteListCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RemoteListCallback :: (HasCallStack, MonadIO m) => FunPtr C_RemoteListCallback -> Text -> OId -> OId -> Bool -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RemoteListCallback :: MonadIO m => RemoteListCallback -> m (GClosure C_RemoteListCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RemoteListCallback</a>.
mk_RemoteListCallback :: C_RemoteListCallback -> IO (FunPtr C_RemoteListCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteListCallback</a></tt>.
noRemoteListCallback :: Maybe RemoteListCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteListCallback_WithClosures</a></tt>.
noRemoteListCallback_WithClosures :: Maybe RemoteListCallback_WithClosures

-- | Wrap a <a>RemoteListCallback</a> into a <a>C_RemoteListCallback</a>.
wrap_RemoteListCallback :: Maybe (Ptr (FunPtr C_RemoteListCallback)) -> RemoteListCallback_WithClosures -> C_RemoteListCallback

-- | Type for the callback on the (unwrapped) C side.
type C_StashCallback = Word32 -> CString -> Ptr OId -> Ptr () -> IO Int32

-- | When iterating over all the stashed states, callback that will be
--   issued per entry. See <a>repositoryStashForeach</a>.
type StashCallback = Word32 " /@index@/: the position within the stash list. 0 points to the most recent stashed state." -> Text " /@message@/: the stash message." -> OId " /@stashOid@/: the commit oid of the stashed state." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | When iterating over all the stashed states, callback that will be
--   issued per entry. See <a>repositoryStashForeach</a>.
type StashCallback_WithClosures = Word32 " /@index@/: the position within the stash list. 0 points to the most recent stashed state." -> Text " /@message@/: the stash message." -> OId " /@stashOid@/: the commit oid of the stashed state." -> Ptr () " /@userData@/: user-suplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_StashCallback :: StashCallback -> StashCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_StashCallback :: (HasCallStack, MonadIO m) => FunPtr C_StashCallback -> Word32 -> Text -> OId -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_StashCallback :: MonadIO m => StashCallback -> m (GClosure C_StashCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_StashCallback</a>.
mk_StashCallback :: C_StashCallback -> IO (FunPtr C_StashCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>StashCallback</a></tt>.
noStashCallback :: Maybe StashCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>StashCallback_WithClosures</a></tt>.
noStashCallback_WithClosures :: Maybe StashCallback_WithClosures

-- | Wrap a <a>StashCallback</a> into a <a>C_StashCallback</a>.
wrap_StashCallback :: Maybe (Ptr (FunPtr C_StashCallback)) -> StashCallback_WithClosures -> C_StashCallback

-- | Type for the callback on the (unwrapped) C side.
type C_StatusCallback = CString -> CUInt -> Ptr () -> IO Int32

-- | The type of the callback functions for retrieving the status of the
--   files in a <a>Repository</a>. See <a>repositoryFileStatusForeach</a>.
type StatusCallback = Text " /@path@/: the file to retrieve status for, rooted at the repository working dir." -> [StatusFlags] " /@statusFlags@/: the status value." -> IO Int32 " __Returns:__ 0 to go for the next file or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for retrieving the status of the
--   files in a <a>Repository</a>. See <a>repositoryFileStatusForeach</a>.
type StatusCallback_WithClosures = Text " /@path@/: the file to retrieve status for, rooted at the repository working dir." -> [StatusFlags] " /@statusFlags@/: the status value." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go for the next file or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_StatusCallback :: StatusCallback -> StatusCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_StatusCallback :: (HasCallStack, MonadIO m) => FunPtr C_StatusCallback -> Text -> [StatusFlags] -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_StatusCallback :: MonadIO m => StatusCallback -> m (GClosure C_StatusCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_StatusCallback</a>.
mk_StatusCallback :: C_StatusCallback -> IO (FunPtr C_StatusCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>StatusCallback</a></tt>.
noStatusCallback :: Maybe StatusCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>StatusCallback_WithClosures</a></tt>.
noStatusCallback_WithClosures :: Maybe StatusCallback_WithClosures

-- | Wrap a <a>StatusCallback</a> into a <a>C_StatusCallback</a>.
wrap_StatusCallback :: Maybe (Ptr (FunPtr C_StatusCallback)) -> StatusCallback_WithClosures -> C_StatusCallback

-- | Type for the callback on the (unwrapped) C side.
type C_SubmoduleCallback = Ptr Submodule -> CString -> Ptr () -> IO Int32

-- | The type of the callback functions for retrieving the submodules in a
--   <a>Repository</a>. See <a>repositorySubmoduleForeach</a>.
type SubmoduleCallback = Submodule " /@submodule@/: a t'GI.Ggit.Structs.Submodule.Submodule'." -> Text " /@name@/: the name of the submodule." -> IO Int32 " __Returns:__ 0 to go for the next submodule or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for retrieving the submodules in a
--   <a>Repository</a>. See <a>repositorySubmoduleForeach</a>.
type SubmoduleCallback_WithClosures = Submodule " /@submodule@/: a t'GI.Ggit.Structs.Submodule.Submodule'." -> Text " /@name@/: the name of the submodule." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go for the next submodule or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SubmoduleCallback :: SubmoduleCallback -> SubmoduleCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_SubmoduleCallback :: (HasCallStack, MonadIO m) => FunPtr C_SubmoduleCallback -> Submodule -> Text -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_SubmoduleCallback :: MonadIO m => SubmoduleCallback -> m (GClosure C_SubmoduleCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_SubmoduleCallback</a>.
mk_SubmoduleCallback :: C_SubmoduleCallback -> IO (FunPtr C_SubmoduleCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>SubmoduleCallback</a></tt>.
noSubmoduleCallback :: Maybe SubmoduleCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>SubmoduleCallback_WithClosures</a></tt>.
noSubmoduleCallback_WithClosures :: Maybe SubmoduleCallback_WithClosures

-- | Wrap a <a>SubmoduleCallback</a> into a <a>C_SubmoduleCallback</a>.
wrap_SubmoduleCallback :: Maybe (Ptr (FunPtr C_SubmoduleCallback)) -> SubmoduleCallback_WithClosures -> C_SubmoduleCallback

-- | Type for the callback on the (unwrapped) C side.
type C_TagCallback = CString -> Ptr OId -> Ptr () -> IO Int32

-- | When iterating over all the tags, callback that will be issued per
--   entry. See <a>repositoryTagForeach</a>.
type TagCallback = Text " /@name@/: the tag name." -> OId " /@tagOid@/: the tag oid." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | When iterating over all the tags, callback that will be issued per
--   entry. See <a>repositoryTagForeach</a>.
type TagCallback_WithClosures = Text " /@name@/: the tag name." -> OId " /@tagOid@/: the tag oid." -> Ptr () " /@userData@/: user-suplied data." -> IO Int32 " __Returns:__ 0 to go continue or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TagCallback :: TagCallback -> TagCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TagCallback :: (HasCallStack, MonadIO m) => FunPtr C_TagCallback -> Text -> OId -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TagCallback :: MonadIO m => TagCallback -> m (GClosure C_TagCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TagCallback</a>.
mk_TagCallback :: C_TagCallback -> IO (FunPtr C_TagCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TagCallback</a></tt>.
noTagCallback :: Maybe TagCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TagCallback_WithClosures</a></tt>.
noTagCallback_WithClosures :: Maybe TagCallback_WithClosures

-- | Wrap a <a>TagCallback</a> into a <a>C_TagCallback</a>.
wrap_TagCallback :: Maybe (Ptr (FunPtr C_TagCallback)) -> TagCallback_WithClosures -> C_TagCallback

-- | Type for the callback on the (unwrapped) C side.
type C_TransferProgressCallback = Ptr TransferProgress -> Ptr () -> IO Int32

-- | Progress callbacks during indexing.
type TransferProgressCallback = TransferProgress " /@stats@/: a t'GI.Ggit.Structs.TransferProgress.TransferProgress'." -> IO Int32 " __Returns:__ a value less than zero to cancel the transfer."

-- | Progress callbacks during indexing.
type TransferProgressCallback_WithClosures = TransferProgress " /@stats@/: a t'GI.Ggit.Structs.TransferProgress.TransferProgress'." -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ a value less than zero to cancel the transfer."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TransferProgressCallback :: TransferProgressCallback -> TransferProgressCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TransferProgressCallback :: (HasCallStack, MonadIO m) => FunPtr C_TransferProgressCallback -> TransferProgress -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TransferProgressCallback :: MonadIO m => TransferProgressCallback -> m (GClosure C_TransferProgressCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TransferProgressCallback</a>.
mk_TransferProgressCallback :: C_TransferProgressCallback -> IO (FunPtr C_TransferProgressCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TransferProgressCallback</a></tt>.
noTransferProgressCallback :: Maybe TransferProgressCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TransferProgressCallback_WithClosures</a></tt>.
noTransferProgressCallback_WithClosures :: Maybe TransferProgressCallback_WithClosures

-- | Wrap a <a>TransferProgressCallback</a> into a
--   <a>C_TransferProgressCallback</a>.
wrap_TransferProgressCallback :: Maybe (Ptr (FunPtr C_TransferProgressCallback)) -> TransferProgressCallback_WithClosures -> C_TransferProgressCallback

-- | Type for the callback on the (unwrapped) C side.
type C_TreeWalkCallback = CString -> Ptr TreeEntry -> Ptr () -> IO Int32

-- | The type of the callback functions for walking a tree. See
--   <a>treeWalk</a>.
type TreeWalkCallback = Text " /@root@/: the current (relative) root of the entry" -> TreeEntry " /@entry@/: the tree entry" -> IO Int32 " __Returns:__ 0 to go for the next entry or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | The type of the callback functions for walking a tree. See
--   <a>treeWalk</a>.
type TreeWalkCallback_WithClosures = Text " /@root@/: the current (relative) root of the entry" -> TreeEntry " /@entry@/: the tree entry" -> Ptr () " /@userData@/: user-supplied data." -> IO Int32 " __Returns:__ 0 to go for the next entry or a t'GI.Ggit.Enums.Error' in case there was an error."

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TreeWalkCallback :: TreeWalkCallback -> TreeWalkCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TreeWalkCallback :: (HasCallStack, MonadIO m) => FunPtr C_TreeWalkCallback -> Text -> TreeEntry -> Ptr () -> m Int32

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TreeWalkCallback :: MonadIO m => TreeWalkCallback -> m (GClosure C_TreeWalkCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TreeWalkCallback</a>.
mk_TreeWalkCallback :: C_TreeWalkCallback -> IO (FunPtr C_TreeWalkCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeWalkCallback</a></tt>.
noTreeWalkCallback :: Maybe TreeWalkCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeWalkCallback_WithClosures</a></tt>.
noTreeWalkCallback_WithClosures :: Maybe TreeWalkCallback_WithClosures

-- | Wrap a <a>TreeWalkCallback</a> into a <a>C_TreeWalkCallback</a>.
wrap_TreeWalkCallback :: Maybe (Ptr (FunPtr C_TreeWalkCallback)) -> TreeWalkCallback_WithClosures -> C_TreeWalkCallback


-- | Represents a similarity metric.
module GI.Ggit.Structs.DiffSimilarityMetric

-- | Memory-managed wrapper type.
newtype DiffSimilarityMetric
DiffSimilarityMetric :: ManagedPtr DiffSimilarityMetric -> DiffSimilarityMetric

-- | Copies <i><tt>metric</tt></i> into a newly allocated
--   <a>DiffSimilarityMetric</a>.
diffSimilarityMetricCopy :: (HasCallStack, MonadIO m) => DiffSimilarityMetric -> m (Maybe DiffSimilarityMetric)

-- | Frees <i><tt>metric</tt></i>.
diffSimilarityMetricFree :: (HasCallStack, MonadIO m) => DiffSimilarityMetric -> m ()

-- | Creates a new <a>DiffSimilarityMetric</a>.
diffSimilarityMetricNew :: (HasCallStack, MonadIO m) => DiffSimilarityMetricFileSignatureCallback -> DiffSimilarityMetricBufferSignatureCallback -> DiffSimilarityMetricFreeSignatureCallback -> DiffSimilarityMetricSimilarityCallback -> m DiffSimilarityMetric
instance GHC.Classes.Eq GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.DiffSimilarityMetric.DiffSimilarityMetric


-- | Represents a tree object.
module GI.Ggit.Objects.Tree

-- | Memory-managed wrapper type.
newtype Tree
Tree :: ManagedPtr Tree -> Tree

-- | Type class for types which can be safely cast to <a>Tree</a>, for
--   instance with <a>toTree</a>.
class (GObject o, IsDescendantOf Tree o) => IsTree o

-- | Cast to <a>Tree</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toTree :: (MonadIO m, IsTree o) => o -> m Tree

-- | Get a tree entry by index.
treeGet :: (HasCallStack, MonadIO m, IsTree a) => a -> Word32 -> m (Maybe TreeEntry)

-- | Get a tree entry by name.
treeGetByName :: (HasCallStack, MonadIO m, IsTree a) => a -> Text -> m (Maybe TreeEntry)

-- | Retrieves a tree entry contained in a tree or in any of its subtrees,
--   given its relative path.
treeGetByPath :: (HasCallStack, MonadIO m, IsTree a) => a -> Text -> m (Maybe TreeEntry)

-- | Get the <a>OId</a> of the tree.
treeGetId :: (HasCallStack, MonadIO m, IsTree a) => a -> m (Maybe OId)

-- | Get the number of entries in the tree.
treeSize :: (HasCallStack, MonadIO m, IsTree a) => a -> m Word32

-- | Walk all the entries of a tree object recursively (resolving and
--   walking subtrees of the tree as needed). The <i><tt>error</tt></i>
--   will be set to the error returned by <i><tt>callback</tt></i> (if
--   any).
treeWalk :: (HasCallStack, MonadIO m, IsTree a) => a -> TreeWalkMode -> TreeWalkCallback -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.Tree.Tree
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Tree.Tree o) => GI.Ggit.Objects.Tree.IsTree o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Tree.Tree
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Tree.Tree
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Tree.Tree
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Tree.Tree
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Tree.Tree


-- | Represents an existing git repository including all of it's object
--   contents.
module GI.Ggit.Objects.Repository

-- | Memory-managed wrapper type.
newtype Repository
Repository :: ManagedPtr Repository -> Repository

-- | Type class for types which can be safely cast to <a>Repository</a>,
--   for instance with <a>toRepository</a>.
class (GObject o, IsDescendantOf Repository o) => IsRepository o

-- | Cast to <a>Repository</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRepository :: (MonadIO m, IsRepository o) => o -> m Repository

-- | Adds a fetch refspec to the <i><tt>remote</tt></i>'s configuration.
--   Adds <i><tt>refspec</tt></i> to the fetch list in the configuration.
--   No loaded remote instances will be affected.
repositoryAddRemoteFetch :: (HasCallStack, MonadIO m, IsRepository a, IsRemote b) => a -> b -> Text -> m ()

-- | Adds a push refspec to <i><tt>remote</tt></i>'s configuration. Adds
--   the given refspec to the push list in the configuration. No loaded
--   remote instances will be affected.
repositoryAddRemotePush :: (HasCallStack, MonadIO m, IsRepository a, IsRemote b) => a -> b -> Text -> m ()

-- | Get a blame for a single file.
repositoryBlameFile :: (HasCallStack, MonadIO m, IsRepository a, IsFile b) => a -> b -> Maybe BlameOptions -> m (Maybe Blame)

-- | Update files in the working tree to reflect the contents of current
--   HEAD. If <i><tt>options</tt></i> is <a>Nothing</a>, then the default
--   checkout options will be used.
--   
--   If the checkout was not successfull, then <i><tt>error</tt></i> will
--   be set.
repositoryCheckoutHead :: (HasCallStack, MonadIO m, IsRepository a, IsCheckoutOptions b) => a -> Maybe b -> m ()

-- | Update files in the working tree to reflect the contents of the index.
--   If <i><tt>index</tt></i> is <a>Nothing</a>, then the current index of
--   the repository will be used. If <i><tt>options</tt></i> is
--   <a>Nothing</a>, then the default checkout options will be used.
--   
--   If the checkout was not successfull, then <i><tt>error</tt></i> will
--   be set.
repositoryCheckoutIndex :: (HasCallStack, MonadIO m, IsRepository a, IsIndex b, IsCheckoutOptions c) => a -> Maybe b -> Maybe c -> m ()

-- | Update files in the working tree to reflect the contents of the
--   specified commit, tag or tree object. If <i><tt>tree</tt></i> is
--   <a>Nothing</a>, then the current HEAD of the repository will be used.
--   If <i><tt>options</tt></i> is <a>Nothing</a>, then the default
--   checkout options will be used.
--   
--   If the checkout was not successfull, then <i><tt>error</tt></i> will
--   be set.
repositoryCheckoutTree :: (HasCallStack, MonadIO m, IsRepository a, IsObject b, IsCheckoutOptions c) => a -> Maybe b -> Maybe c -> m ()

-- | Cherry pick the specified commit, making changes in the index and the
--   working directory.
repositoryCherryPick :: (HasCallStack, MonadIO m, IsRepository a, IsCommit b, IsCherryPickOptions c) => a -> b -> c -> m ()

-- | Cherry-picks the given <i><tt>commit</tt></i> against the provided
--   <i><tt>ourCommit</tt></i>, producing and index that reflects the
--   result of the cherry-pick.
repositoryCherryPickCommit :: (HasCallStack, MonadIO m, IsRepository a, IsCommit b, IsCommit c) => a -> b -> c -> Word32 -> Maybe MergeOptions -> m (Maybe Index)

-- | Clones a new git repository in the given folder.
repositoryClone :: (HasCallStack, MonadIO m, IsFile a, IsCloneOptions b) => Text -> a -> Maybe b -> m (Maybe Repository)

-- | Create a new blob and return a <a>OutputStream</a> to write contents
--   to the blob. This is an efficient way to create new blobs without
--   copying data. The blob id can be obtained from the blob output stream
--   using <tt><i>ggit_blob_output_stream_get_id</i></tt>, after you close
--   the stream.
repositoryCreateBlob :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe BlobOutputStream)

-- | Write an in-memory buffer to the object database as a blob.
repositoryCreateBlobFromBuffer :: (HasCallStack, MonadIO m, IsRepository a) => a -> ByteString -> m (Maybe OId)

-- | Write a file to the object database as a blob.
--   
--   Returns (transfer full) (nullable): the new <tt><i>GgitOid</i></tt> of
--   the written blob, or <a>Nothing</a> if writing the blob failed.
repositoryCreateBlobFromFile :: (HasCallStack, MonadIO m, IsRepository a, IsFile b) => a -> b -> m OId

-- | Write a path relative to the repository working directory to the
--   object database as a blob.
repositoryCreateBlobFromPath :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m (Maybe OId)

-- | Creates a new branch pointing at a target commit.
repositoryCreateBranch :: (HasCallStack, MonadIO m, IsRepository a, IsObject b) => a -> Text -> b -> [CreateFlags] -> m (Maybe Branch)

-- | Create a new commit. If <i><tt>updateRef</tt></i> is not
--   <a>Nothing</a>, the given reference will be updated to point to the
--   newly created commit. Use "HEAD" to update the HEAD of the current
--   branch and make it point to this commit.
--   
--   If <i><tt>messageEncoding</tt></i> is set to <a>Nothing</a>, "UTF-8"
--   encoding is assumed for the provided <i><tt>message</tt></i>. Note
--   that <i><tt>message</tt></i> will not be cleaned up automatically. You
--   can use <tt><i>ggit_message_prettify</i></tt> to do this yourself if
--   needed.
repositoryCreateCommit :: (HasCallStack, MonadIO m, IsRepository a, IsSignature b, IsSignature c, IsTree d) => a -> Maybe Text -> b -> c -> Maybe Text -> Text -> d -> [Commit] -> m (Maybe OId)

-- | Create a new commit. If <i><tt>updateRef</tt></i> is not
--   <a>Nothing</a>, the given reference will be updated to point to the
--   newly created commit. Use "HEAD" to update the HEAD of the current
--   branch and make it point to this commit.
--   
--   If <i><tt>messageEncoding</tt></i> is set to <a>Nothing</a>, "UTF-8"
--   encoding is assumed for the provided <i><tt>message</tt></i>. Note
--   that <i><tt>message</tt></i> will not be cleaned up automatically. You
--   can use <tt><i>ggit_message_prettify</i></tt> to do this yourself if
--   needed.
repositoryCreateCommitFromIds :: (HasCallStack, MonadIO m, IsRepository a, IsSignature b, IsSignature c) => a -> Maybe Text -> b -> c -> Maybe Text -> Text -> OId -> [OId] -> m (Maybe OId)

-- | Create a new index entry. When <i><tt>file</tt></i> is not
--   <a>Nothing</a>, the path of the returned entry
--   (<tt><i>ggit_index_entry_get_path</i></tt>) is set to the path of
--   <i><tt>file</tt></i> relative to the working directory of
--   <i><tt>repository</tt></i>. The file must reside in the working
--   directory of <i><tt>repository</tt></i>. The file related fields of
--   the returned entry are also queried from this file (if the file
--   exists).
--   
--   If <i><tt>id</tt></i> is not <a>Nothing</a>, then the id of the
--   returned entry is set to <i><tt>id</tt></i> (see
--   <tt><i>ggit_index_entry_get_id</i></tt>) which could point to a blob
--   (for a file) or a tree (for a directory).
repositoryCreateIndexEntryForFile :: (HasCallStack, MonadIO m, IsRepository a, IsFile b) => a -> Maybe b -> Maybe OId -> m (Maybe IndexEntry)

-- | Create a new index entry. When <i><tt>path</tt></i> is not
--   <a>Nothing</a>, the path of the returned entry
--   (<tt><i>ggit_index_entry_get_path</i></tt>) is set to
--   <i><tt>path</tt></i>. The specified path can be either absolute or
--   relative. In the case of an absolute path, the path must reside within
--   the working directory of <i><tt>repository</tt></i>. The file related
--   fields of the returned entry are also queried from this path (if the
--   file exists).
--   
--   If <i><tt>id</tt></i> is not <a>Nothing</a>, then the id of the
--   returned entry is set to <i><tt>id</tt></i> (see
--   <tt><i>ggit_index_entry_get_id</i></tt>) which could point to a blob
--   (for a file) or a tree (for a directory).
repositoryCreateIndexEntryForPath :: (HasCallStack, MonadIO m, IsRepository a) => a -> Maybe Text -> Maybe OId -> m (Maybe IndexEntry)

-- | Adds a note for an object.
repositoryCreateNote :: (HasCallStack, MonadIO m, IsRepository a, IsSignature b, IsSignature c) => a -> Maybe Text -> b -> c -> OId -> Text -> Bool -> m (Maybe OId)

-- | Creates a new object id reference.
--   
--   The reference will be created in the repository and written to the
--   disk. The returned value must be freed with <a>objectUnref</a>.
repositoryCreateReference :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> OId -> Text -> m (Maybe Ref)

-- | Adds a remote with the default fetch refspec to the repository's
--   configuration.
repositoryCreateRemote :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> Text -> m (Maybe Remote)

-- | Creates a new symbolic reference.
--   
--   The reference will be created in the repository and written to the
--   disk. The returned value must be freed with <a>objectUnref</a>.
repositoryCreateSymbolicReference :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> Text -> Text -> m (Maybe Ref)

-- | Create a new tag object.
repositoryCreateTag :: (HasCallStack, MonadIO m, IsRepository a, IsObject b, IsSignature c) => a -> Text -> b -> c -> Text -> [CreateFlags] -> m (Maybe OId)

-- | Creates a new annotated tag.
repositoryCreateTagAnnotation :: (HasCallStack, MonadIO m, IsRepository a, IsObject b, IsSignature c) => a -> Text -> b -> c -> Text -> m (Maybe OId)

-- | Create a new tag from a buffer describing the tag object. The buffer
--   must be correctly formatted.
repositoryCreateTagFromBuffer :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> [CreateFlags] -> m (Maybe OId)

-- | Creates a new lightweight tag.
repositoryCreateTagLightweight :: (HasCallStack, MonadIO m, IsRepository a, IsObject b) => a -> Text -> b -> [CreateFlags] -> m (Maybe OId)

-- | Create a new tree builder.
repositoryCreateTreeBuilder :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe TreeBuilder)

-- | Create a tree builder for initialized with <i><tt>tree</tt></i>. To
--   create an empty tree builder, use
--   <tt><i>ggit_repository_create_tree_builder</i></tt> instead.
repositoryCreateTreeBuilderFromTree :: (HasCallStack, MonadIO m, IsRepository a, IsTree b) => a -> b -> m (Maybe TreeBuilder)

-- | Delete an existing tag reference by name.
repositoryDeleteTag :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m ()

-- | Looks for a git repository.
--   
--   The lookup starts from <i><tt>path</tt></i> and walks up the parent
--   directories and stops when a repository is found.
repositoryDiscover :: (HasCallStack, MonadIO m, IsFile a) => a -> m (Maybe File)

-- | Looks for a git repository.
--   
--   The lookup starts from <i><tt>path</tt></i> and walks up the parent
--   directories and stops when a repository is found.
repositoryDiscoverFull :: (HasCallStack, MonadIO m, IsFile a) => a -> Bool -> Maybe [Text] -> m (Maybe File)

-- | Removes a single stashed state from the stash list.
repositoryDropStash :: (HasCallStack, MonadIO m, IsRepository a) => a -> Word32 -> m ()

-- | Get a branch enumerator to enumerate over all branches of the
--   specified <i><tt>listType</tt></i> in <i><tt>repository</tt></i>.
repositoryEnumerateBranches :: (HasCallStack, MonadIO m, IsRepository a) => a -> BranchType -> m (Maybe BranchEnumerator)

-- | Gets the file status for a single file.
repositoryFileStatus :: (HasCallStack, MonadIO m, IsRepository a, IsFile b) => a -> b -> m [StatusFlags]

-- | Gathers file statuses and run a callback for each one.
--   
--   To the callback is passed the path of the file, the status and the
--   data pointer passed to this function. If the callback returns
--   something other than 0, the iteration will stop and
--   <i><tt>error</tt></i> will be set.
--   
--   Set <i><tt>options</tt></i> to <a>Nothing</a> to get the default
--   status options.
repositoryFileStatusForeach :: (HasCallStack, MonadIO m, IsRepository a) => a -> Maybe StatusOptions -> StatusCallback -> m ()

-- | Count the number of unique commits between two commit objects.
--   
--   There is no need for branches containing the commits to have any
--   upstream relationship, but it helps to think of one as a branch and
--   the other as its upstream, the <i><tt>ahead</tt></i> and
--   <i><tt>behind</tt></i> values will be what git would report for the
--   branches.
repositoryGetAheadBehind :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> OId -> m (Word32, Word32)

-- | Get the attribute value of the specified attribute for the given file.
repositoryGetAttribute :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> Text -> [AttributeCheckFlags] -> m (Maybe Text)

-- | Get the config for a specific repository.
repositoryGetConfig :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe Config)

-- | Gets the default notes reference for <i><tt>repository</tt></i>. It
--   defaults to "refs/notes/commits".
repositoryGetDefaultNotesRef :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe Text)

-- | Check whether <i><tt>com</tt></i> mit is a descendant of
--   <i><tt>ancestor</tt></i>. Note that if this function returns
--   <a>False</a>, an error might have occurred. If so,
--   <i><tt>error</tt></i> will be set appropriately.
repositoryGetDescendantOf :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> OId -> m ()

-- | Get and resolves the current HEAD reference of the repository. Note
--   that the returned ref is already resolved (if HEAD is symbolic). If
--   you want to retrieve the symbolic ref called HEAD, then use
--   <tt><i>ggit_repository_lookup_reference</i></tt> instead.
repositoryGetHead :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe Ref)

-- | Get the index for a specific repository.
repositoryGetIndex :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe Index)

-- | Get the gitdir location of the repository.
repositoryGetLocation :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe File)

-- | Gets the status for a submodule. This looks at a submodule and tries
--   to determine the status. It will return a combination of the
--   <tt><i>GGIT_SUBMODULE_STATUS</i></tt> values. How deeply it examines
--   the working directory to do this will depend on
--   <i><tt>ignore</tt></i>.
repositoryGetSubmoduleStatus :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> SubmoduleIgnore -> m [SubmoduleStatus]

-- | Gets the working directory of the repository.
repositoryGetWorkdir :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe File)

-- | Creates a new git repository in the given folder.
repositoryInitRepository :: (HasCallStack, MonadIO m, IsFile a) => a -> Bool -> m (Maybe Repository)

-- | Checks if <i><tt>repository</tt></i> is bare.
repositoryIsBare :: (HasCallStack, MonadIO m, IsRepository a) => a -> m Bool

-- | Checks if <i><tt>repository</tt></i> is empty.
--   
--   An empty repository has just been initialized and contains no commits.
repositoryIsEmpty :: (HasCallStack, MonadIO m, IsRepository a) => a -> m ()

-- | Checks if <i><tt>repository</tt></i>'s HEAD is detached.
--   
--   A repository's HEAD is detached when it points directly to a commit
--   instead of a branch.
repositoryIsHeadDetached :: (HasCallStack, MonadIO m, IsRepository a) => a -> m ()

-- | Checks if <i><tt>repository</tt></i>'s HEAD is an orphan.
--   
--   An orphan branch is one named from HEAD but doesn't exist in the refs
--   namespace, because it doesn't have any commit to point to.
repositoryIsHeadUnborn :: (HasCallStack, MonadIO m, IsRepository a) => a -> m ()

-- | Fill a list with all the remotes in <i><tt>repository</tt></i>.
repositoryListRemotes :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe [Text])

-- | Fill a list with all the tags in the <i><tt>repository</tt></i>.
repositoryListTags :: (HasCallStack, MonadIO m, IsRepository a) => a -> m (Maybe [Text])

-- | Fill a list with all the tags in the <i><tt>repository</tt></i>
--   matching the provided pattern. The pattern can use standard fnmatch
--   syntax.
repositoryListTagsMatch :: (HasCallStack, MonadIO m, IsRepository a) => a -> Maybe Text -> m (Maybe [Text])

-- | Lookups a reference to one of the objects in the
--   <i><tt>repository</tt></i>.
--   
--   The generated reference must be freed with <a>objectUnref</a>.
--   
--   The <i><tt>gtype</tt></i> must match the type of the object in the
--   odb; the method will fail otherwise. The special value
--   <tt><i>G_TYPE_NONE</i></tt> may be passed to let the method guess the
--   object's type.
repositoryLookup :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> GType -> m (Maybe Object)

-- | Lookups a branch by its name in a repository.
repositoryLookupBlob :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> m (Maybe Blob)

-- | Lookups a branch by its name in a repository.
repositoryLookupBranch :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> BranchType -> m (Maybe Branch)

-- | Lookups a branch by its name in a repository.
repositoryLookupCommit :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> m (Maybe Commit)

-- | Lookups a reference by its name in <i><tt>repository</tt></i>. The
--   returned <a>Ref</a> must be freed with <a>objectUnref</a>.
repositoryLookupReference :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m (Maybe Ref)

-- | Lookups a reference by its short name in <i><tt>repository</tt></i>
--   applying the git precendence rules to the given shorthand to determine
--   which reference the user is referring to. The returned <a>Ref</a> must
--   be freed with <a>objectUnref</a>.
repositoryLookupReferenceDwim :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m (Maybe Ref)

-- | Gets the remote called <i><tt>name</tt></i>.
repositoryLookupRemote :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m (Maybe Remote)

-- | Lookups a submodule information by name or path. If the submodule does
--   not exist, <a>Nothing</a> is returned and a GGIT_ERROR_NOTFOUND error
--   set.
repositoryLookupSubmodule :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m (Maybe Submodule)

-- | Lookups a branch by its name in a repository.
repositoryLookupTag :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> m (Maybe Tag)

-- | Lookups a branch by its name in a repository.
repositoryLookupTree :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> m (Maybe Tree)

-- | Merges the given commit(s) into HEAD, writing the results into the
--   working directory. Any changes are staged for commit and any conflicts
--   are written to the index.
--   
--   Callers should inspect the repository's index after this completes,
--   resolve any conflicts and prepare a commit.
repositoryMerge :: (HasCallStack, MonadIO m, IsRepository a, IsCheckoutOptions b) => a -> [AnnotatedCommit] -> MergeOptions -> b -> m ()

-- | Find the merge base between two commits
repositoryMergeBase :: (HasCallStack, MonadIO m, IsRepository a) => a -> OId -> OId -> m (Maybe OId)

-- | Merge two commits creating a <a>Index</a> reflecting the result of the
--   merge.
repositoryMergeCommits :: (HasCallStack, MonadIO m, IsRepository a, IsCommit b, IsCommit c) => a -> b -> c -> MergeOptions -> m (Maybe Index)

-- | Merge two trees creating a <a>Index</a> reflecting the result of the
--   merge.
repositoryMergeTrees :: (HasCallStack, MonadIO m, IsRepository a, IsTree b, IsTree c, IsTree d) => a -> b -> c -> d -> MergeOptions -> m (Maybe Index)

-- | Loop over all the notes within a specified namespace and issue a
--   callback for each one. If <i><tt>callback</tt></i> returns a non-zero
--   value, this will stop looping.
repositoryNoteForeach :: (HasCallStack, MonadIO m, IsRepository a) => a -> Maybe Text -> NoteCallback -> m ()

-- | Open a git repository.
--   
--   The <i><tt>path</tt></i> must point to an existing git repository
--   folder, e.g.
--   
--   /path/to/my_repo/.git/ (normal repository) objects/ index HEAD
--   
--   /path/to/bare_repo/ (bare repository) objects/ index HEAD
--   
--   The method will automatically detect if <i><tt>path</tt></i> is a
--   normal or bare repository or fail if it is neither.
repositoryOpen :: (HasCallStack, MonadIO m, IsFile a) => a -> m (Maybe Repository)

-- | Tests if the ignore rules apply to the path provided.
--   
--   This acts similar to filtering performed when calling "git add ." on
--   the command line.
repositoryPathIsIgnored :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m ()

-- | Reads the note for an object.
repositoryReadNote :: (HasCallStack, MonadIO m, IsRepository a) => a -> Maybe Text -> OId -> m (Maybe Note)

-- | Initializes a rebase operation to rebase the changes in
--   <i><tt>branch</tt></i> relative to <i><tt>upstream</tt></i> onto
--   another branch. To begin the rebase process, call
--   <tt><i>git_rebase_next()</i></tt>. When you have finished with this
--   object, call <a>objectUnref</a>.
repositoryRebaseInit :: (HasCallStack, MonadIO m, IsRepository a) => a -> Maybe AnnotatedCommit -> Maybe AnnotatedCommit -> Maybe AnnotatedCommit -> RebaseOptions -> m (Maybe Rebase)

-- | Opens an existing rebase that was previously started by either an
--   invocation of <tt><i>ggit_rebase_init()</i></tt> or by another client.
repositoryRebaseOpen :: (HasCallStack, MonadIO m, IsRepository a) => a -> RebaseOptions -> m (Maybe Rebase)

-- | Gathers references and run a callback for each one.
--   
--   To the callback is passed the reference and the data pointer passed to
--   this function. If the callback returns something other than 0, the
--   iteration will stop and <i><tt>error</tt></i> will be set.
repositoryReferencesForeach :: (HasCallStack, MonadIO m, IsRepository a) => a -> ReferencesCallback -> m ()

-- | Gathers reference names and run a callback for each one.
--   
--   To the callback is passed the name of the reference and the data
--   pointer passed to this function. If the callback returns something
--   other than 0, the iteration will stop and <i><tt>error</tt></i> will
--   be set.
repositoryReferencesForeachName :: (HasCallStack, MonadIO m, IsRepository a) => a -> ReferencesNameCallback -> m ()

-- | Removes the note for an object.
repositoryRemoveNote :: (HasCallStack, MonadIO m, IsRepository a, IsSignature b, IsSignature c) => a -> Maybe Text -> b -> c -> OId -> m ()

-- | Removes <i><tt>remote</tt></i> from the <i><tt>repository</tt></i>.
repositoryRemoveRemote :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m ()

-- | Rename the remote of <i><tt>repository</tt></i> from
--   <i><tt>name</tt></i> to <i><tt>newName</tt></i>.
repositoryRenameRemote :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> Text -> m (Maybe [Text])

-- | Performs a reset of type <i><tt>resetType</tt></i> on
--   <i><tt>repository</tt></i> to <i><tt>target</tt></i>, or
--   <i><tt>error</tt></i> will be set.
repositoryReset :: (HasCallStack, MonadIO m, IsRepository a, IsObject b, IsCheckoutOptions c) => a -> b -> ResetType -> c -> m ()

-- | Update some entries in the index from the target commit tree. The
--   scope of the updated entries is determined by the paths specified in
--   <i><tt>pathspecs</tt></i>. Passing <a>Nothing</a> in
--   <i><tt>target</tt></i> will result in removing entries in the index
--   matching the provided pathspecs.
repositoryResetDefault :: (HasCallStack, MonadIO m, IsRepository a, IsObject b) => a -> Maybe b -> [Text] -> m ()

-- | Revert the given <i><tt>commit</tt></i> on top of the current working
--   directory.
repositoryRevert :: (HasCallStack, MonadIO m, IsRepository a, IsCommit b) => a -> b -> RevertOptions -> m ()

-- | Find an object, as specified by a revision string. See <tt>man
--   gitrevisions</tt>, or the documentation for <tt>git rev-parse</tt> for
--   information on the syntax accepted.
repositoryRevparse :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m (Maybe Object)

-- | Saves the local modifications to a new stash. It returns the commit
--   containing the stashed state. This commit is also the target of the
--   direct reference refs/stash.
repositorySaveStash :: (HasCallStack, MonadIO m, IsRepository a, IsSignature b) => a -> b -> Text -> [StashFlags] -> m (Maybe OId)

-- | <i>No description available in the introspection data.</i>
repositorySetHead :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> m ()

-- | Sets url for the <i><tt>remote</tt></i> from the
--   <i><tt>repository</tt></i>.
repositorySetRemoteUrl :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> Text -> m ()

-- | Sets the submodule.'name'.fetchRecurseSubmodules value for the
--   submodule. This setting won't affect any existing instances..
repositorySetSubmoduleFetchRecurse :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> SubmoduleRecurse -> m ()

-- | Sets the ignore rule for the submodule in the configuration. This does
--   not affect any currently-loaded instances..
repositorySetSubmoduleIgnore :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> SubmoduleIgnore -> m ()

-- | Sets the update rule for the submodule in the configuration. This
--   setting won't affect any existing instances.
repositorySetSubmoduleUpdate :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> SubmoduleUpdate -> m ()

-- | Sets the URL for the submodule in the configuration.
--   
--   After calling this, you may wish to call <a>submoduleSync</a> to write
--   the changes to the checked out submodule repository.
repositorySetSubmoduleUrl :: (HasCallStack, MonadIO m, IsRepository a) => a -> Text -> Text -> m ()

-- | Sets the working directory of the repository. If
--   <i><tt>updateGitlink</tt></i> is set to <a>True</a> "core.worktree"
--   will be set in the config if workdir is not the parent of the .git
--   directory).
repositorySetWorkdir :: (HasCallStack, MonadIO m, IsRepository a, IsFile b) => a -> b -> Bool -> m ()

-- | Loops over all the stashed states and issue a callback for each one.
--   If <i><tt>callback</tt></i> returns a non-zero value, this will stop
--   looping.
repositoryStashForeach :: (HasCallStack, MonadIO m, IsRepository a) => a -> StashCallback -> m ()

-- | Gathers submodules and run a callback for each one.
--   
--   To the callback is passed the submodule instance and name. If the
--   callback returns something other than 0, the iteration will stop and
--   <i><tt>error</tt></i> will be set.
--   
--   NOTE: the submodule instance passed to the callback is only valid
--   during the call to ggit_repository_submodule_foreach and may not be
--   used after the call has finished.
repositorySubmoduleForeach :: (HasCallStack, MonadIO m, IsRepository a) => a -> SubmoduleCallback -> m ()

-- | Get all the tags in the repository and run the provided callback on
--   each. If the callback returns something other than 0, the iteration
--   will stop and <i><tt>error</tt></i> will be set.
repositoryTagForeach :: (HasCallStack, MonadIO m, IsRepository a) => a -> TagCallback -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>clone-options</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRepositoryCloneOptions :: (IsRepository o, MonadIO m, IsCloneOptions a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>clone-options</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repository #cloneOptions
--   </pre>
getRepositoryCloneOptions :: (MonadIO m, IsRepository o) => o -> m (Maybe CloneOptions)

-- | Get the value of the “<tt>head</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repository #head
--   </pre>
getRepositoryHead :: (MonadIO m, IsRepository o) => o -> m (Maybe Ref)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>init</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRepositoryInit :: (IsRepository o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>init</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repository #init
--   </pre>
getRepositoryInit :: (MonadIO m, IsRepository o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>is-bare</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRepositoryIsBare :: (IsRepository o, MonadIO m) => Bool -> m (GValueConstruct o)

-- | Get the value of the “<tt>is-bare</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repository #isBare
--   </pre>
getRepositoryIsBare :: (MonadIO m, IsRepository o) => o -> m Bool

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>location</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructRepositoryLocation :: (IsRepository o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>location</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repository #location
--   </pre>
getRepositoryLocation :: (MonadIO m, IsRepository o) => o -> m (Maybe File)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>url</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRepositoryUrl :: (IsRepository o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>url</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repository #url
--   </pre>
getRepositoryUrl :: (MonadIO m, IsRepository o) => o -> m (Maybe Text)

-- | Set the value of the “<tt>workdir</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #workdir
--   </pre>
clearRepositoryWorkdir :: (MonadIO m, IsRepository o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>workdir</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRepositoryWorkdir :: (IsRepository o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>workdir</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repository #workdir
--   </pre>
getRepositoryWorkdir :: (MonadIO m, IsRepository o) => o -> m (Maybe File)

-- | Set the value of the “<tt>workdir</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repository [ #workdir <a>:=</a> value ]
--   </pre>
setRepositoryWorkdir :: (MonadIO m, IsRepository o, IsFile a) => o -> a -> m ()
instance GHC.Classes.Eq GI.Ggit.Objects.Repository.Repository
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Repository.Repository o) => GI.Ggit.Objects.Repository.IsRepository o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Repository.Repository
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Repository.Repository
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Repository.Repository
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Repository.Repository
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Repository.Repository


-- | Represents a diff list.
module GI.Ggit.Objects.Diff

-- | Memory-managed wrapper type.
newtype Diff
Diff :: ManagedPtr Diff -> Diff

-- | Type class for types which can be safely cast to <a>Diff</a>, for
--   instance with <a>toDiff</a>.
class (GObject o, IsDescendantOf Diff o) => IsDiff o

-- | Cast to <a>Diff</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toDiff :: (MonadIO m, IsDiff o) => o -> m Diff

-- | Transform <i><tt>diff</tt></i> marking file renames, copies, etc.. If
--   <i><tt>options</tt></i> is set to <a>Nothing</a>, then the default
--   options will be used.
diffFindSimilar :: (HasCallStack, MonadIO m, IsDiff a, IsDiffFindOptions b) => a -> Maybe b -> m ()

-- | Create an e-mail ready patch from a diff.
diffFormatEmail :: (HasCallStack, MonadIO m, IsDiff a, IsDiffFormatEmailOptions b) => a -> b -> m (Maybe Text)

-- | Get the delta at the specified index.
diffGetDelta :: (HasCallStack, MonadIO m, IsDiff a) => a -> Word32 -> m (Maybe DiffDelta)

-- | Get the number of deltas in the diff.
diffGetNumDeltas :: (HasCallStack, MonadIO m, IsDiff a) => a -> m Word32

-- | Merges <i><tt>from</tt></i> into <i><tt>onto</tt></i> unless
--   <i><tt>error</tt></i> is set.
diffMerge :: (HasCallStack, MonadIO m, IsDiff a, IsDiff b) => a -> b -> m ()

-- | Same as <a>diffBlobs</a> but using a buffers. Creates a <a>Diff</a>
--   which compares <i><tt>buffer1</tt></i> and <i><tt>buffer2</tt></i>.
--   
--   If <i><tt>diffOptions</tt></i> is <a>Nothing</a> then the defaults
--   specified in <a>diffOptionsNew</a> are used.
diffNewBuffers :: (HasCallStack, MonadIO m, IsDiffOptions a) => Maybe ByteString -> Maybe Text -> Maybe ByteString -> Maybe Text -> Maybe a -> m (Maybe Diff)

-- | Creates a <a>Diff</a> which compares the working directory and the
--   index.
--   
--   If <i><tt>index</tt></i> is <a>Nothing</a> then
--   <i><tt>repository</tt></i> index is used. If
--   <i><tt>diffOptions</tt></i> is <a>Nothing</a> then the defaults
--   specified in <a>diffOptionsNew</a> are used.
diffNewIndexToWorkdir :: (HasCallStack, MonadIO m, IsRepository a, IsIndex b, IsDiffOptions c) => a -> Maybe b -> Maybe c -> m (Maybe Diff)

-- | Creates a <a>Diff</a> which compares <i><tt>oldTree</tt></i> and the
--   index.
--   
--   If <i><tt>index</tt></i> is <a>Nothing</a> then
--   <i><tt>repository</tt></i> index is used. If
--   <i><tt>diffOptions</tt></i> is <a>Nothing</a> then the defaults
--   specified in <a>diffOptionsNew</a> are used.
diffNewTreeToIndex :: (HasCallStack, MonadIO m, IsRepository a, IsTree b, IsIndex c, IsDiffOptions d) => a -> Maybe b -> Maybe c -> Maybe d -> m (Maybe Diff)

-- | Creates a <a>Diff</a> which compares <i><tt>oldTree</tt></i> and
--   <i><tt>newTree</tt></i>.
--   
--   If <i><tt>diffOptions</tt></i> is <a>Nothing</a> then the defaults
--   specified in <a>diffOptionsNew</a> are used.
diffNewTreeToTree :: (HasCallStack, MonadIO m, IsRepository a, IsTree b, IsTree c, IsDiffOptions d) => a -> Maybe b -> Maybe c -> Maybe d -> m (Maybe Diff)

-- | Creates a <a>Diff</a> which compares the working directory and
--   <i><tt>oldTree</tt></i>.
--   
--   If <i><tt>diffOptions</tt></i> is <a>Nothing</a> then the defaults
--   specified in <a>diffOptionsNew</a> are used.
diffNewTreeToWorkdir :: (HasCallStack, MonadIO m, IsRepository a, IsTree b, IsDiffOptions c) => a -> Maybe b -> Maybe c -> m (Maybe Diff)

-- | Iterates over <i><tt>diff</tt></i> generating text output like "git
--   diff".
diffPrint :: (HasCallStack, MonadIO m, IsDiff a) => a -> DiffFormatType -> DiffLineCallback -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>repository</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructDiffRepository :: (IsDiff o, MonadIO m, IsRepository a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>repository</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diff #repository
--   </pre>
getDiffRepository :: (MonadIO m, IsDiff o) => o -> m (Maybe Repository)
instance GHC.Classes.Eq GI.Ggit.Objects.Diff.Diff
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Diff.Diff o) => GI.Ggit.Objects.Diff.IsDiff o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Diff.Diff
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Diff.Diff
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Diff.Diff
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Diff.Diff
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Diff.Diff


-- | Represents a git configuration.
module GI.Ggit.Objects.Config

-- | Memory-managed wrapper type.
newtype Config
Config :: ManagedPtr Config -> Config

-- | Type class for types which can be safely cast to <a>Config</a>, for
--   instance with <a>toConfig</a>.
class (GObject o, IsDescendantOf Config o) => IsConfig o

-- | Cast to <a>Config</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toConfig :: (MonadIO m, IsConfig o) => o -> m Config

-- | Add an on-disk config file instance to an existing config
--   
--   The on-disk file pointed at by <i><tt>file</tt></i> will be opened and
--   parsed; it's expected to be a native Git config file following the
--   default Git config syntax (see man git-config).
--   
--   Further queries on this config object will access each of the config
--   file instances in order (instances with a higher priority level will
--   be accessed first).
configAddFile :: (HasCallStack, MonadIO m, IsConfig a, IsFile b) => a -> b -> ConfigLevel -> Bool -> m ()

-- | Delete a config variable from the config file.
configDeleteEntry :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> m ()

-- | Find the file representing the users global git configuration. This
--   file is usually located at $HOME/.gitconfig. This function will try to
--   guess the full path to that file, if the file exists. The returned
--   file may then be used with <tt><i>ggit_config_new_from_file</i></tt>
--   or <tt><i>ggit_config_add_file</i></tt>. This function returns
--   <a>Nothing</a> if the global config could not be found.
configFindGlobal :: (HasCallStack, MonadIO m) => m File

-- | Find the file representing the systems global git configuration. This
--   file is usually located at /etc/gitconfig on UNIX type systems or
--   <tt><i>PROGRAMFILES</i></tt>%\Git\etc\gitconfig on windows. This
--   function will try to guess the full path to that file, if the file
--   exists. The returned file may then be used with
--   <tt><i>ggit_config_new_from_file</i></tt> or
--   <tt><i>ggit_config_add_file</i></tt>. This function returns
--   <a>Nothing</a> if the system config could not be found.
configFindSystem :: (HasCallStack, MonadIO m) => m File

-- | Call <i><tt>callback</tt></i> for each configuration value.
configForeach :: (HasCallStack, MonadIO m, IsConfig a) => a -> ConfigCallback -> m ()

-- | Get a boolean configuration value.
configGetBool :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> m ()

-- | Get <a>ConfigEntry</a> of a config variable.
configGetEntry :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> m ConfigEntry

-- | Get a int32 configuration value.
configGetInt32 :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> m Int32

-- | Get a int64 configuration value.
configGetInt64 :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> m Int64

-- | Get the configuration value of <i><tt>name</tt></i> as string.
configGetString :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> m (Maybe Text)

-- | Matches a configuration against a regular expression.
--   <i><tt>matchInfo</tt></i> will contain the match information if the
--   return value is not <a>Nothing</a>, otherwise <i><tt>error</tt></i>
--   will be set.
configMatch :: (HasCallStack, MonadIO m, IsConfig a) => a -> Regex -> m (Maybe Text, MatchInfo)

-- | Call <i><tt>callback</tt></i> for all configurations matching
--   <i><tt>regex</tt></i>.
configMatchForeach :: (HasCallStack, MonadIO m, IsConfig a) => a -> Regex -> ConfigMatchCallback -> m ()

-- | Create a new config. See also
--   <tt><i>ggit_config_get_default()</i></tt> to get a <a>Config</a>
--   representing the global, XDG and system configuration files. To get a
--   <a>Config</a> for a repository use
--   <tt><i>ggit_repository_get_config</i></tt> instead.
configNew :: (HasCallStack, MonadIO m) => m Config

-- | Get the global, XDG and system configuration files merged into one
--   <a>Config</a> with their appropriate priority levels. If an error
--   occured trying to load the various configuration files, this function
--   will return <a>Nothing</a> and <i><tt>error</tt></i> will be set
--   accordingly.
configNewDefault :: (HasCallStack, MonadIO m) => m Config

-- | Create a new config from a single on disk file. This is a convenience
--   API and is exactly the same as creating an empty <a>Config</a> using
--   <tt><i>ggit_config_new</i></tt> and adding the file with
--   <tt><i>ggit_config_add_file</i></tt>. The level will be set to
--   <tt><i>GGIT_CONFIG_LEVEL_LOCAL</i></tt>. If the config could not be
--   loaded this function returns <a>Nothing</a> and <i><tt>error</tt></i>
--   will be set accordingly.
configNewFromFile :: (HasCallStack, MonadIO m, IsFile a) => a -> m Config

-- | Open a specific level config derived from a multi-level one.
configOpenLevel :: (HasCallStack, MonadIO m, IsConfig a) => a -> ConfigLevel -> m Config

-- | Set a boolean value.
configSetBool :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> Bool -> m ()

-- | Set a int32 value.
configSetInt32 :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> Int32 -> m ()

-- | Set a int64 value.
configSetInt64 :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> Int64 -> m ()

-- | Set a new string value of a configuration.
configSetString :: (HasCallStack, MonadIO m, IsConfig a) => a -> Text -> Text -> m ()

-- | Create a snapshot of the current state of the configuration, which
--   allows you to look into a consistent view of the configuration for
--   looking up complex values (e.g. a remote, submodule).
configSnapshot :: (HasCallStack, MonadIO m, IsConfig a) => a -> m Config
instance GHC.Classes.Eq GI.Ggit.Objects.Config.Config
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Ggit.Objects.Config.Config o) => GI.Ggit.Objects.Config.IsConfig o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Objects.Config.Config
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Objects.Config.Config
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Config.Config
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Objects.Config.Config
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Objects.Config.Config


module GI.Ggit.Objects


-- | Represents an entry in a tree.
module GI.Ggit.Structs.TreeEntry

-- | Memory-managed wrapper type.
newtype TreeEntry
TreeEntry :: ManagedPtr TreeEntry -> TreeEntry

-- | Gets the <a>FileMode</a> of a tree entry.
treeEntryGetFileMode :: (HasCallStack, MonadIO m) => TreeEntry -> m FileMode

-- | Get the <a>OId</a> of the entry.
treeEntryGetId :: (HasCallStack, MonadIO m) => TreeEntry -> m (Maybe OId)

-- | Get the name of the tree entry.
treeEntryGetName :: (HasCallStack, MonadIO m) => TreeEntry -> m (Maybe Text)

-- | Get the type of the tree entry object.
treeEntryGetObjectType :: (HasCallStack, MonadIO m) => TreeEntry -> m GType

-- | Atomically increments the reference count of <i><tt>entry</tt></i> by
--   one. This function is MT-safe and may be called from any thread.
treeEntryRef :: (HasCallStack, MonadIO m) => TreeEntry -> m (Maybe TreeEntry)

-- | Atomically decrements the reference count of <i><tt>entry</tt></i> by
--   one. If the reference count drops to 0, <i><tt>entry</tt></i> is
--   freed.
treeEntryUnref :: (HasCallStack, MonadIO m) => TreeEntry -> m ()
instance GHC.Classes.Eq GI.Ggit.Structs.TreeEntry.TreeEntry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Ggit.Structs.TreeEntry.TreeEntry
instance Data.GI.Base.Overloading.HasParentTypes GI.Ggit.Structs.TreeEntry.TreeEntry
instance Data.GI.Base.BasicTypes.TypedObject GI.Ggit.Structs.TreeEntry.TreeEntry
instance Data.GI.Base.BasicTypes.GBoxed GI.Ggit.Structs.TreeEntry.TreeEntry
instance Data.GI.Base.GValue.IsGValue GI.Ggit.Structs.TreeEntry.TreeEntry


module GI.Ggit.Structs


module GI.Ggit
