-- 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.2


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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffOptions</a>.
noDiffOptions :: Maybe 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) => [DiffOption] -> IO (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) => Int32 -> IO (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) => Int32 -> IO (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) => Text -> IO (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) => Text -> IO (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) => [Text] -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.DiffOptions.DiffOptions a) => GI.Ggit.Objects.DiffOptions.IsDiffOptions a
instance GI.Ggit.Objects.DiffOptions.IsDiffOptions GI.Ggit.Objects.DiffOptions.DiffOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.DiffOptions.DiffOptions
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Native</a>.
noNative :: Maybe 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) => Ptr () -> IO (GValueConstruct o)
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Native.Native a) => GI.Ggit.Objects.Native.IsNative a
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Native.Native
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Native.Native
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Native.Native
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CredSshKeyFromAgent</a>.
noCredSshKeyFromAgent :: Maybe 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) => Text -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent a) => GI.Ggit.Objects.CredSshKeyFromAgent.IsCredSshKeyFromAgent a
instance GI.Ggit.Objects.CredSshKeyFromAgent.IsCredSshKeyFromAgent GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance GI.Ggit.Objects.Cred.IsCred GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.CredSshKeyFromAgent.CredSshKeyFromAgent
instance GI.Gio.Interfaces.Initable.IsInitable 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CredSshInteractive</a>.
noCredSshInteractive :: Maybe 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) => Text -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.CredSshInteractive.CredSshInteractive a) => GI.Ggit.Objects.CredSshInteractive.IsCredSshInteractive a
instance GI.Ggit.Objects.CredSshInteractive.IsCredSshInteractive GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance GI.Ggit.Objects.Cred.IsCred GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.CredSshInteractive.CredSshInteractive
instance GI.Gio.Interfaces.Initable.IsInitable 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CredPlaintext</a>.
noCredPlaintext :: Maybe 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) => Text -> IO (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) => Text -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.CredPlaintext.CredPlaintext a) => GI.Ggit.Objects.CredPlaintext.IsCredPlaintext a
instance GI.Ggit.Objects.CredPlaintext.IsCredPlaintext GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance GI.Ggit.Objects.Cred.IsCred GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.CredPlaintext.CredPlaintext
instance GI.Gio.Interfaces.Initable.IsInitable 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Cred</a>.
noCred :: Maybe Cred
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Cred.Cred a) => GI.Ggit.Objects.Cred.IsCred a
instance GI.Ggit.Objects.Cred.IsCred GI.Ggit.Objects.Cred.Cred
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Cred.Cred
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Cred.Cred
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Cred.Cred
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Blob</a>.
noBlob :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Blob.Blob a) => GI.Ggit.Objects.Blob.IsBlob a
instance GI.Ggit.Objects.Blob.IsBlob GI.Ggit.Objects.Blob.Blob
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Blob.Blob
instance GI.Ggit.Objects.Object.IsObject GI.Ggit.Objects.Blob.Blob
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Blob.Blob
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Blob.Blob
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectFactoryBase</a>.
noObjectFactoryBase :: Maybe ObjectFactoryBase
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase a) => GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase a
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.ObjectFactoryBase.ObjectFactoryBase
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>ProxyOptions</a>.
noProxyOptions :: Maybe ProxyOptions

-- | Create a new proxy options object.
proxyOptionsNew :: (HasCallStack, MonadIO m) => m (Maybe ProxyOptions)
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.ProxyOptions.ProxyOptions a) => GI.Ggit.Objects.ProxyOptions.IsProxyOptions a
instance GI.Ggit.Objects.ProxyOptions.IsProxyOptions GI.Ggit.Objects.ProxyOptions.ProxyOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.ProxyOptions.ProxyOptions
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.ProxyOptions.ProxyOptions


-- | 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>PushOptions</a>.
noPushOptions :: Maybe 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

-- | 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 ()

-- | 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) => Int32 -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.PushOptions.PushOptions a) => GI.Ggit.Objects.PushOptions.IsPushOptions a
instance GI.Ggit.Objects.PushOptions.IsPushOptions GI.Ggit.Objects.PushOptions.PushOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.PushOptions.PushOptions
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.PushOptions.PushOptions


-- | 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Branch</a>.
noBranch :: Maybe 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)
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Branch.Branch a) => GI.Ggit.Objects.Branch.IsBranch a
instance GI.Ggit.Objects.Branch.IsBranch GI.Ggit.Objects.Branch.Branch
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Branch.Branch
instance GI.Ggit.Objects.Ref.IsRef GI.Ggit.Objects.Branch.Branch
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Branch.Branch
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Branch.Branch
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.Branch.Branch


-- | 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Signature</a>.
noSignature :: Maybe 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) => Text -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Signature.Signature a) => GI.Ggit.Objects.Signature.IsSignature a
instance GI.Ggit.Objects.Signature.IsSignature GI.Ggit.Objects.Signature.Signature
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Signature.Signature
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Signature.Signature
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Signature.Signature
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CheckoutOptions</a>.
noCheckoutOptions :: Maybe 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) => Text -> IO (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, IsTree a) => a -> IO (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) => Word32 -> IO (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) => Bool -> IO (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) => Word32 -> IO (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) => Int32 -> IO (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) => [CheckoutNotifyFlags] -> IO (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) => Text -> IO (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) => [CheckoutStrategy] -> IO (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) => Text -> IO (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) => Text -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.CheckoutOptions.CheckoutOptions a) => GI.Ggit.Objects.CheckoutOptions.IsCheckoutOptions a
instance GI.Ggit.Objects.CheckoutOptions.IsCheckoutOptions GI.Ggit.Objects.CheckoutOptions.CheckoutOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CheckoutOptions.CheckoutOptions
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Blame</a>.
noBlame :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Blame.Blame a) => GI.Ggit.Objects.Blame.IsBlame a
instance GI.Ggit.Objects.Blame.IsBlame GI.Ggit.Objects.Blame.Blame
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Blame.Blame
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Blame.Blame
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Blame.Blame
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.Blame.Blame


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

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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>BranchEnumerator</a>.
noBranchEnumerator :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>ConfigEntry</a>.
noConfigEntry :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CredSshInteractivePrompt</a>.
noCredSshInteractivePrompt :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.CredSshInteractivePrompt.CredSshInteractivePrompt


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

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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffBinary</a>.
noDiffBinary :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffBinaryFile</a>.
noDiffBinaryFile :: Maybe 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 -> Word64 -> m Word8

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

-- | 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffDelta</a>.
noDiffDelta :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffHunk</a>.
noDiffHunk :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffLine</a>.
noDiffLine :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffFindOptions</a>.
noDiffFindOptions :: Maybe 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 Word64

-- | 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 -> Word64 -> 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) => Word32 -> IO (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) => [DiffFindFlags] -> IO (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) => DiffSimilarityMetric -> IO (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) => Word32 -> IO (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) => Word32 -> IO (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) => Word32 -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.DiffFindOptions.DiffFindOptions a) => GI.Ggit.Objects.DiffFindOptions.IsDiffFindOptions a
instance GI.Ggit.Objects.DiffFindOptions.IsDiffFindOptions GI.Ggit.Objects.DiffFindOptions.DiffFindOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.DiffFindOptions.DiffFindOptions
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>SubmoduleUpdateOptions</a>.
noSubmoduleUpdateOptions :: Maybe 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, IsCheckoutOptions a) => a -> IO (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) => FetchOptions -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions a) => GI.Ggit.Objects.SubmoduleUpdateOptions.IsSubmoduleUpdateOptions a
instance GI.Ggit.Objects.SubmoduleUpdateOptions.IsSubmoduleUpdateOptions GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.SubmoduleUpdateOptions.SubmoduleUpdateOptions
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CloneOptions</a>.
noCloneOptions :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.CloneOptions.CloneOptions a) => GI.Ggit.Objects.CloneOptions.IsCloneOptions a
instance GI.Ggit.Objects.CloneOptions.IsCloneOptions GI.Ggit.Objects.CloneOptions.CloneOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CloneOptions.CloneOptions
instance GI.GObject.Objects.Object.IsObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>FetchOptions</a>.
noFetchOptions :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>IndexEntries</a>.
noIndexEntries :: Maybe 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 -> Word64 -> 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>IndexEntriesResolveUndo</a>.
noIndexEntriesResolveUndo :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CherryPickOptions</a>.
noCherryPickOptions :: Maybe 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, IsCheckoutOptions a) => a -> IO (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) => Word32 -> IO (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) => MergeOptions -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.CherryPickOptions.CherryPickOptions a) => GI.Ggit.Objects.CherryPickOptions.IsCherryPickOptions a
instance GI.Ggit.Objects.CherryPickOptions.IsCherryPickOptions GI.Ggit.Objects.CherryPickOptions.CherryPickOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CherryPickOptions.CherryPickOptions
instance GI.GObject.Objects.Object.IsObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>MergeOptions</a>.
noMergeOptions :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.MergeOptions.MergeOptions


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

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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Note</a>.
noNote :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>IndexEntryResolveUndo</a>.
noIndexEntryResolveUndo :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>IndexEntry</a>.
noIndexEntry :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffFile</a>.
noDiffFile :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.DiffFile.DiffFile


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

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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>BlameOptions</a>.
noBlameOptions :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.BlameOptions.BlameOptions


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

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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>BlameHunk</a>.
noBlameHunk :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>AnnotatedCommit</a>.
noAnnotatedCommit :: Maybe AnnotatedCommit

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

-- | 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Tag</a>.
noTag :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Tag.Tag a) => GI.Ggit.Objects.Tag.IsTag a
instance GI.Ggit.Objects.Tag.IsTag GI.Ggit.Objects.Tag.Tag
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Tag.Tag
instance GI.Ggit.Objects.Object.IsObject GI.Ggit.Objects.Tag.Tag
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Tag.Tag
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Tag.Tag
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>RevisionWalker</a>.
noRevisionWalker :: Maybe 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, IsRepository a) => a -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.RevisionWalker.RevisionWalker a) => GI.Ggit.Objects.RevisionWalker.IsRevisionWalker a
instance GI.Ggit.Objects.RevisionWalker.IsRevisionWalker GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.RevisionWalker.RevisionWalker
instance GI.Gio.Interfaces.Initable.IsInitable 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Object</a>.
noObject :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Object.Object a) => GI.Ggit.Objects.Object.IsObject a
instance GI.Ggit.Objects.Object.IsObject GI.Ggit.Objects.Object.Object
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Object.Object
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Object.Object
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Object.Object
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Index</a>.
noIndex :: Maybe 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, IsFile a) => a -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Index.Index a) => GI.Ggit.Objects.Index.IsIndex a
instance GI.Ggit.Objects.Index.IsIndex GI.Ggit.Objects.Index.Index
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Index.Index
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Index.Index
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Index.Index
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.Index.Index
instance GI.Gio.Interfaces.Initable.IsInitable 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffFormatEmailOptions</a>.
noDiffFormatEmailOptions :: Maybe 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 Word64

-- | 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 Word64

-- | 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 -> Word64 -> 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 -> Word64 -> 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, IsSignature a) => a -> IO (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) => Text -> IO (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) => [DiffFormatEmailFlags] -> IO (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) => OId -> IO (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) => Word64 -> IO (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) => Text -> IO (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) => Word64 -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions a) => GI.Ggit.Objects.DiffFormatEmailOptions.IsDiffFormatEmailOptions a
instance GI.Ggit.Objects.DiffFormatEmailOptions.IsDiffFormatEmailOptions GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.DiffFormatEmailOptions.DiffFormatEmailOptions
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>CommitParents</a>.
noCommitParents :: Maybe 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, IsCommit a) => a -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.CommitParents.CommitParents a) => GI.Ggit.Objects.CommitParents.IsCommitParents a
instance GI.Ggit.Objects.CommitParents.IsCommitParents GI.Ggit.Objects.CommitParents.CommitParents
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.CommitParents.CommitParents
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Commit</a>.
noCommit :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Commit.Commit a) => GI.Ggit.Objects.Commit.IsCommit a
instance GI.Ggit.Objects.Commit.IsCommit GI.Ggit.Objects.Commit.Commit
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Commit.Commit
instance GI.Ggit.Objects.Object.IsObject GI.Ggit.Objects.Commit.Commit
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Commit.Commit
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Commit.Commit
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>BlobOutputStream</a>.
noBlobOutputStream :: Maybe 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, IsRepository a) => a -> IO (GValueConstruct o)
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.BlobOutputStream.BlobOutputStream a) => GI.Ggit.Objects.BlobOutputStream.IsBlobOutputStream a
instance GI.Ggit.Objects.BlobOutputStream.IsBlobOutputStream GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance GI.Gio.Objects.OutputStream.IsOutputStream GI.Ggit.Objects.BlobOutputStream.BlobOutputStream
instance GI.GObject.Objects.Object.IsObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>OId</a>.
noOId :: Maybe 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) => Word8 -> 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.OId.OId


-- | Represents a patch object.
module GI.Ggit.Structs.Patch

-- | Memory-managed wrapper type.
newtype Patch
Patch :: (ManagedPtr Patch) -> Patch

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Patch</a>.
noPatch :: Maybe 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 -> Word64 -> m (Maybe DiffHunk)

-- | Get the line statistics of the patch.
patchGetLineStats :: (HasCallStack, MonadIO m) => Patch -> m ((Word64, Word64, Word64))

-- | Get the number of hunks in the patch.
patchGetNumHunks :: (HasCallStack, MonadIO m) => Patch -> m Word64

-- | Get the number of lines in <i><tt>hunk</tt></i>.
patchGetNumLinesInHunk :: (HasCallStack, MonadIO m) => Patch -> Word64 -> 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 -> Word64 -> 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Rebase</a>.
noRebase :: Maybe 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 -> Word64 -> m (Maybe RebaseOperation)

-- | Gets the count of rebase operations that are to be applied.
rebaseGetOperationEntryCount :: (HasCallStack, MonadIO m, IsRebase a) => a -> m Word64

-- | 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 Word64

-- | 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Rebase.Rebase a) => GI.Ggit.Objects.Rebase.IsRebase a
instance GI.Ggit.Objects.Rebase.IsRebase GI.Ggit.Objects.Rebase.Rebase
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Rebase.Rebase
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Rebase.Rebase
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Rebase.Rebase
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.Rebase.Rebase


-- | Represents a rebase operation.
module GI.Ggit.Structs.RebaseOperation

-- | Memory-managed wrapper type.
newtype RebaseOperation
RebaseOperation :: (ManagedPtr RebaseOperation) -> RebaseOperation

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>RebaseOperation</a>.
noRebaseOperation :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>RebaseOptions</a>.
noRebaseOptions :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>RefSpec</a>.
noRefSpec :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Ref</a>.
noRef :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Ref.Ref a) => GI.Ggit.Objects.Ref.IsRef a
instance GI.Ggit.Objects.Ref.IsRef GI.Ggit.Objects.Ref.Ref
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Ref.Ref
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Ref.Ref
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Ref.Ref
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.Ref.Ref


-- | Represents a reflog.
module GI.Ggit.Structs.Reflog

-- | Memory-managed wrapper type.
newtype Reflog
Reflog :: (ManagedPtr Reflog) -> Reflog

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Reflog</a>.
noReflog :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.Reflog.Reflog


-- | Represents a reflog entry.
module GI.Ggit.Structs.ReflogEntry

-- | Memory-managed wrapper type.
newtype ReflogEntry
ReflogEntry :: (ManagedPtr ReflogEntry) -> ReflogEntry

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>ReflogEntry</a>.
noReflogEntry :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Remote</a>.
noRemote :: Maybe 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)

-- | Update tips to the new state.
remoteUpdateTips :: (HasCallStack, MonadIO m, IsRemote a, IsRemoteCallbacks b) => a -> b -> Bool -> RemoteDownloadTagsType -> Maybe (Text) -> m ()
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Remote.Remote a) => GI.Ggit.Objects.Remote.IsRemote a
instance GI.Ggit.Objects.Remote.IsRemote GI.Ggit.Objects.Remote.Remote
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Remote.Remote
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Remote.Remote
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Remote.Remote
instance GI.GObject.Objects.Object.IsObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteHead</a>.
noRemoteHead :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>RevertOptions</a>.
noRevertOptions :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>StatusOptions</a>.
noStatusOptions :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.StatusOptions.StatusOptions


-- | Represents a git submodule.
module GI.Ggit.Structs.Submodule

-- | Memory-managed wrapper type.
newtype Submodule
Submodule :: (ManagedPtr Submodule) -> Submodule

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Submodule</a>.
noSubmodule :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>RemoteCallbacks</a>.
noRemoteCallbacks :: Maybe 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 “<tt>completion</tt>” 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>Closure</a>.
genClosure_RemoteCallbacksCompletion :: RemoteCallbacksCompletionCallback -> IO Closure

-- | 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 “<tt>completion</tt>” 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 “<tt>progress</tt>” 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>Closure</a>.
genClosure_RemoteCallbacksProgress :: RemoteCallbacksProgressCallback -> IO Closure

-- | 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 “<tt>progress</tt>” 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 “<tt>transfer-progress</tt>” 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>Closure</a>.
genClosure_RemoteCallbacksTransferProgress :: RemoteCallbacksTransferProgressCallback -> IO Closure

-- | 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 “<tt>transfer-progress</tt>” 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 “<tt>update-tips</tt>” 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>Closure</a>.
genClosure_RemoteCallbacksUpdateTips :: RemoteCallbacksUpdateTipsCallback -> IO Closure

-- | 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 “<tt>update-tips</tt>” 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks a) => GI.Ggit.Objects.RemoteCallbacks.IsRemoteCallbacks a
instance GI.Ggit.Objects.RemoteCallbacks.IsRemoteCallbacks GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.RemoteCallbacks.RemoteCallbacks


-- | Represents transfering progress.
module GI.Ggit.Structs.TransferProgress

-- | Memory-managed wrapper type.
newtype TransferProgress
TransferProgress :: (ManagedPtr TransferProgress) -> TransferProgress

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>TransferProgress</a>.
noTransferProgress :: Maybe 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 Word64

-- | 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeBuilder</a>.
noTreeBuilder :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.TreeBuilder.TreeBuilder a) => GI.Ggit.Objects.TreeBuilder.IsTreeBuilder a
instance GI.Ggit.Objects.TreeBuilder.IsTreeBuilder GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.TreeBuilder.TreeBuilder
instance GI.GObject.Objects.Object.IsObject 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 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'.  -> IO Int32  __Returns:__ 0 to go for the next config value or a '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 'GI.Ggit.Structs.ConfigEntry.ConfigEntry'.  -> Ptr ()  /@userData@/: user-supplied data.  -> IO Int32  __Returns:__ 0 to go for the next config value or a '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>Closure</a>.
genClosure_ConfigCallback :: ConfigCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_ConfigMatchCallback :: ConfigMatchCallback -> IO Closure

-- | 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>Closure</a>.
genClosure_CredAcquireCallback :: CredAcquireCallback -> IO Closure

-- | 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 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> DiffBinary  /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'.  -> IO Int32  __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. 

-- | Called for each file.
type DiffBinaryCallback_WithClosures = DiffDelta  /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> DiffBinary  /@binary@/: a 'GI.Ggit.Structs.DiffBinary.DiffBinary'.  -> Ptr ()  /@userData@/: user-supplied data.  -> IO Int32  __Returns:__ 0 to go continue or a '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>Closure</a>.
genClosure_DiffBinaryCallback :: DiffBinaryCallback -> IO Closure

-- | 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 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> Float  /@progress@/: the progress.  -> IO Int32  __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. 

-- | Called for each file.
type DiffFileCallback_WithClosures = DiffDelta  /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> Float  /@progress@/: the progress.  -> Ptr ()  /@userData@/: user-supplied data.  -> IO Int32  __Returns:__ 0 to go continue or a '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>Closure</a>.
genClosure_DiffFileCallback :: DiffFileCallback -> IO Closure

-- | 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 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> DiffHunk  /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'.  -> IO Int32  __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. 

-- | Called for each hunk.
type DiffHunkCallback_WithClosures = DiffDelta  /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> DiffHunk  /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'.  -> Ptr ()  /@userData@/: user-supplied data.  -> IO Int32  __Returns:__ 0 to go continue or a '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>Closure</a>.
genClosure_DiffHunkCallback :: DiffHunkCallback -> IO Closure

-- | 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 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> DiffHunk  /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'.  -> DiffLine  /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'.  -> IO Int32  __Returns:__ 0 to go continue or a 'GI.Ggit.Enums.Error' in case there was an error. 

-- | Called for each line.
type DiffLineCallback_WithClosures = DiffDelta  /@delta@/: a 'GI.Ggit.Structs.DiffDelta.DiffDelta'.  -> DiffHunk  /@hunk@/: a 'GI.Ggit.Structs.DiffHunk.DiffHunk'.  -> DiffLine  /@line@/: a 'GI.Ggit.Structs.DiffLine.DiffLine'.  -> Ptr ()  /@userData@/: user-supplied data.  -> IO Int32  __Returns:__ 0 to go continue or a '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 -> DiffHunk -> DiffLine -> Ptr () -> m Int32

-- | Wrap the callback into a <a>Closure</a>.
genClosure_DiffLineCallback :: DiffLineCallback -> IO Closure

-- | 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 -> Word64 -> Ptr () -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricBufferSignatureCallback = DiffFile -> Text -> Word64 -> Ptr () -> IO Int32

-- | <i>No description available in the introspection data.</i>
type DiffSimilarityMetricBufferSignatureCallback_WithClosures = DiffFile -> Text -> Word64 -> 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 -> Word64 -> Ptr () -> Ptr () -> m Int32

-- | Wrap the callback into a <a>Closure</a>.
genClosure_DiffSimilarityMetricBufferSignatureCallback :: DiffSimilarityMetricBufferSignatureCallback -> IO Closure

-- | 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>Closure</a>.
genClosure_DiffSimilarityMetricFileSignatureCallback :: DiffSimilarityMetricFileSignatureCallback -> IO Closure

-- | 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>Closure</a>.
genClosure_DiffSimilarityMetricFreeSignatureCallback :: DiffSimilarityMetricFreeSignatureCallback -> IO Closure

-- | 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>Closure</a>.
genClosure_DiffSimilarityMetricSimilarityCallback :: DiffSimilarityMetricSimilarityCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_NoteCallback :: NoteCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_ReferencesCallback :: ReferencesCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_ReferencesNameCallback :: ReferencesNameCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_RemoteListCallback :: RemoteListCallback -> IO Closure

-- | 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 = Word64 -> 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 = Word64  /@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 '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 = Word64  /@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 '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 -> Word64 -> Text -> OId -> Ptr () -> m Int32

-- | Wrap the callback into a <a>Closure</a>.
genClosure_StashCallback :: StashCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_StatusCallback :: StatusCallback -> IO Closure

-- | 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 'GI.Ggit.Structs.Submodule.Submodule'.  -> Text  /@name@/: the name of the submodule.  -> IO Int32  __Returns:__ 0 to go for the next submodule or a '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 '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 '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>Closure</a>.
genClosure_SubmoduleCallback :: SubmoduleCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_TagCallback :: TagCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_TransferProgressCallback :: TransferProgressCallback -> IO Closure

-- | 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 '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 '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>Closure</a>.
genClosure_TreeWalkCallback :: TreeWalkCallback -> IO Closure

-- | 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>DiffSimilarityMetric</a>.
noDiffSimilarityMetric :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Tree</a>.
noTree :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Tree.Tree a) => GI.Ggit.Objects.Tree.IsTree a
instance GI.Ggit.Objects.Tree.IsTree GI.Ggit.Objects.Tree.Tree
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Tree.Tree
instance GI.Ggit.Objects.Object.IsObject GI.Ggit.Objects.Tree.Tree
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Tree.Tree
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Tree.Tree
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>Repository</a>.
noRepository :: Maybe 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 -> Word64 -> 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 ((Word64, Word64))

-- | 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)

-- | 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 ()

-- | 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 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, IsCloneOptions a) => a -> IO (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) => Bool -> IO (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) => Bool -> IO (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, IsFile a) => a -> IO (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) => Text -> IO (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, IsFile a) => a -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Repository.Repository a) => GI.Ggit.Objects.Repository.IsRepository a
instance GI.Ggit.Objects.Repository.IsRepository GI.Ggit.Objects.Repository.Repository
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Repository.Repository
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Repository.Repository
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Repository.Repository
instance GI.GObject.Objects.Object.IsObject GI.Ggit.Objects.Repository.Repository
instance GI.Gio.Interfaces.Initable.IsInitable 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Diff</a>.
noDiff :: Maybe 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 -> Word64 -> m (Maybe DiffDelta)

-- | Get the number of deltas in the diff.
diffGetNumDeltas :: (HasCallStack, MonadIO m, IsDiff a) => a -> m Word64

-- | 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 ()

-- | 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, IsRepository a) => a -> IO (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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Diff.Diff a) => GI.Ggit.Objects.Diff.IsDiff a
instance GI.Ggit.Objects.Diff.IsDiff GI.Ggit.Objects.Diff.Diff
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Diff.Diff
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Diff.Diff
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Diff.Diff
instance GI.GObject.Objects.Object.IsObject 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 => 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a> <a>Config</a>.
noConfig :: Maybe 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 (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Ggit.Objects.Config.Config a) => GI.Ggit.Objects.Config.IsConfig a
instance GI.Ggit.Objects.Config.IsConfig GI.Ggit.Objects.Config.Config
instance Data.GI.Base.BasicTypes.GObject GI.Ggit.Objects.Config.Config
instance GI.Ggit.Objects.Native.IsNative GI.Ggit.Objects.Config.Config
instance GI.Ggit.Objects.ObjectFactoryBase.IsObjectFactoryBase GI.Ggit.Objects.Config.Config
instance GI.GObject.Objects.Object.IsObject 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

-- | A convenience alias for <a>Nothing</a> :: <a>Maybe</a>
--   <a>TreeEntry</a>.
noTreeEntry :: Maybe 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 Data.GI.Base.BasicTypes.BoxedObject GI.Ggit.Structs.TreeEntry.TreeEntry


module GI.Ggit.Structs


module GI.Ggit
