-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.Ggit.Enums
    ( 

 -- * Enumerations


-- ** BranchType #enum:BranchType#

    BranchType(..)                          ,


-- ** CloneLocal #enum:CloneLocal#

    CloneLocal(..)                          ,


-- ** ConfigLevel #enum:ConfigLevel#

    ConfigLevel(..)                         ,


-- ** DeltaType #enum:DeltaType#

    DeltaType(..)                           ,


-- ** DiffBinaryType #enum:DiffBinaryType#

    DiffBinaryType(..)                      ,


-- ** DiffFormatType #enum:DiffFormatType#

    DiffFormatType(..)                      ,


-- ** DiffLineType #enum:DiffLineType#

    DiffLineType(..)                        ,


-- ** Direction #enum:Direction#

    Direction(..)                           ,


-- ** Error #enum:Error#

    Error(..)                               ,
    catchError                              ,
    handleError                             ,


-- ** FileMode #enum:FileMode#

    FileMode(..)                            ,


-- ** MergeFileFavor #enum:MergeFileFavor#

    MergeFileFavor(..)                      ,


-- ** PackbuilderStage #enum:PackbuilderStage#

    PackbuilderStage(..)                    ,


-- ** ProxyType #enum:ProxyType#

    ProxyType(..)                           ,


-- ** RebaseOperationType #enum:RebaseOperationType#

    RebaseOperationType(..)                 ,


-- ** RefType #enum:RefType#

    RefType(..)                             ,


-- ** RemoteCompletionType #enum:RemoteCompletionType#

    RemoteCompletionType(..)                ,


-- ** RemoteDownloadTagsType #enum:RemoteDownloadTagsType#

    RemoteDownloadTagsType(..)              ,


-- ** ResetType #enum:ResetType#

    ResetType(..)                           ,


-- ** StatusShow #enum:StatusShow#

    StatusShow(..)                          ,


-- ** SubmoduleIgnore #enum:SubmoduleIgnore#

    SubmoduleIgnore(..)                     ,


-- ** SubmoduleRecurse #enum:SubmoduleRecurse#

    SubmoduleRecurse(..)                    ,


-- ** SubmoduleUpdate #enum:SubmoduleUpdate#

    SubmoduleUpdate(..)                     ,


-- ** TreeWalkMode #enum:TreeWalkMode#

    TreeWalkMode(..)                        ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Enum TreeWalkMode
-- | Describes in which order a tree walk should be performed.
data TreeWalkMode = 
      TreeWalkModePre
    -- ^ walk tree in pre-order
    | TreeWalkModePost
    -- ^ walk tree in post-order
    | AnotherTreeWalkMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TreeWalkMode -> ShowS
[TreeWalkMode] -> ShowS
TreeWalkMode -> String
(Int -> TreeWalkMode -> ShowS)
-> (TreeWalkMode -> String)
-> ([TreeWalkMode] -> ShowS)
-> Show TreeWalkMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TreeWalkMode -> ShowS
showsPrec :: Int -> TreeWalkMode -> ShowS
$cshow :: TreeWalkMode -> String
show :: TreeWalkMode -> String
$cshowList :: [TreeWalkMode] -> ShowS
showList :: [TreeWalkMode] -> ShowS
Show, TreeWalkMode -> TreeWalkMode -> Bool
(TreeWalkMode -> TreeWalkMode -> Bool)
-> (TreeWalkMode -> TreeWalkMode -> Bool) -> Eq TreeWalkMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TreeWalkMode -> TreeWalkMode -> Bool
== :: TreeWalkMode -> TreeWalkMode -> Bool
$c/= :: TreeWalkMode -> TreeWalkMode -> Bool
/= :: TreeWalkMode -> TreeWalkMode -> Bool
Eq)

instance P.Enum TreeWalkMode where
    fromEnum :: TreeWalkMode -> Int
fromEnum TreeWalkMode
TreeWalkModePre = Int
0
    fromEnum TreeWalkMode
TreeWalkModePost = Int
1
    fromEnum (AnotherTreeWalkMode Int
k) = Int
k

    toEnum :: Int -> TreeWalkMode
toEnum Int
0 = TreeWalkMode
TreeWalkModePre
    toEnum Int
1 = TreeWalkMode
TreeWalkModePost
    toEnum Int
k = Int -> TreeWalkMode
AnotherTreeWalkMode Int
k

instance P.Ord TreeWalkMode where
    compare :: TreeWalkMode -> TreeWalkMode -> Ordering
compare TreeWalkMode
a TreeWalkMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeWalkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeWalkMode
a) (TreeWalkMode -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeWalkMode
b)

type instance O.ParentTypes TreeWalkMode = '[]
instance O.HasParentTypes TreeWalkMode

foreign import ccall "ggit_tree_walk_mode_get_type" c_ggit_tree_walk_mode_get_type :: 
    IO GType

instance B.Types.TypedObject TreeWalkMode where
    glibType :: IO GType
glibType = IO GType
c_ggit_tree_walk_mode_get_type

instance B.Types.BoxedEnum TreeWalkMode

-- Enum SubmoduleUpdate
-- | Describes how a submodule should be updated.
data SubmoduleUpdate = 
      SubmoduleUpdateCheckout
    -- ^ checkout the submodule.
    | SubmoduleUpdateRebase
    -- ^ rebase the current branch onto the
    --                                commit recorded in the superproject.
    | SubmoduleUpdateMerge
    -- ^ merge the commit recorded in the
    --                               superproject into the current branch.
    | SubmoduleUpdateNone
    -- ^ do not update this submodule.
    | SubmoduleUpdateDefault
    -- ^ not used except as static initializer
    -- when we don\'t want any particular update rule to be specified.
    | AnotherSubmoduleUpdate Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SubmoduleUpdate -> ShowS
[SubmoduleUpdate] -> ShowS
SubmoduleUpdate -> String
(Int -> SubmoduleUpdate -> ShowS)
-> (SubmoduleUpdate -> String)
-> ([SubmoduleUpdate] -> ShowS)
-> Show SubmoduleUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubmoduleUpdate -> ShowS
showsPrec :: Int -> SubmoduleUpdate -> ShowS
$cshow :: SubmoduleUpdate -> String
show :: SubmoduleUpdate -> String
$cshowList :: [SubmoduleUpdate] -> ShowS
showList :: [SubmoduleUpdate] -> ShowS
Show, SubmoduleUpdate -> SubmoduleUpdate -> Bool
(SubmoduleUpdate -> SubmoduleUpdate -> Bool)
-> (SubmoduleUpdate -> SubmoduleUpdate -> Bool)
-> Eq SubmoduleUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
== :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
$c/= :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
/= :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
Eq)

instance P.Enum SubmoduleUpdate where
    fromEnum :: SubmoduleUpdate -> Int
fromEnum SubmoduleUpdate
SubmoduleUpdateCheckout = Int
1
    fromEnum SubmoduleUpdate
SubmoduleUpdateRebase = Int
2
    fromEnum SubmoduleUpdate
SubmoduleUpdateMerge = Int
3
    fromEnum SubmoduleUpdate
SubmoduleUpdateNone = Int
4
    fromEnum SubmoduleUpdate
SubmoduleUpdateDefault = Int
0
    fromEnum (AnotherSubmoduleUpdate Int
k) = Int
k

    toEnum :: Int -> SubmoduleUpdate
toEnum Int
1 = SubmoduleUpdate
SubmoduleUpdateCheckout
    toEnum Int
2 = SubmoduleUpdate
SubmoduleUpdateRebase
    toEnum Int
3 = SubmoduleUpdate
SubmoduleUpdateMerge
    toEnum Int
4 = SubmoduleUpdate
SubmoduleUpdateNone
    toEnum Int
0 = SubmoduleUpdate
SubmoduleUpdateDefault
    toEnum Int
k = Int -> SubmoduleUpdate
AnotherSubmoduleUpdate Int
k

instance P.Ord SubmoduleUpdate where
    compare :: SubmoduleUpdate -> SubmoduleUpdate -> Ordering
compare SubmoduleUpdate
a SubmoduleUpdate
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubmoduleUpdate -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleUpdate
a) (SubmoduleUpdate -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleUpdate
b)

type instance O.ParentTypes SubmoduleUpdate = '[]
instance O.HasParentTypes SubmoduleUpdate

foreign import ccall "ggit_submodule_update_get_type" c_ggit_submodule_update_get_type :: 
    IO GType

instance B.Types.TypedObject SubmoduleUpdate where
    glibType :: IO GType
glibType = IO GType
c_ggit_submodule_update_get_type

instance B.Types.BoxedEnum SubmoduleUpdate

-- Enum SubmoduleRecurse
-- | Options for submodule recurse.
-- Represents the value of @submodule.$name.fetchRecurseSubmodules@
data SubmoduleRecurse = 
      SubmoduleRecurseNo
    -- ^ do no recurse into submodules.
    | SubmoduleRecurseYes
    -- ^ recurse into submodules.
    | SubmoduleRecurseOndemand
    -- ^ recurse into submodules only when
    -- commit not already in local clone.
    | AnotherSubmoduleRecurse Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SubmoduleRecurse -> ShowS
[SubmoduleRecurse] -> ShowS
SubmoduleRecurse -> String
(Int -> SubmoduleRecurse -> ShowS)
-> (SubmoduleRecurse -> String)
-> ([SubmoduleRecurse] -> ShowS)
-> Show SubmoduleRecurse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubmoduleRecurse -> ShowS
showsPrec :: Int -> SubmoduleRecurse -> ShowS
$cshow :: SubmoduleRecurse -> String
show :: SubmoduleRecurse -> String
$cshowList :: [SubmoduleRecurse] -> ShowS
showList :: [SubmoduleRecurse] -> ShowS
Show, SubmoduleRecurse -> SubmoduleRecurse -> Bool
(SubmoduleRecurse -> SubmoduleRecurse -> Bool)
-> (SubmoduleRecurse -> SubmoduleRecurse -> Bool)
-> Eq SubmoduleRecurse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
== :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
$c/= :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
/= :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
Eq)

instance P.Enum SubmoduleRecurse where
    fromEnum :: SubmoduleRecurse -> Int
fromEnum SubmoduleRecurse
SubmoduleRecurseNo = Int
0
    fromEnum SubmoduleRecurse
SubmoduleRecurseYes = Int
1
    fromEnum SubmoduleRecurse
SubmoduleRecurseOndemand = Int
2
    fromEnum (AnotherSubmoduleRecurse Int
k) = Int
k

    toEnum :: Int -> SubmoduleRecurse
toEnum Int
0 = SubmoduleRecurse
SubmoduleRecurseNo
    toEnum Int
1 = SubmoduleRecurse
SubmoduleRecurseYes
    toEnum Int
2 = SubmoduleRecurse
SubmoduleRecurseOndemand
    toEnum Int
k = Int -> SubmoduleRecurse
AnotherSubmoduleRecurse Int
k

instance P.Ord SubmoduleRecurse where
    compare :: SubmoduleRecurse -> SubmoduleRecurse -> Ordering
compare SubmoduleRecurse
a SubmoduleRecurse
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubmoduleRecurse -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleRecurse
a) (SubmoduleRecurse -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleRecurse
b)

type instance O.ParentTypes SubmoduleRecurse = '[]
instance O.HasParentTypes SubmoduleRecurse

foreign import ccall "ggit_submodule_recurse_get_type" c_ggit_submodule_recurse_get_type :: 
    IO GType

instance B.Types.TypedObject SubmoduleRecurse where
    glibType :: IO GType
glibType = IO GType
c_ggit_submodule_recurse_get_type

instance B.Types.BoxedEnum SubmoduleRecurse

-- Enum SubmoduleIgnore
-- | Describes which submodules should be ignored.
data SubmoduleIgnore = 
      SubmoduleIgnoreUnspecified
    -- ^ reset to on-disk value.
    | SubmoduleIgnoreNone
    -- ^ don\'t ignore any change.
    | SubmoduleIgnoreUntracked
    -- ^ ignore untracked files.
    | SubmoduleIgnoreDirty
    -- ^ ignore changes in the working directory.
    | SubmoduleIgnoreAll
    -- ^ never check if the submodule is dirty.
    | AnotherSubmoduleIgnore Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SubmoduleIgnore -> ShowS
[SubmoduleIgnore] -> ShowS
SubmoduleIgnore -> String
(Int -> SubmoduleIgnore -> ShowS)
-> (SubmoduleIgnore -> String)
-> ([SubmoduleIgnore] -> ShowS)
-> Show SubmoduleIgnore
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubmoduleIgnore -> ShowS
showsPrec :: Int -> SubmoduleIgnore -> ShowS
$cshow :: SubmoduleIgnore -> String
show :: SubmoduleIgnore -> String
$cshowList :: [SubmoduleIgnore] -> ShowS
showList :: [SubmoduleIgnore] -> ShowS
Show, SubmoduleIgnore -> SubmoduleIgnore -> Bool
(SubmoduleIgnore -> SubmoduleIgnore -> Bool)
-> (SubmoduleIgnore -> SubmoduleIgnore -> Bool)
-> Eq SubmoduleIgnore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
== :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
$c/= :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
/= :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
Eq)

instance P.Enum SubmoduleIgnore where
    fromEnum :: SubmoduleIgnore -> Int
fromEnum SubmoduleIgnore
SubmoduleIgnoreUnspecified = Int
-1
    fromEnum SubmoduleIgnore
SubmoduleIgnoreNone = Int
1
    fromEnum SubmoduleIgnore
SubmoduleIgnoreUntracked = Int
2
    fromEnum SubmoduleIgnore
SubmoduleIgnoreDirty = Int
3
    fromEnum SubmoduleIgnore
SubmoduleIgnoreAll = Int
4
    fromEnum (AnotherSubmoduleIgnore Int
k) = Int
k

    toEnum :: Int -> SubmoduleIgnore
toEnum Int
-1 = SubmoduleIgnore
SubmoduleIgnoreUnspecified
    toEnum Int
1 = SubmoduleIgnore
SubmoduleIgnoreNone
    toEnum Int
2 = SubmoduleIgnore
SubmoduleIgnoreUntracked
    toEnum Int
3 = SubmoduleIgnore
SubmoduleIgnoreDirty
    toEnum Int
4 = SubmoduleIgnore
SubmoduleIgnoreAll
    toEnum Int
k = Int -> SubmoduleIgnore
AnotherSubmoduleIgnore Int
k

instance P.Ord SubmoduleIgnore where
    compare :: SubmoduleIgnore -> SubmoduleIgnore -> Ordering
compare SubmoduleIgnore
a SubmoduleIgnore
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubmoduleIgnore -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleIgnore
a) (SubmoduleIgnore -> Int
forall a. Enum a => a -> Int
P.fromEnum SubmoduleIgnore
b)

type instance O.ParentTypes SubmoduleIgnore = '[]
instance O.HasParentTypes SubmoduleIgnore

foreign import ccall "ggit_submodule_ignore_get_type" c_ggit_submodule_ignore_get_type :: 
    IO GType

instance B.Types.TypedObject SubmoduleIgnore where
    glibType :: IO GType
glibType = IO GType
c_ggit_submodule_ignore_get_type

instance B.Types.BoxedEnum SubmoduleIgnore

-- Enum StatusShow
-- | Show options for @/ggit_repository_file_status_foreach/@. Determines which
-- files are included in the status.
data StatusShow = 
      StatusShowIndexAndWorkdir
    -- ^ receive one callback for each file,
    -- even if the file is in both the index and the workdir (combining t'GI.Ggit.Flags.StatusFlags').
    | StatusShowIndexOnly
    -- ^ only receive callbacks for files in the index.
    | StatusShowWorkdirOnly
    -- ^ only receive callbacks for files in the workdir.
    | AnotherStatusShow Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StatusShow -> ShowS
[StatusShow] -> ShowS
StatusShow -> String
(Int -> StatusShow -> ShowS)
-> (StatusShow -> String)
-> ([StatusShow] -> ShowS)
-> Show StatusShow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusShow -> ShowS
showsPrec :: Int -> StatusShow -> ShowS
$cshow :: StatusShow -> String
show :: StatusShow -> String
$cshowList :: [StatusShow] -> ShowS
showList :: [StatusShow] -> ShowS
Show, StatusShow -> StatusShow -> Bool
(StatusShow -> StatusShow -> Bool)
-> (StatusShow -> StatusShow -> Bool) -> Eq StatusShow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusShow -> StatusShow -> Bool
== :: StatusShow -> StatusShow -> Bool
$c/= :: StatusShow -> StatusShow -> Bool
/= :: StatusShow -> StatusShow -> Bool
Eq)

instance P.Enum StatusShow where
    fromEnum :: StatusShow -> Int
fromEnum StatusShow
StatusShowIndexAndWorkdir = Int
0
    fromEnum StatusShow
StatusShowIndexOnly = Int
1
    fromEnum StatusShow
StatusShowWorkdirOnly = Int
2
    fromEnum (AnotherStatusShow Int
k) = Int
k

    toEnum :: Int -> StatusShow
toEnum Int
0 = StatusShow
StatusShowIndexAndWorkdir
    toEnum Int
1 = StatusShow
StatusShowIndexOnly
    toEnum Int
2 = StatusShow
StatusShowWorkdirOnly
    toEnum Int
k = Int -> StatusShow
AnotherStatusShow Int
k

instance P.Ord StatusShow where
    compare :: StatusShow -> StatusShow -> Ordering
compare StatusShow
a StatusShow
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StatusShow -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusShow
a) (StatusShow -> Int
forall a. Enum a => a -> Int
P.fromEnum StatusShow
b)

type instance O.ParentTypes StatusShow = '[]
instance O.HasParentTypes StatusShow

foreign import ccall "ggit_status_show_get_type" c_ggit_status_show_get_type :: 
    IO GType

instance B.Types.TypedObject StatusShow where
    glibType :: IO GType
glibType = IO GType
c_ggit_status_show_get_type

instance B.Types.BoxedEnum StatusShow

-- Enum ResetType
-- | Describes the type of reset to perform.
data ResetType = 
      ResetTypeSoft
    -- ^ The head will be moved to the commit.
    | ResetTypeMixed
    -- ^ the head will be moved to the commit and the index
    --                    will be replaced with the content of the commit tree.
    | ResetTypeHard
    -- ^ MIXED plus changes in working tree discarded.
    | AnotherResetType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ResetType -> ShowS
[ResetType] -> ShowS
ResetType -> String
(Int -> ResetType -> ShowS)
-> (ResetType -> String)
-> ([ResetType] -> ShowS)
-> Show ResetType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ResetType -> ShowS
showsPrec :: Int -> ResetType -> ShowS
$cshow :: ResetType -> String
show :: ResetType -> String
$cshowList :: [ResetType] -> ShowS
showList :: [ResetType] -> ShowS
Show, ResetType -> ResetType -> Bool
(ResetType -> ResetType -> Bool)
-> (ResetType -> ResetType -> Bool) -> Eq ResetType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ResetType -> ResetType -> Bool
== :: ResetType -> ResetType -> Bool
$c/= :: ResetType -> ResetType -> Bool
/= :: ResetType -> ResetType -> Bool
Eq)

instance P.Enum ResetType where
    fromEnum :: ResetType -> Int
fromEnum ResetType
ResetTypeSoft = Int
1
    fromEnum ResetType
ResetTypeMixed = Int
2
    fromEnum ResetType
ResetTypeHard = Int
3
    fromEnum (AnotherResetType Int
k) = Int
k

    toEnum :: Int -> ResetType
toEnum Int
1 = ResetType
ResetTypeSoft
    toEnum Int
2 = ResetType
ResetTypeMixed
    toEnum Int
3 = ResetType
ResetTypeHard
    toEnum Int
k = Int -> ResetType
AnotherResetType Int
k

instance P.Ord ResetType where
    compare :: ResetType -> ResetType -> Ordering
compare ResetType
a ResetType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResetType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResetType
a) (ResetType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResetType
b)

type instance O.ParentTypes ResetType = '[]
instance O.HasParentTypes ResetType

foreign import ccall "ggit_reset_type_get_type" c_ggit_reset_type_get_type :: 
    IO GType

instance B.Types.TypedObject ResetType where
    glibType :: IO GType
glibType = IO GType
c_ggit_reset_type_get_type

instance B.Types.BoxedEnum ResetType

-- Enum RemoteDownloadTagsType
-- | Automatic tag following option
-- 
-- Lets us select the --tags option to use.
data RemoteDownloadTagsType = 
      RemoteDownloadTagsTypeUnspecified
    -- ^ Use the setting from the configuration.
    | RemoteDownloadTagsTypeAuto
    -- ^ Ask the server for tags pointing to objects we\'re already
    -- downloading.
    | RemoteDownloadTagsTypeNone
    -- ^ Don\'t ask for any tags beyond the refspecs.
    | RemoteDownloadTagsTypeAll
    -- ^ Ask for the all the tags.
    | AnotherRemoteDownloadTagsType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RemoteDownloadTagsType -> ShowS
[RemoteDownloadTagsType] -> ShowS
RemoteDownloadTagsType -> String
(Int -> RemoteDownloadTagsType -> ShowS)
-> (RemoteDownloadTagsType -> String)
-> ([RemoteDownloadTagsType] -> ShowS)
-> Show RemoteDownloadTagsType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RemoteDownloadTagsType -> ShowS
showsPrec :: Int -> RemoteDownloadTagsType -> ShowS
$cshow :: RemoteDownloadTagsType -> String
show :: RemoteDownloadTagsType -> String
$cshowList :: [RemoteDownloadTagsType] -> ShowS
showList :: [RemoteDownloadTagsType] -> ShowS
Show, RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
(RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool)
-> (RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool)
-> Eq RemoteDownloadTagsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
== :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
$c/= :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
/= :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
Eq)

instance P.Enum RemoteDownloadTagsType where
    fromEnum :: RemoteDownloadTagsType -> Int
fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeUnspecified = Int
0
    fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeAuto = Int
1
    fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeNone = Int
2
    fromEnum RemoteDownloadTagsType
RemoteDownloadTagsTypeAll = Int
3
    fromEnum (AnotherRemoteDownloadTagsType Int
k) = Int
k

    toEnum :: Int -> RemoteDownloadTagsType
toEnum Int
0 = RemoteDownloadTagsType
RemoteDownloadTagsTypeUnspecified
    toEnum Int
1 = RemoteDownloadTagsType
RemoteDownloadTagsTypeAuto
    toEnum Int
2 = RemoteDownloadTagsType
RemoteDownloadTagsTypeNone
    toEnum Int
3 = RemoteDownloadTagsType
RemoteDownloadTagsTypeAll
    toEnum Int
k = Int -> RemoteDownloadTagsType
AnotherRemoteDownloadTagsType Int
k

instance P.Ord RemoteDownloadTagsType where
    compare :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Ordering
compare RemoteDownloadTagsType
a RemoteDownloadTagsType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RemoteDownloadTagsType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteDownloadTagsType
a) (RemoteDownloadTagsType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteDownloadTagsType
b)

type instance O.ParentTypes RemoteDownloadTagsType = '[]
instance O.HasParentTypes RemoteDownloadTagsType

foreign import ccall "ggit_remote_download_tags_type_get_type" c_ggit_remote_download_tags_type_get_type :: 
    IO GType

instance B.Types.TypedObject RemoteDownloadTagsType where
    glibType :: IO GType
glibType = IO GType
c_ggit_remote_download_tags_type_get_type

instance B.Types.BoxedEnum RemoteDownloadTagsType

-- Enum RemoteCompletionType
-- | Argument to the completion callback which tells it which operation finished.
data RemoteCompletionType = 
      RemoteCompletionTypeDownload
    -- ^ download.
    | RemoteCompletionTypeIndexing
    -- ^ indexing.
    | RemoteCompletionTypeError
    -- ^ error.
    | AnotherRemoteCompletionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RemoteCompletionType -> ShowS
[RemoteCompletionType] -> ShowS
RemoteCompletionType -> String
(Int -> RemoteCompletionType -> ShowS)
-> (RemoteCompletionType -> String)
-> ([RemoteCompletionType] -> ShowS)
-> Show RemoteCompletionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RemoteCompletionType -> ShowS
showsPrec :: Int -> RemoteCompletionType -> ShowS
$cshow :: RemoteCompletionType -> String
show :: RemoteCompletionType -> String
$cshowList :: [RemoteCompletionType] -> ShowS
showList :: [RemoteCompletionType] -> ShowS
Show, RemoteCompletionType -> RemoteCompletionType -> Bool
(RemoteCompletionType -> RemoteCompletionType -> Bool)
-> (RemoteCompletionType -> RemoteCompletionType -> Bool)
-> Eq RemoteCompletionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RemoteCompletionType -> RemoteCompletionType -> Bool
== :: RemoteCompletionType -> RemoteCompletionType -> Bool
$c/= :: RemoteCompletionType -> RemoteCompletionType -> Bool
/= :: RemoteCompletionType -> RemoteCompletionType -> Bool
Eq)

instance P.Enum RemoteCompletionType where
    fromEnum :: RemoteCompletionType -> Int
fromEnum RemoteCompletionType
RemoteCompletionTypeDownload = Int
0
    fromEnum RemoteCompletionType
RemoteCompletionTypeIndexing = Int
1
    fromEnum RemoteCompletionType
RemoteCompletionTypeError = Int
2
    fromEnum (AnotherRemoteCompletionType Int
k) = Int
k

    toEnum :: Int -> RemoteCompletionType
toEnum Int
0 = RemoteCompletionType
RemoteCompletionTypeDownload
    toEnum Int
1 = RemoteCompletionType
RemoteCompletionTypeIndexing
    toEnum Int
2 = RemoteCompletionType
RemoteCompletionTypeError
    toEnum Int
k = Int -> RemoteCompletionType
AnotherRemoteCompletionType Int
k

instance P.Ord RemoteCompletionType where
    compare :: RemoteCompletionType -> RemoteCompletionType -> Ordering
compare RemoteCompletionType
a RemoteCompletionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RemoteCompletionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteCompletionType
a) (RemoteCompletionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RemoteCompletionType
b)

type instance O.ParentTypes RemoteCompletionType = '[]
instance O.HasParentTypes RemoteCompletionType

foreign import ccall "ggit_remote_completion_type_get_type" c_ggit_remote_completion_type_get_type :: 
    IO GType

instance B.Types.TypedObject RemoteCompletionType where
    glibType :: IO GType
glibType = IO GType
c_ggit_remote_completion_type_get_type

instance B.Types.BoxedEnum RemoteCompletionType

-- Enum RefType
-- | Describes the type a reference is.
data RefType = 
      RefTypeInvalid
    -- ^ An invalid reference.
    | RefTypeOid
    -- ^ A reference which points at an object id.
    | RefTypeSymbolic
    -- ^ A reference which points at another reference.
    | RefTypeListall
    -- ^ All reference types.
    | AnotherRefType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RefType -> ShowS
[RefType] -> ShowS
RefType -> String
(Int -> RefType -> ShowS)
-> (RefType -> String) -> ([RefType] -> ShowS) -> Show RefType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RefType -> ShowS
showsPrec :: Int -> RefType -> ShowS
$cshow :: RefType -> String
show :: RefType -> String
$cshowList :: [RefType] -> ShowS
showList :: [RefType] -> ShowS
Show, RefType -> RefType -> Bool
(RefType -> RefType -> Bool)
-> (RefType -> RefType -> Bool) -> Eq RefType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefType -> RefType -> Bool
== :: RefType -> RefType -> Bool
$c/= :: RefType -> RefType -> Bool
/= :: RefType -> RefType -> Bool
Eq)

instance P.Enum RefType where
    fromEnum :: RefType -> Int
fromEnum RefType
RefTypeInvalid = Int
0
    fromEnum RefType
RefTypeOid = Int
1
    fromEnum RefType
RefTypeSymbolic = Int
2
    fromEnum RefType
RefTypeListall = Int
3
    fromEnum (AnotherRefType Int
k) = Int
k

    toEnum :: Int -> RefType
toEnum Int
0 = RefType
RefTypeInvalid
    toEnum Int
1 = RefType
RefTypeOid
    toEnum Int
2 = RefType
RefTypeSymbolic
    toEnum Int
3 = RefType
RefTypeListall
    toEnum Int
k = Int -> RefType
AnotherRefType Int
k

instance P.Ord RefType where
    compare :: RefType -> RefType -> Ordering
compare RefType
a RefType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RefType -> Int
forall a. Enum a => a -> Int
P.fromEnum RefType
a) (RefType -> Int
forall a. Enum a => a -> Int
P.fromEnum RefType
b)

type instance O.ParentTypes RefType = '[]
instance O.HasParentTypes RefType

foreign import ccall "ggit_ref_type_get_type" c_ggit_ref_type_get_type :: 
    IO GType

instance B.Types.TypedObject RefType where
    glibType :: IO GType
glibType = IO GType
c_ggit_ref_type_get_type

instance B.Types.BoxedEnum RefType

-- Enum RebaseOperationType
-- | Type of rebase operation in-progress.
data RebaseOperationType = 
      RebaseOperationTypePick
    -- ^ The given commit is to be cherry-picked.
    -- The client should commit the changes and continue if there are no conflicts.
    | RebaseOperationTypeReword
    -- ^ The given commit is to be cherry-picked,
    -- but the client should prompt the user to provide an updated commit message.
    | RebaseOperationTypeEdit
    -- ^ The given commit is to be cherry-picked,
    -- but the client should stop to allow the user to edit the changes before
    -- committing them.
    | RebaseOperationTypeSquash
    -- ^ The given commit is to be squashed into
    -- the previous commit. The commit message will be merged with the previous message.
    | RebaseOperationTypeFixup
    -- ^ The given commit is to be squashed into the
    -- previous commit. The commit message from this commit will be discarded.
    | RebaseOperationTypeExec
    -- ^ No commit will be cherry-picked.
    -- The client should run the given command and (if successful) continue.
    | AnotherRebaseOperationType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RebaseOperationType -> ShowS
[RebaseOperationType] -> ShowS
RebaseOperationType -> String
(Int -> RebaseOperationType -> ShowS)
-> (RebaseOperationType -> String)
-> ([RebaseOperationType] -> ShowS)
-> Show RebaseOperationType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RebaseOperationType -> ShowS
showsPrec :: Int -> RebaseOperationType -> ShowS
$cshow :: RebaseOperationType -> String
show :: RebaseOperationType -> String
$cshowList :: [RebaseOperationType] -> ShowS
showList :: [RebaseOperationType] -> ShowS
Show, RebaseOperationType -> RebaseOperationType -> Bool
(RebaseOperationType -> RebaseOperationType -> Bool)
-> (RebaseOperationType -> RebaseOperationType -> Bool)
-> Eq RebaseOperationType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RebaseOperationType -> RebaseOperationType -> Bool
== :: RebaseOperationType -> RebaseOperationType -> Bool
$c/= :: RebaseOperationType -> RebaseOperationType -> Bool
/= :: RebaseOperationType -> RebaseOperationType -> Bool
Eq)

instance P.Enum RebaseOperationType where
    fromEnum :: RebaseOperationType -> Int
fromEnum RebaseOperationType
RebaseOperationTypePick = Int
0
    fromEnum RebaseOperationType
RebaseOperationTypeReword = Int
1
    fromEnum RebaseOperationType
RebaseOperationTypeEdit = Int
2
    fromEnum RebaseOperationType
RebaseOperationTypeSquash = Int
3
    fromEnum RebaseOperationType
RebaseOperationTypeFixup = Int
4
    fromEnum RebaseOperationType
RebaseOperationTypeExec = Int
5
    fromEnum (AnotherRebaseOperationType Int
k) = Int
k

    toEnum :: Int -> RebaseOperationType
toEnum Int
0 = RebaseOperationType
RebaseOperationTypePick
    toEnum Int
1 = RebaseOperationType
RebaseOperationTypeReword
    toEnum Int
2 = RebaseOperationType
RebaseOperationTypeEdit
    toEnum Int
3 = RebaseOperationType
RebaseOperationTypeSquash
    toEnum Int
4 = RebaseOperationType
RebaseOperationTypeFixup
    toEnum Int
5 = RebaseOperationType
RebaseOperationTypeExec
    toEnum Int
k = Int -> RebaseOperationType
AnotherRebaseOperationType Int
k

instance P.Ord RebaseOperationType where
    compare :: RebaseOperationType -> RebaseOperationType -> Ordering
compare RebaseOperationType
a RebaseOperationType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RebaseOperationType -> Int
forall a. Enum a => a -> Int
P.fromEnum RebaseOperationType
a) (RebaseOperationType -> Int
forall a. Enum a => a -> Int
P.fromEnum RebaseOperationType
b)

type instance O.ParentTypes RebaseOperationType = '[]
instance O.HasParentTypes RebaseOperationType

foreign import ccall "ggit_rebase_operation_type_get_type" c_ggit_rebase_operation_type_get_type :: 
    IO GType

instance B.Types.TypedObject RebaseOperationType where
    glibType :: IO GType
glibType = IO GType
c_ggit_rebase_operation_type_get_type

instance B.Types.BoxedEnum RebaseOperationType

-- Enum ProxyType
-- | The type of proxy to use.
data ProxyType = 
      ProxyTypeNone
    -- ^ Do not attempt to connect through a proxy.
    | ProxyTypeAuto
    -- ^ Try to auto-detect the proxy from the git configuration.
    | ProxyTypeSpecified
    -- ^ Connect via the URL given in the options.
    | AnotherProxyType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ProxyType -> ShowS
[ProxyType] -> ShowS
ProxyType -> String
(Int -> ProxyType -> ShowS)
-> (ProxyType -> String)
-> ([ProxyType] -> ShowS)
-> Show ProxyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProxyType -> ShowS
showsPrec :: Int -> ProxyType -> ShowS
$cshow :: ProxyType -> String
show :: ProxyType -> String
$cshowList :: [ProxyType] -> ShowS
showList :: [ProxyType] -> ShowS
Show, ProxyType -> ProxyType -> Bool
(ProxyType -> ProxyType -> Bool)
-> (ProxyType -> ProxyType -> Bool) -> Eq ProxyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProxyType -> ProxyType -> Bool
== :: ProxyType -> ProxyType -> Bool
$c/= :: ProxyType -> ProxyType -> Bool
/= :: ProxyType -> ProxyType -> Bool
Eq)

instance P.Enum ProxyType where
    fromEnum :: ProxyType -> Int
fromEnum ProxyType
ProxyTypeNone = Int
0
    fromEnum ProxyType
ProxyTypeAuto = Int
1
    fromEnum ProxyType
ProxyTypeSpecified = Int
2
    fromEnum (AnotherProxyType Int
k) = Int
k

    toEnum :: Int -> ProxyType
toEnum Int
0 = ProxyType
ProxyTypeNone
    toEnum Int
1 = ProxyType
ProxyTypeAuto
    toEnum Int
2 = ProxyType
ProxyTypeSpecified
    toEnum Int
k = Int -> ProxyType
AnotherProxyType Int
k

instance P.Ord ProxyType where
    compare :: ProxyType -> ProxyType -> Ordering
compare ProxyType
a ProxyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ProxyType -> Int
forall a. Enum a => a -> Int
P.fromEnum ProxyType
a) (ProxyType -> Int
forall a. Enum a => a -> Int
P.fromEnum ProxyType
b)

type instance O.ParentTypes ProxyType = '[]
instance O.HasParentTypes ProxyType

foreign import ccall "ggit_proxy_type_get_type" c_ggit_proxy_type_get_type :: 
    IO GType

instance B.Types.TypedObject ProxyType where
    glibType :: IO GType
glibType = IO GType
c_ggit_proxy_type_get_type

instance B.Types.BoxedEnum ProxyType

-- Enum PackbuilderStage
-- | Valid stages for pack building.
data PackbuilderStage = 
      PackbuilderStageAddingObjects
    -- ^ adding objects.
    | PackbuilderStageDeltafication
    -- ^ deltafication.
    | AnotherPackbuilderStage Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PackbuilderStage -> ShowS
[PackbuilderStage] -> ShowS
PackbuilderStage -> String
(Int -> PackbuilderStage -> ShowS)
-> (PackbuilderStage -> String)
-> ([PackbuilderStage] -> ShowS)
-> Show PackbuilderStage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PackbuilderStage -> ShowS
showsPrec :: Int -> PackbuilderStage -> ShowS
$cshow :: PackbuilderStage -> String
show :: PackbuilderStage -> String
$cshowList :: [PackbuilderStage] -> ShowS
showList :: [PackbuilderStage] -> ShowS
Show, PackbuilderStage -> PackbuilderStage -> Bool
(PackbuilderStage -> PackbuilderStage -> Bool)
-> (PackbuilderStage -> PackbuilderStage -> Bool)
-> Eq PackbuilderStage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PackbuilderStage -> PackbuilderStage -> Bool
== :: PackbuilderStage -> PackbuilderStage -> Bool
$c/= :: PackbuilderStage -> PackbuilderStage -> Bool
/= :: PackbuilderStage -> PackbuilderStage -> Bool
Eq)

instance P.Enum PackbuilderStage where
    fromEnum :: PackbuilderStage -> Int
fromEnum PackbuilderStage
PackbuilderStageAddingObjects = Int
0
    fromEnum PackbuilderStage
PackbuilderStageDeltafication = Int
1
    fromEnum (AnotherPackbuilderStage Int
k) = Int
k

    toEnum :: Int -> PackbuilderStage
toEnum Int
0 = PackbuilderStage
PackbuilderStageAddingObjects
    toEnum Int
1 = PackbuilderStage
PackbuilderStageDeltafication
    toEnum Int
k = Int -> PackbuilderStage
AnotherPackbuilderStage Int
k

instance P.Ord PackbuilderStage where
    compare :: PackbuilderStage -> PackbuilderStage -> Ordering
compare PackbuilderStage
a PackbuilderStage
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PackbuilderStage -> Int
forall a. Enum a => a -> Int
P.fromEnum PackbuilderStage
a) (PackbuilderStage -> Int
forall a. Enum a => a -> Int
P.fromEnum PackbuilderStage
b)

type instance O.ParentTypes PackbuilderStage = '[]
instance O.HasParentTypes PackbuilderStage

foreign import ccall "ggit_packbuilder_stage_get_type" c_ggit_packbuilder_stage_get_type :: 
    IO GType

instance B.Types.TypedObject PackbuilderStage where
    glibType :: IO GType
glibType = IO GType
c_ggit_packbuilder_stage_get_type

instance B.Types.BoxedEnum PackbuilderStage

-- Enum MergeFileFavor
-- | /No description available in the introspection data./
data MergeFileFavor = 
      MergeFileFavorNormal
    -- ^ /No description available in the introspection data./
    | MergeFileFavorOurs
    -- ^ /No description available in the introspection data./
    | MergeFileFavorTheirs
    -- ^ /No description available in the introspection data./
    | MergeFileFavorUnion
    -- ^ /No description available in the introspection data./
    | AnotherMergeFileFavor Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MergeFileFavor -> ShowS
[MergeFileFavor] -> ShowS
MergeFileFavor -> String
(Int -> MergeFileFavor -> ShowS)
-> (MergeFileFavor -> String)
-> ([MergeFileFavor] -> ShowS)
-> Show MergeFileFavor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeFileFavor -> ShowS
showsPrec :: Int -> MergeFileFavor -> ShowS
$cshow :: MergeFileFavor -> String
show :: MergeFileFavor -> String
$cshowList :: [MergeFileFavor] -> ShowS
showList :: [MergeFileFavor] -> ShowS
Show, MergeFileFavor -> MergeFileFavor -> Bool
(MergeFileFavor -> MergeFileFavor -> Bool)
-> (MergeFileFavor -> MergeFileFavor -> Bool) -> Eq MergeFileFavor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeFileFavor -> MergeFileFavor -> Bool
== :: MergeFileFavor -> MergeFileFavor -> Bool
$c/= :: MergeFileFavor -> MergeFileFavor -> Bool
/= :: MergeFileFavor -> MergeFileFavor -> Bool
Eq)

instance P.Enum MergeFileFavor where
    fromEnum :: MergeFileFavor -> Int
fromEnum MergeFileFavor
MergeFileFavorNormal = Int
0
    fromEnum MergeFileFavor
MergeFileFavorOurs = Int
1
    fromEnum MergeFileFavor
MergeFileFavorTheirs = Int
2
    fromEnum MergeFileFavor
MergeFileFavorUnion = Int
3
    fromEnum (AnotherMergeFileFavor Int
k) = Int
k

    toEnum :: Int -> MergeFileFavor
toEnum Int
0 = MergeFileFavor
MergeFileFavorNormal
    toEnum Int
1 = MergeFileFavor
MergeFileFavorOurs
    toEnum Int
2 = MergeFileFavor
MergeFileFavorTheirs
    toEnum Int
3 = MergeFileFavor
MergeFileFavorUnion
    toEnum Int
k = Int -> MergeFileFavor
AnotherMergeFileFavor Int
k

instance P.Ord MergeFileFavor where
    compare :: MergeFileFavor -> MergeFileFavor -> Ordering
compare MergeFileFavor
a MergeFileFavor
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MergeFileFavor -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFileFavor
a) (MergeFileFavor -> Int
forall a. Enum a => a -> Int
P.fromEnum MergeFileFavor
b)

type instance O.ParentTypes MergeFileFavor = '[]
instance O.HasParentTypes MergeFileFavor

foreign import ccall "ggit_merge_file_favor_get_type" c_ggit_merge_file_favor_get_type :: 
    IO GType

instance B.Types.TypedObject MergeFileFavor where
    glibType :: IO GType
glibType = IO GType
c_ggit_merge_file_favor_get_type

instance B.Types.BoxedEnum MergeFileFavor

-- Enum FileMode
-- | /No description available in the introspection data./
data FileMode = 
      FileModeUnreadable
    -- ^ /No description available in the introspection data./
    | FileModeTree
    -- ^ /No description available in the introspection data./
    | FileModeBlob
    -- ^ /No description available in the introspection data./
    | FileModeBlobExecutable
    -- ^ /No description available in the introspection data./
    | FileModeLink
    -- ^ /No description available in the introspection data./
    | FileModeCommit
    -- ^ /No description available in the introspection data./
    | AnotherFileMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FileMode -> ShowS
[FileMode] -> ShowS
FileMode -> String
(Int -> FileMode -> ShowS)
-> (FileMode -> String) -> ([FileMode] -> ShowS) -> Show FileMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FileMode -> ShowS
showsPrec :: Int -> FileMode -> ShowS
$cshow :: FileMode -> String
show :: FileMode -> String
$cshowList :: [FileMode] -> ShowS
showList :: [FileMode] -> ShowS
Show, FileMode -> FileMode -> Bool
(FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> Bool) -> Eq FileMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FileMode -> FileMode -> Bool
== :: FileMode -> FileMode -> Bool
$c/= :: FileMode -> FileMode -> Bool
/= :: FileMode -> FileMode -> Bool
Eq)

instance P.Enum FileMode where
    fromEnum :: FileMode -> Int
fromEnum FileMode
FileModeUnreadable = Int
0
    fromEnum FileMode
FileModeTree = Int
16384
    fromEnum FileMode
FileModeBlob = Int
33188
    fromEnum FileMode
FileModeBlobExecutable = Int
33261
    fromEnum FileMode
FileModeLink = Int
40960
    fromEnum FileMode
FileModeCommit = Int
57344
    fromEnum (AnotherFileMode Int
k) = Int
k

    toEnum :: Int -> FileMode
toEnum Int
0 = FileMode
FileModeUnreadable
    toEnum Int
16384 = FileMode
FileModeTree
    toEnum Int
33188 = FileMode
FileModeBlob
    toEnum Int
33261 = FileMode
FileModeBlobExecutable
    toEnum Int
40960 = FileMode
FileModeLink
    toEnum Int
57344 = FileMode
FileModeCommit
    toEnum Int
k = Int -> FileMode
AnotherFileMode Int
k

instance P.Ord FileMode where
    compare :: FileMode -> FileMode -> Ordering
compare FileMode
a FileMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMode
a) (FileMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FileMode
b)

type instance O.ParentTypes FileMode = '[]
instance O.HasParentTypes FileMode

foreign import ccall "ggit_file_mode_get_type" c_ggit_file_mode_get_type :: 
    IO GType

instance B.Types.TypedObject FileMode where
    glibType :: IO GType
glibType = IO GType
c_ggit_file_mode_get_type

instance B.Types.BoxedEnum FileMode

-- Enum Error
-- | Error codes for the @/GGIT_ERROR/@ error domain.
data Error = 
      ErrorGitError
    -- ^ A generic error for when an operation fails.
    | ErrorNotfound
    -- ^ Input does not exist in the scope searched.
    | ErrorExists
    -- ^ A reference with this name already exists.
    | ErrorAmbiguous
    -- ^ The given error is ambiguous.
    | ErrorBufs
    -- ^ The buffer is too short.
    | ErrorPassthrough
    -- ^ Skip and passthrough the given ODB backend.
    | ErrorIterover
    -- ^ The iteration has finished.
    | AnotherError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Error -> ShowS
[Error] -> ShowS
Error -> String
(Int -> Error -> ShowS)
-> (Error -> String) -> ([Error] -> ShowS) -> Show Error
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Error -> ShowS
showsPrec :: Int -> Error -> ShowS
$cshow :: Error -> String
show :: Error -> String
$cshowList :: [Error] -> ShowS
showList :: [Error] -> ShowS
Show, Error -> Error -> Bool
(Error -> Error -> Bool) -> (Error -> Error -> Bool) -> Eq Error
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Error -> Error -> Bool
== :: Error -> Error -> Bool
$c/= :: Error -> Error -> Bool
/= :: Error -> Error -> Bool
Eq)

instance P.Enum Error where
    fromEnum :: Error -> Int
fromEnum Error
ErrorGitError = Int
-1
    fromEnum Error
ErrorNotfound = Int
-3
    fromEnum Error
ErrorExists = Int
-4
    fromEnum Error
ErrorAmbiguous = Int
-5
    fromEnum Error
ErrorBufs = Int
-6
    fromEnum Error
ErrorPassthrough = Int
-30
    fromEnum Error
ErrorIterover = Int
-31
    fromEnum (AnotherError Int
k) = Int
k

    toEnum :: Int -> Error
toEnum Int
-1 = Error
ErrorGitError
    toEnum Int
-3 = Error
ErrorNotfound
    toEnum Int
-4 = Error
ErrorExists
    toEnum Int
-5 = Error
ErrorAmbiguous
    toEnum Int
-6 = Error
ErrorBufs
    toEnum Int
-30 = Error
ErrorPassthrough
    toEnum Int
-31 = Error
ErrorIterover
    toEnum Int
k = Int -> Error
AnotherError Int
k

instance P.Ord Error where
    compare :: Error -> Error -> Ordering
compare Error
a Error
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Error -> Int
forall a. Enum a => a -> Int
P.fromEnum Error
a) (Error -> Int
forall a. Enum a => a -> Int
P.fromEnum Error
b)

instance GErrorClass Error where
    gerrorClassDomain :: Error -> Text
gerrorClassDomain Error
_ = Text
"ggit-error"

-- | Catch exceptions of type `Error`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchError ::
    IO a ->
    (Error -> GErrorMessage -> IO a) ->
    IO a
catchError :: forall a. IO a -> (Error -> Text -> IO a) -> IO a
catchError = IO a -> (Error -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `Error`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleError ::
    (Error -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleError :: forall a. (Error -> Text -> IO a) -> IO a -> IO a
handleError = (Error -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes Error = '[]
instance O.HasParentTypes Error

foreign import ccall "ggit_error_get_type" c_ggit_error_get_type :: 
    IO GType

instance B.Types.TypedObject Error where
    glibType :: IO GType
glibType = IO GType
c_ggit_error_get_type

instance B.Types.BoxedEnum Error

-- Enum Direction
-- | /No description available in the introspection data./
data Direction = 
      DirectionFetch
    -- ^ /No description available in the introspection data./
    | DirectionPush
    -- ^ /No description available in the introspection data./
    | AnotherDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Direction -> ShowS
[Direction] -> ShowS
Direction -> String
(Int -> Direction -> ShowS)
-> (Direction -> String)
-> ([Direction] -> ShowS)
-> Show Direction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Direction -> ShowS
showsPrec :: Int -> Direction -> ShowS
$cshow :: Direction -> String
show :: Direction -> String
$cshowList :: [Direction] -> ShowS
showList :: [Direction] -> ShowS
Show, Direction -> Direction -> Bool
(Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool) -> Eq Direction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
/= :: Direction -> Direction -> Bool
Eq)

instance P.Enum Direction where
    fromEnum :: Direction -> Int
fromEnum Direction
DirectionFetch = Int
0
    fromEnum Direction
DirectionPush = Int
1
    fromEnum (AnotherDirection Int
k) = Int
k

    toEnum :: Int -> Direction
toEnum Int
0 = Direction
DirectionFetch
    toEnum Int
1 = Direction
DirectionPush
    toEnum Int
k = Int -> Direction
AnotherDirection Int
k

instance P.Ord Direction where
    compare :: Direction -> Direction -> Ordering
compare Direction
a Direction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Direction -> Int
forall a. Enum a => a -> Int
P.fromEnum Direction
a) (Direction -> Int
forall a. Enum a => a -> Int
P.fromEnum Direction
b)

type instance O.ParentTypes Direction = '[]
instance O.HasParentTypes Direction

foreign import ccall "ggit_direction_get_type" c_ggit_direction_get_type :: 
    IO GType

instance B.Types.TypedObject Direction where
    glibType :: IO GType
glibType = IO GType
c_ggit_direction_get_type

instance B.Types.BoxedEnum Direction

-- Enum DiffLineType
-- | These values describe where a line came from and will be passed to
-- the t'GI.Ggit.Callbacks.DiffLineCallback' when iterating over a diff.
-- 
-- The @/GGIT_DIFF_LINE_FILE_HDR/@, @/GGIT_DIFF_LINE_HUNK_HDR/@ and
-- @/GGIT_DIFF_LINE_BINARY/@ values are only sent when the diff is being printed.
data DiffLineType = 
      DiffLineTypeContext
    -- ^ line is part of the context.
    | DiffLineTypeAddition
    -- ^ line that was added.
    | DiffLineTypeDeletion
    -- ^ line that was removed.
    | DiffLineTypeContextEofnl
    -- ^ Both files have no LF at end.
    | DiffLineTypeAddEofnl
    -- ^ LF was added at end of file.
    | DiffLineTypeDelEofnl
    -- ^ LF was removed at end of file.
    | DiffLineTypeFileHdr
    -- ^ the file header.
    | DiffLineTypeHunkHdr
    -- ^ the hunk header.
    | DiffLineTypeBinary
    -- ^ is binary.
    | AnotherDiffLineType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DiffLineType -> ShowS
[DiffLineType] -> ShowS
DiffLineType -> String
(Int -> DiffLineType -> ShowS)
-> (DiffLineType -> String)
-> ([DiffLineType] -> ShowS)
-> Show DiffLineType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffLineType -> ShowS
showsPrec :: Int -> DiffLineType -> ShowS
$cshow :: DiffLineType -> String
show :: DiffLineType -> String
$cshowList :: [DiffLineType] -> ShowS
showList :: [DiffLineType] -> ShowS
Show, DiffLineType -> DiffLineType -> Bool
(DiffLineType -> DiffLineType -> Bool)
-> (DiffLineType -> DiffLineType -> Bool) -> Eq DiffLineType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffLineType -> DiffLineType -> Bool
== :: DiffLineType -> DiffLineType -> Bool
$c/= :: DiffLineType -> DiffLineType -> Bool
/= :: DiffLineType -> DiffLineType -> Bool
Eq)

instance P.Enum DiffLineType where
    fromEnum :: DiffLineType -> Int
fromEnum DiffLineType
DiffLineTypeContext = Int
32
    fromEnum DiffLineType
DiffLineTypeAddition = Int
43
    fromEnum DiffLineType
DiffLineTypeDeletion = Int
45
    fromEnum DiffLineType
DiffLineTypeContextEofnl = Int
61
    fromEnum DiffLineType
DiffLineTypeAddEofnl = Int
62
    fromEnum DiffLineType
DiffLineTypeDelEofnl = Int
60
    fromEnum DiffLineType
DiffLineTypeFileHdr = Int
70
    fromEnum DiffLineType
DiffLineTypeHunkHdr = Int
72
    fromEnum DiffLineType
DiffLineTypeBinary = Int
66
    fromEnum (AnotherDiffLineType Int
k) = Int
k

    toEnum :: Int -> DiffLineType
toEnum Int
32 = DiffLineType
DiffLineTypeContext
    toEnum Int
43 = DiffLineType
DiffLineTypeAddition
    toEnum Int
45 = DiffLineType
DiffLineTypeDeletion
    toEnum Int
61 = DiffLineType
DiffLineTypeContextEofnl
    toEnum Int
62 = DiffLineType
DiffLineTypeAddEofnl
    toEnum Int
60 = DiffLineType
DiffLineTypeDelEofnl
    toEnum Int
70 = DiffLineType
DiffLineTypeFileHdr
    toEnum Int
72 = DiffLineType
DiffLineTypeHunkHdr
    toEnum Int
66 = DiffLineType
DiffLineTypeBinary
    toEnum Int
k = Int -> DiffLineType
AnotherDiffLineType Int
k

instance P.Ord DiffLineType where
    compare :: DiffLineType -> DiffLineType -> Ordering
compare DiffLineType
a DiffLineType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffLineType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffLineType
a) (DiffLineType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffLineType
b)

type instance O.ParentTypes DiffLineType = '[]
instance O.HasParentTypes DiffLineType

foreign import ccall "ggit_diff_line_type_get_type" c_ggit_diff_line_type_get_type :: 
    IO GType

instance B.Types.TypedObject DiffLineType where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_line_type_get_type

instance B.Types.BoxedEnum DiffLineType

-- Enum DiffFormatType
-- | Possible output formats for diff data.
data DiffFormatType = 
      DiffFormatTypePatch
    -- ^ full git diff.
    | DiffFormatTypePatchHeader
    -- ^ just the file headers of patch.
    | DiffFormatTypeRaw
    -- ^ like git diff --raw.
    | DiffFormatTypeNameOnly
    -- ^ like git diff --name-only.
    | DiffFormatTypeNameStatus
    -- ^ like git diff --name-status.
    | AnotherDiffFormatType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DiffFormatType -> ShowS
[DiffFormatType] -> ShowS
DiffFormatType -> String
(Int -> DiffFormatType -> ShowS)
-> (DiffFormatType -> String)
-> ([DiffFormatType] -> ShowS)
-> Show DiffFormatType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffFormatType -> ShowS
showsPrec :: Int -> DiffFormatType -> ShowS
$cshow :: DiffFormatType -> String
show :: DiffFormatType -> String
$cshowList :: [DiffFormatType] -> ShowS
showList :: [DiffFormatType] -> ShowS
Show, DiffFormatType -> DiffFormatType -> Bool
(DiffFormatType -> DiffFormatType -> Bool)
-> (DiffFormatType -> DiffFormatType -> Bool) -> Eq DiffFormatType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffFormatType -> DiffFormatType -> Bool
== :: DiffFormatType -> DiffFormatType -> Bool
$c/= :: DiffFormatType -> DiffFormatType -> Bool
/= :: DiffFormatType -> DiffFormatType -> Bool
Eq)

instance P.Enum DiffFormatType where
    fromEnum :: DiffFormatType -> Int
fromEnum DiffFormatType
DiffFormatTypePatch = Int
1
    fromEnum DiffFormatType
DiffFormatTypePatchHeader = Int
2
    fromEnum DiffFormatType
DiffFormatTypeRaw = Int
3
    fromEnum DiffFormatType
DiffFormatTypeNameOnly = Int
4
    fromEnum DiffFormatType
DiffFormatTypeNameStatus = Int
5
    fromEnum (AnotherDiffFormatType Int
k) = Int
k

    toEnum :: Int -> DiffFormatType
toEnum Int
1 = DiffFormatType
DiffFormatTypePatch
    toEnum Int
2 = DiffFormatType
DiffFormatTypePatchHeader
    toEnum Int
3 = DiffFormatType
DiffFormatTypeRaw
    toEnum Int
4 = DiffFormatType
DiffFormatTypeNameOnly
    toEnum Int
5 = DiffFormatType
DiffFormatTypeNameStatus
    toEnum Int
k = Int -> DiffFormatType
AnotherDiffFormatType Int
k

instance P.Ord DiffFormatType where
    compare :: DiffFormatType -> DiffFormatType -> Ordering
compare DiffFormatType
a DiffFormatType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffFormatType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFormatType
a) (DiffFormatType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffFormatType
b)

type instance O.ParentTypes DiffFormatType = '[]
instance O.HasParentTypes DiffFormatType

foreign import ccall "ggit_diff_format_type_get_type" c_ggit_diff_format_type_get_type :: 
    IO GType

instance B.Types.TypedObject DiffFormatType where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_format_type_get_type

instance B.Types.BoxedEnum DiffFormatType

-- Enum DiffBinaryType
-- | 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 = 
      DiffBinaryTypeNone
    -- ^ /No description available in the introspection data./
    | DiffBinaryTypeLiteral
    -- ^ /No description available in the introspection data./
    | DiffBinaryTypeDelta
    -- ^ /No description available in the introspection data./
    | AnotherDiffBinaryType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DiffBinaryType -> ShowS
[DiffBinaryType] -> ShowS
DiffBinaryType -> String
(Int -> DiffBinaryType -> ShowS)
-> (DiffBinaryType -> String)
-> ([DiffBinaryType] -> ShowS)
-> Show DiffBinaryType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffBinaryType -> ShowS
showsPrec :: Int -> DiffBinaryType -> ShowS
$cshow :: DiffBinaryType -> String
show :: DiffBinaryType -> String
$cshowList :: [DiffBinaryType] -> ShowS
showList :: [DiffBinaryType] -> ShowS
Show, DiffBinaryType -> DiffBinaryType -> Bool
(DiffBinaryType -> DiffBinaryType -> Bool)
-> (DiffBinaryType -> DiffBinaryType -> Bool) -> Eq DiffBinaryType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffBinaryType -> DiffBinaryType -> Bool
== :: DiffBinaryType -> DiffBinaryType -> Bool
$c/= :: DiffBinaryType -> DiffBinaryType -> Bool
/= :: DiffBinaryType -> DiffBinaryType -> Bool
Eq)

instance P.Enum DiffBinaryType where
    fromEnum :: DiffBinaryType -> Int
fromEnum DiffBinaryType
DiffBinaryTypeNone = Int
0
    fromEnum DiffBinaryType
DiffBinaryTypeLiteral = Int
1
    fromEnum DiffBinaryType
DiffBinaryTypeDelta = Int
2
    fromEnum (AnotherDiffBinaryType Int
k) = Int
k

    toEnum :: Int -> DiffBinaryType
toEnum Int
0 = DiffBinaryType
DiffBinaryTypeNone
    toEnum Int
1 = DiffBinaryType
DiffBinaryTypeLiteral
    toEnum Int
2 = DiffBinaryType
DiffBinaryTypeDelta
    toEnum Int
k = Int -> DiffBinaryType
AnotherDiffBinaryType Int
k

instance P.Ord DiffBinaryType where
    compare :: DiffBinaryType -> DiffBinaryType -> Ordering
compare DiffBinaryType
a DiffBinaryType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DiffBinaryType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffBinaryType
a) (DiffBinaryType -> Int
forall a. Enum a => a -> Int
P.fromEnum DiffBinaryType
b)

type instance O.ParentTypes DiffBinaryType = '[]
instance O.HasParentTypes DiffBinaryType

foreign import ccall "ggit_diff_binary_type_get_type" c_ggit_diff_binary_type_get_type :: 
    IO GType

instance B.Types.TypedObject DiffBinaryType where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_binary_type_get_type

instance B.Types.BoxedEnum DiffBinaryType

-- Enum DeltaType
-- | Describes the type of change the delta is.
data DeltaType = 
      DeltaTypeUnmodified
    -- ^ unmodified.
    | DeltaTypeAdded
    -- ^ added.
    | DeltaTypeDeleted
    -- ^ deleted.
    | DeltaTypeModified
    -- ^ modified.
    | DeltaTypeRenamed
    -- ^ renamed.
    | DeltaTypeCopied
    -- ^ copied.
    | DeltaTypeIgnored
    -- ^ ignored.
    | DeltaTypeUntracked
    -- ^ untracked.
    | DeltaTypeTypechange
    -- ^ /No description available in the introspection data./
    | DeltaTypeUnreadable
    -- ^ /No description available in the introspection data./
    | DeltaTypeConflicted
    -- ^ /No description available in the introspection data./
    | AnotherDeltaType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeltaType -> ShowS
[DeltaType] -> ShowS
DeltaType -> String
(Int -> DeltaType -> ShowS)
-> (DeltaType -> String)
-> ([DeltaType] -> ShowS)
-> Show DeltaType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeltaType -> ShowS
showsPrec :: Int -> DeltaType -> ShowS
$cshow :: DeltaType -> String
show :: DeltaType -> String
$cshowList :: [DeltaType] -> ShowS
showList :: [DeltaType] -> ShowS
Show, DeltaType -> DeltaType -> Bool
(DeltaType -> DeltaType -> Bool)
-> (DeltaType -> DeltaType -> Bool) -> Eq DeltaType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeltaType -> DeltaType -> Bool
== :: DeltaType -> DeltaType -> Bool
$c/= :: DeltaType -> DeltaType -> Bool
/= :: DeltaType -> DeltaType -> Bool
Eq)

instance P.Enum DeltaType where
    fromEnum :: DeltaType -> Int
fromEnum DeltaType
DeltaTypeUnmodified = Int
0
    fromEnum DeltaType
DeltaTypeAdded = Int
1
    fromEnum DeltaType
DeltaTypeDeleted = Int
2
    fromEnum DeltaType
DeltaTypeModified = Int
3
    fromEnum DeltaType
DeltaTypeRenamed = Int
4
    fromEnum DeltaType
DeltaTypeCopied = Int
5
    fromEnum DeltaType
DeltaTypeIgnored = Int
6
    fromEnum DeltaType
DeltaTypeUntracked = Int
7
    fromEnum DeltaType
DeltaTypeTypechange = Int
8
    fromEnum DeltaType
DeltaTypeUnreadable = Int
9
    fromEnum DeltaType
DeltaTypeConflicted = Int
10
    fromEnum (AnotherDeltaType Int
k) = Int
k

    toEnum :: Int -> DeltaType
toEnum Int
0 = DeltaType
DeltaTypeUnmodified
    toEnum Int
1 = DeltaType
DeltaTypeAdded
    toEnum Int
2 = DeltaType
DeltaTypeDeleted
    toEnum Int
3 = DeltaType
DeltaTypeModified
    toEnum Int
4 = DeltaType
DeltaTypeRenamed
    toEnum Int
5 = DeltaType
DeltaTypeCopied
    toEnum Int
6 = DeltaType
DeltaTypeIgnored
    toEnum Int
7 = DeltaType
DeltaTypeUntracked
    toEnum Int
8 = DeltaType
DeltaTypeTypechange
    toEnum Int
9 = DeltaType
DeltaTypeUnreadable
    toEnum Int
10 = DeltaType
DeltaTypeConflicted
    toEnum Int
k = Int -> DeltaType
AnotherDeltaType Int
k

instance P.Ord DeltaType where
    compare :: DeltaType -> DeltaType -> Ordering
compare DeltaType
a DeltaType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeltaType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeltaType
a) (DeltaType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeltaType
b)

type instance O.ParentTypes DeltaType = '[]
instance O.HasParentTypes DeltaType

foreign import ccall "ggit_delta_type_get_type" c_ggit_delta_type_get_type :: 
    IO GType

instance B.Types.TypedObject DeltaType where
    glibType :: IO GType
glibType = IO GType
c_ggit_delta_type_get_type

instance B.Types.BoxedEnum DeltaType

-- Enum ConfigLevel
-- | 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 = 
      ConfigLevelProgramdata
    -- ^ System-wide on Windows, for compatibility with portable git.
    | ConfigLevelSystem
    -- ^ System-wide configuration file.
    | ConfigLevelXdg
    -- ^ XDG compatible configuration file (.config\/git\/config).
    | ConfigLevelGlobal
    -- ^ User-specific configuration file, also called Global configuration file.
    | ConfigLevelLocal
    -- ^ Repository specific configuration file.
    | ConfigLevelApp
    -- ^ Application specific configuration file; freely defined by applications.
    | ConfigLevelHighest
    -- ^ Represents the highest level of a config file.
    | AnotherConfigLevel Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConfigLevel -> ShowS
[ConfigLevel] -> ShowS
ConfigLevel -> String
(Int -> ConfigLevel -> ShowS)
-> (ConfigLevel -> String)
-> ([ConfigLevel] -> ShowS)
-> Show ConfigLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConfigLevel -> ShowS
showsPrec :: Int -> ConfigLevel -> ShowS
$cshow :: ConfigLevel -> String
show :: ConfigLevel -> String
$cshowList :: [ConfigLevel] -> ShowS
showList :: [ConfigLevel] -> ShowS
Show, ConfigLevel -> ConfigLevel -> Bool
(ConfigLevel -> ConfigLevel -> Bool)
-> (ConfigLevel -> ConfigLevel -> Bool) -> Eq ConfigLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConfigLevel -> ConfigLevel -> Bool
== :: ConfigLevel -> ConfigLevel -> Bool
$c/= :: ConfigLevel -> ConfigLevel -> Bool
/= :: ConfigLevel -> ConfigLevel -> Bool
Eq)

instance P.Enum ConfigLevel where
    fromEnum :: ConfigLevel -> Int
fromEnum ConfigLevel
ConfigLevelProgramdata = Int
1
    fromEnum ConfigLevel
ConfigLevelSystem = Int
2
    fromEnum ConfigLevel
ConfigLevelXdg = Int
3
    fromEnum ConfigLevel
ConfigLevelGlobal = Int
4
    fromEnum ConfigLevel
ConfigLevelLocal = Int
5
    fromEnum ConfigLevel
ConfigLevelApp = Int
6
    fromEnum ConfigLevel
ConfigLevelHighest = Int
-1
    fromEnum (AnotherConfigLevel Int
k) = Int
k

    toEnum :: Int -> ConfigLevel
toEnum Int
1 = ConfigLevel
ConfigLevelProgramdata
    toEnum Int
2 = ConfigLevel
ConfigLevelSystem
    toEnum Int
3 = ConfigLevel
ConfigLevelXdg
    toEnum Int
4 = ConfigLevel
ConfigLevelGlobal
    toEnum Int
5 = ConfigLevel
ConfigLevelLocal
    toEnum Int
6 = ConfigLevel
ConfigLevelApp
    toEnum Int
-1 = ConfigLevel
ConfigLevelHighest
    toEnum Int
k = Int -> ConfigLevel
AnotherConfigLevel Int
k

instance P.Ord ConfigLevel where
    compare :: ConfigLevel -> ConfigLevel -> Ordering
compare ConfigLevel
a ConfigLevel
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConfigLevel -> Int
forall a. Enum a => a -> Int
P.fromEnum ConfigLevel
a) (ConfigLevel -> Int
forall a. Enum a => a -> Int
P.fromEnum ConfigLevel
b)

type instance O.ParentTypes ConfigLevel = '[]
instance O.HasParentTypes ConfigLevel

foreign import ccall "ggit_config_level_get_type" c_ggit_config_level_get_type :: 
    IO GType

instance B.Types.TypedObject ConfigLevel where
    glibType :: IO GType
glibType = IO GType
c_ggit_config_level_get_type

instance B.Types.BoxedEnum ConfigLevel

-- Enum CloneLocal
-- | /No description available in the introspection data./
data CloneLocal = 
      CloneLocalAuto
    -- ^ /No description available in the introspection data./
    | CloneLocalLocal
    -- ^ /No description available in the introspection data./
    | CloneLocalNoLocal
    -- ^ /No description available in the introspection data./
    | CloneLocalNoLinks
    -- ^ /No description available in the introspection data./
    | AnotherCloneLocal Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CloneLocal -> ShowS
[CloneLocal] -> ShowS
CloneLocal -> String
(Int -> CloneLocal -> ShowS)
-> (CloneLocal -> String)
-> ([CloneLocal] -> ShowS)
-> Show CloneLocal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CloneLocal -> ShowS
showsPrec :: Int -> CloneLocal -> ShowS
$cshow :: CloneLocal -> String
show :: CloneLocal -> String
$cshowList :: [CloneLocal] -> ShowS
showList :: [CloneLocal] -> ShowS
Show, CloneLocal -> CloneLocal -> Bool
(CloneLocal -> CloneLocal -> Bool)
-> (CloneLocal -> CloneLocal -> Bool) -> Eq CloneLocal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CloneLocal -> CloneLocal -> Bool
== :: CloneLocal -> CloneLocal -> Bool
$c/= :: CloneLocal -> CloneLocal -> Bool
/= :: CloneLocal -> CloneLocal -> Bool
Eq)

instance P.Enum CloneLocal where
    fromEnum :: CloneLocal -> Int
fromEnum CloneLocal
CloneLocalAuto = Int
0
    fromEnum CloneLocal
CloneLocalLocal = Int
1
    fromEnum CloneLocal
CloneLocalNoLocal = Int
2
    fromEnum CloneLocal
CloneLocalNoLinks = Int
3
    fromEnum (AnotherCloneLocal Int
k) = Int
k

    toEnum :: Int -> CloneLocal
toEnum Int
0 = CloneLocal
CloneLocalAuto
    toEnum Int
1 = CloneLocal
CloneLocalLocal
    toEnum Int
2 = CloneLocal
CloneLocalNoLocal
    toEnum Int
3 = CloneLocal
CloneLocalNoLinks
    toEnum Int
k = Int -> CloneLocal
AnotherCloneLocal Int
k

instance P.Ord CloneLocal where
    compare :: CloneLocal -> CloneLocal -> Ordering
compare CloneLocal
a CloneLocal
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CloneLocal -> Int
forall a. Enum a => a -> Int
P.fromEnum CloneLocal
a) (CloneLocal -> Int
forall a. Enum a => a -> Int
P.fromEnum CloneLocal
b)

type instance O.ParentTypes CloneLocal = '[]
instance O.HasParentTypes CloneLocal

foreign import ccall "ggit_clone_local_get_type" c_ggit_clone_local_get_type :: 
    IO GType

instance B.Types.TypedObject CloneLocal where
    glibType :: IO GType
glibType = IO GType
c_ggit_clone_local_get_type

instance B.Types.BoxedEnum CloneLocal

-- Enum BranchType
-- | The type of a branch.
data BranchType = 
      BranchTypeLocal
    -- ^ specifies a local branch.
    | BranchTypeRemote
    -- ^ specifies a remote branch.
    | AnotherBranchType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BranchType -> ShowS
[BranchType] -> ShowS
BranchType -> String
(Int -> BranchType -> ShowS)
-> (BranchType -> String)
-> ([BranchType] -> ShowS)
-> Show BranchType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BranchType -> ShowS
showsPrec :: Int -> BranchType -> ShowS
$cshow :: BranchType -> String
show :: BranchType -> String
$cshowList :: [BranchType] -> ShowS
showList :: [BranchType] -> ShowS
Show, BranchType -> BranchType -> Bool
(BranchType -> BranchType -> Bool)
-> (BranchType -> BranchType -> Bool) -> Eq BranchType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BranchType -> BranchType -> Bool
== :: BranchType -> BranchType -> Bool
$c/= :: BranchType -> BranchType -> Bool
/= :: BranchType -> BranchType -> Bool
Eq)

instance P.Enum BranchType where
    fromEnum :: BranchType -> Int
fromEnum BranchType
BranchTypeLocal = Int
1
    fromEnum BranchType
BranchTypeRemote = Int
2
    fromEnum (AnotherBranchType Int
k) = Int
k

    toEnum :: Int -> BranchType
toEnum Int
1 = BranchType
BranchTypeLocal
    toEnum Int
2 = BranchType
BranchTypeRemote
    toEnum Int
k = Int -> BranchType
AnotherBranchType Int
k

instance P.Ord BranchType where
    compare :: BranchType -> BranchType -> Ordering
compare BranchType
a BranchType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BranchType -> Int
forall a. Enum a => a -> Int
P.fromEnum BranchType
a) (BranchType -> Int
forall a. Enum a => a -> Int
P.fromEnum BranchType
b)

type instance O.ParentTypes BranchType = '[]
instance O.HasParentTypes BranchType

foreign import ccall "ggit_branch_type_get_type" c_ggit_branch_type_get_type :: 
    IO GType

instance B.Types.TypedObject BranchType where
    glibType :: IO GType
glibType = IO GType
c_ggit_branch_type_get_type

instance B.Types.BoxedEnum BranchType