-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 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


-- 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
showList :: [TreeWalkMode] -> ShowS
$cshowList :: [TreeWalkMode] -> ShowS
show :: TreeWalkMode -> String
$cshow :: TreeWalkMode -> String
showsPrec :: Int -> TreeWalkMode -> ShowS
$cshowsPrec :: Int -> TreeWalkMode -> ShowS
Show, TreeWalkMode -> TreeWalkMode -> Bool
(TreeWalkMode -> TreeWalkMode -> Bool)
-> (TreeWalkMode -> TreeWalkMode -> Bool) -> Eq TreeWalkMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeWalkMode -> TreeWalkMode -> Bool
$c/= :: TreeWalkMode -> TreeWalkMode -> Bool
== :: TreeWalkMode -> TreeWalkMode -> Bool
$c== :: TreeWalkMode -> TreeWalkMode -> Bool
Eq)

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

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

instance P.Ord TreeWalkMode where
    compare :: TreeWalkMode -> TreeWalkMode -> Ordering
compare a :: TreeWalkMode
a b :: 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)

foreign import ccall "ggit_tree_walk_mode_get_type" c_ggit_tree_walk_mode_get_type :: 
    IO GType

instance BoxedEnum TreeWalkMode where
    boxedEnumType :: TreeWalkMode -> IO GType
boxedEnumType _ = IO GType
c_ggit_tree_walk_mode_get_type

-- 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
showList :: [SubmoduleUpdate] -> ShowS
$cshowList :: [SubmoduleUpdate] -> ShowS
show :: SubmoduleUpdate -> String
$cshow :: SubmoduleUpdate -> String
showsPrec :: Int -> SubmoduleUpdate -> ShowS
$cshowsPrec :: Int -> SubmoduleUpdate -> ShowS
Show, SubmoduleUpdate -> SubmoduleUpdate -> Bool
(SubmoduleUpdate -> SubmoduleUpdate -> Bool)
-> (SubmoduleUpdate -> SubmoduleUpdate -> Bool)
-> Eq SubmoduleUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
$c/= :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
== :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
$c== :: SubmoduleUpdate -> SubmoduleUpdate -> Bool
Eq)

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

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

instance P.Ord SubmoduleUpdate where
    compare :: SubmoduleUpdate -> SubmoduleUpdate -> Ordering
compare a :: SubmoduleUpdate
a b :: 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)

foreign import ccall "ggit_submodule_update_get_type" c_ggit_submodule_update_get_type :: 
    IO GType

instance BoxedEnum SubmoduleUpdate where
    boxedEnumType :: SubmoduleUpdate -> IO GType
boxedEnumType _ = IO GType
c_ggit_submodule_update_get_type

-- 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
showList :: [SubmoduleRecurse] -> ShowS
$cshowList :: [SubmoduleRecurse] -> ShowS
show :: SubmoduleRecurse -> String
$cshow :: SubmoduleRecurse -> String
showsPrec :: Int -> SubmoduleRecurse -> ShowS
$cshowsPrec :: Int -> SubmoduleRecurse -> ShowS
Show, SubmoduleRecurse -> SubmoduleRecurse -> Bool
(SubmoduleRecurse -> SubmoduleRecurse -> Bool)
-> (SubmoduleRecurse -> SubmoduleRecurse -> Bool)
-> Eq SubmoduleRecurse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
$c/= :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
== :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
$c== :: SubmoduleRecurse -> SubmoduleRecurse -> Bool
Eq)

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

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

instance P.Ord SubmoduleRecurse where
    compare :: SubmoduleRecurse -> SubmoduleRecurse -> Ordering
compare a :: SubmoduleRecurse
a b :: 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)

foreign import ccall "ggit_submodule_recurse_get_type" c_ggit_submodule_recurse_get_type :: 
    IO GType

instance BoxedEnum SubmoduleRecurse where
    boxedEnumType :: SubmoduleRecurse -> IO GType
boxedEnumType _ = IO GType
c_ggit_submodule_recurse_get_type

-- 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
showList :: [SubmoduleIgnore] -> ShowS
$cshowList :: [SubmoduleIgnore] -> ShowS
show :: SubmoduleIgnore -> String
$cshow :: SubmoduleIgnore -> String
showsPrec :: Int -> SubmoduleIgnore -> ShowS
$cshowsPrec :: Int -> SubmoduleIgnore -> ShowS
Show, SubmoduleIgnore -> SubmoduleIgnore -> Bool
(SubmoduleIgnore -> SubmoduleIgnore -> Bool)
-> (SubmoduleIgnore -> SubmoduleIgnore -> Bool)
-> Eq SubmoduleIgnore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
$c/= :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
== :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
$c== :: SubmoduleIgnore -> SubmoduleIgnore -> Bool
Eq)

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

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

instance P.Ord SubmoduleIgnore where
    compare :: SubmoduleIgnore -> SubmoduleIgnore -> Ordering
compare a :: SubmoduleIgnore
a b :: 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)

foreign import ccall "ggit_submodule_ignore_get_type" c_ggit_submodule_ignore_get_type :: 
    IO GType

instance BoxedEnum SubmoduleIgnore where
    boxedEnumType :: SubmoduleIgnore -> IO GType
boxedEnumType _ = IO GType
c_ggit_submodule_ignore_get_type

-- 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
showList :: [StatusShow] -> ShowS
$cshowList :: [StatusShow] -> ShowS
show :: StatusShow -> String
$cshow :: StatusShow -> String
showsPrec :: Int -> StatusShow -> ShowS
$cshowsPrec :: Int -> StatusShow -> ShowS
Show, StatusShow -> StatusShow -> Bool
(StatusShow -> StatusShow -> Bool)
-> (StatusShow -> StatusShow -> Bool) -> Eq StatusShow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StatusShow -> StatusShow -> Bool
$c/= :: StatusShow -> StatusShow -> Bool
== :: StatusShow -> StatusShow -> Bool
$c== :: StatusShow -> StatusShow -> Bool
Eq)

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

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

instance P.Ord StatusShow where
    compare :: StatusShow -> StatusShow -> Ordering
compare a :: StatusShow
a b :: 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)

foreign import ccall "ggit_status_show_get_type" c_ggit_status_show_get_type :: 
    IO GType

instance BoxedEnum StatusShow where
    boxedEnumType :: StatusShow -> IO GType
boxedEnumType _ = IO GType
c_ggit_status_show_get_type

-- 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
showList :: [ResetType] -> ShowS
$cshowList :: [ResetType] -> ShowS
show :: ResetType -> String
$cshow :: ResetType -> String
showsPrec :: Int -> ResetType -> ShowS
$cshowsPrec :: Int -> ResetType -> ShowS
Show, ResetType -> ResetType -> Bool
(ResetType -> ResetType -> Bool)
-> (ResetType -> ResetType -> Bool) -> Eq ResetType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResetType -> ResetType -> Bool
$c/= :: ResetType -> ResetType -> Bool
== :: ResetType -> ResetType -> Bool
$c== :: ResetType -> ResetType -> Bool
Eq)

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

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

instance P.Ord ResetType where
    compare :: ResetType -> ResetType -> Ordering
compare a :: ResetType
a b :: 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)

foreign import ccall "ggit_reset_type_get_type" c_ggit_reset_type_get_type :: 
    IO GType

instance BoxedEnum ResetType where
    boxedEnumType :: ResetType -> IO GType
boxedEnumType _ = IO GType
c_ggit_reset_type_get_type

-- 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
showList :: [RemoteDownloadTagsType] -> ShowS
$cshowList :: [RemoteDownloadTagsType] -> ShowS
show :: RemoteDownloadTagsType -> String
$cshow :: RemoteDownloadTagsType -> String
showsPrec :: Int -> RemoteDownloadTagsType -> ShowS
$cshowsPrec :: Int -> RemoteDownloadTagsType -> ShowS
Show, RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
(RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool)
-> (RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool)
-> Eq RemoteDownloadTagsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
$c/= :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
== :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
$c== :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Bool
Eq)

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

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

instance P.Ord RemoteDownloadTagsType where
    compare :: RemoteDownloadTagsType -> RemoteDownloadTagsType -> Ordering
compare a :: RemoteDownloadTagsType
a b :: 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)

foreign import ccall "ggit_remote_download_tags_type_get_type" c_ggit_remote_download_tags_type_get_type :: 
    IO GType

instance BoxedEnum RemoteDownloadTagsType where
    boxedEnumType :: RemoteDownloadTagsType -> IO GType
boxedEnumType _ = IO GType
c_ggit_remote_download_tags_type_get_type

-- 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
showList :: [RemoteCompletionType] -> ShowS
$cshowList :: [RemoteCompletionType] -> ShowS
show :: RemoteCompletionType -> String
$cshow :: RemoteCompletionType -> String
showsPrec :: Int -> RemoteCompletionType -> ShowS
$cshowsPrec :: Int -> RemoteCompletionType -> ShowS
Show, RemoteCompletionType -> RemoteCompletionType -> Bool
(RemoteCompletionType -> RemoteCompletionType -> Bool)
-> (RemoteCompletionType -> RemoteCompletionType -> Bool)
-> Eq RemoteCompletionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoteCompletionType -> RemoteCompletionType -> Bool
$c/= :: RemoteCompletionType -> RemoteCompletionType -> Bool
== :: RemoteCompletionType -> RemoteCompletionType -> Bool
$c== :: RemoteCompletionType -> RemoteCompletionType -> Bool
Eq)

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

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

instance P.Ord RemoteCompletionType where
    compare :: RemoteCompletionType -> RemoteCompletionType -> Ordering
compare a :: RemoteCompletionType
a b :: 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)

foreign import ccall "ggit_remote_completion_type_get_type" c_ggit_remote_completion_type_get_type :: 
    IO GType

instance BoxedEnum RemoteCompletionType where
    boxedEnumType :: RemoteCompletionType -> IO GType
boxedEnumType _ = IO GType
c_ggit_remote_completion_type_get_type

-- 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
showList :: [RefType] -> ShowS
$cshowList :: [RefType] -> ShowS
show :: RefType -> String
$cshow :: RefType -> String
showsPrec :: Int -> RefType -> ShowS
$cshowsPrec :: Int -> RefType -> ShowS
Show, RefType -> RefType -> Bool
(RefType -> RefType -> Bool)
-> (RefType -> RefType -> Bool) -> Eq RefType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RefType -> RefType -> Bool
$c/= :: RefType -> RefType -> Bool
== :: RefType -> RefType -> Bool
$c== :: RefType -> RefType -> Bool
Eq)

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

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

instance P.Ord RefType where
    compare :: RefType -> RefType -> Ordering
compare a :: RefType
a b :: 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)

foreign import ccall "ggit_ref_type_get_type" c_ggit_ref_type_get_type :: 
    IO GType

instance BoxedEnum RefType where
    boxedEnumType :: RefType -> IO GType
boxedEnumType _ = IO GType
c_ggit_ref_type_get_type

-- 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
showList :: [RebaseOperationType] -> ShowS
$cshowList :: [RebaseOperationType] -> ShowS
show :: RebaseOperationType -> String
$cshow :: RebaseOperationType -> String
showsPrec :: Int -> RebaseOperationType -> ShowS
$cshowsPrec :: Int -> RebaseOperationType -> ShowS
Show, RebaseOperationType -> RebaseOperationType -> Bool
(RebaseOperationType -> RebaseOperationType -> Bool)
-> (RebaseOperationType -> RebaseOperationType -> Bool)
-> Eq RebaseOperationType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RebaseOperationType -> RebaseOperationType -> Bool
$c/= :: RebaseOperationType -> RebaseOperationType -> Bool
== :: RebaseOperationType -> RebaseOperationType -> Bool
$c== :: RebaseOperationType -> RebaseOperationType -> Bool
Eq)

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

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

instance P.Ord RebaseOperationType where
    compare :: RebaseOperationType -> RebaseOperationType -> Ordering
compare a :: RebaseOperationType
a b :: 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)

foreign import ccall "ggit_rebase_operation_type_get_type" c_ggit_rebase_operation_type_get_type :: 
    IO GType

instance BoxedEnum RebaseOperationType where
    boxedEnumType :: RebaseOperationType -> IO GType
boxedEnumType _ = IO GType
c_ggit_rebase_operation_type_get_type

-- 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
showList :: [ProxyType] -> ShowS
$cshowList :: [ProxyType] -> ShowS
show :: ProxyType -> String
$cshow :: ProxyType -> String
showsPrec :: Int -> ProxyType -> ShowS
$cshowsPrec :: Int -> ProxyType -> ShowS
Show, ProxyType -> ProxyType -> Bool
(ProxyType -> ProxyType -> Bool)
-> (ProxyType -> ProxyType -> Bool) -> Eq ProxyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProxyType -> ProxyType -> Bool
$c/= :: ProxyType -> ProxyType -> Bool
== :: ProxyType -> ProxyType -> Bool
$c== :: ProxyType -> ProxyType -> Bool
Eq)

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

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

instance P.Ord ProxyType where
    compare :: ProxyType -> ProxyType -> Ordering
compare a :: ProxyType
a b :: 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)

foreign import ccall "ggit_proxy_type_get_type" c_ggit_proxy_type_get_type :: 
    IO GType

instance BoxedEnum ProxyType where
    boxedEnumType :: ProxyType -> IO GType
boxedEnumType _ = IO GType
c_ggit_proxy_type_get_type

-- 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
showList :: [PackbuilderStage] -> ShowS
$cshowList :: [PackbuilderStage] -> ShowS
show :: PackbuilderStage -> String
$cshow :: PackbuilderStage -> String
showsPrec :: Int -> PackbuilderStage -> ShowS
$cshowsPrec :: Int -> PackbuilderStage -> ShowS
Show, PackbuilderStage -> PackbuilderStage -> Bool
(PackbuilderStage -> PackbuilderStage -> Bool)
-> (PackbuilderStage -> PackbuilderStage -> Bool)
-> Eq PackbuilderStage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackbuilderStage -> PackbuilderStage -> Bool
$c/= :: PackbuilderStage -> PackbuilderStage -> Bool
== :: PackbuilderStage -> PackbuilderStage -> Bool
$c== :: PackbuilderStage -> PackbuilderStage -> Bool
Eq)

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

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

instance P.Ord PackbuilderStage where
    compare :: PackbuilderStage -> PackbuilderStage -> Ordering
compare a :: PackbuilderStage
a b :: 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)

foreign import ccall "ggit_packbuilder_stage_get_type" c_ggit_packbuilder_stage_get_type :: 
    IO GType

instance BoxedEnum PackbuilderStage where
    boxedEnumType :: PackbuilderStage -> IO GType
boxedEnumType _ = IO GType
c_ggit_packbuilder_stage_get_type

-- 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
showList :: [MergeFileFavor] -> ShowS
$cshowList :: [MergeFileFavor] -> ShowS
show :: MergeFileFavor -> String
$cshow :: MergeFileFavor -> String
showsPrec :: Int -> MergeFileFavor -> ShowS
$cshowsPrec :: Int -> MergeFileFavor -> ShowS
Show, MergeFileFavor -> MergeFileFavor -> Bool
(MergeFileFavor -> MergeFileFavor -> Bool)
-> (MergeFileFavor -> MergeFileFavor -> Bool) -> Eq MergeFileFavor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MergeFileFavor -> MergeFileFavor -> Bool
$c/= :: MergeFileFavor -> MergeFileFavor -> Bool
== :: MergeFileFavor -> MergeFileFavor -> Bool
$c== :: MergeFileFavor -> MergeFileFavor -> Bool
Eq)

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

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

instance P.Ord MergeFileFavor where
    compare :: MergeFileFavor -> MergeFileFavor -> Ordering
compare a :: MergeFileFavor
a b :: 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)

foreign import ccall "ggit_merge_file_favor_get_type" c_ggit_merge_file_favor_get_type :: 
    IO GType

instance BoxedEnum MergeFileFavor where
    boxedEnumType :: MergeFileFavor -> IO GType
boxedEnumType _ = IO GType
c_ggit_merge_file_favor_get_type

-- 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
showList :: [FileMode] -> ShowS
$cshowList :: [FileMode] -> ShowS
show :: FileMode -> String
$cshow :: FileMode -> String
showsPrec :: Int -> FileMode -> ShowS
$cshowsPrec :: Int -> FileMode -> ShowS
Show, FileMode -> FileMode -> Bool
(FileMode -> FileMode -> Bool)
-> (FileMode -> FileMode -> Bool) -> Eq FileMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileMode -> FileMode -> Bool
$c/= :: FileMode -> FileMode -> Bool
== :: FileMode -> FileMode -> Bool
$c== :: FileMode -> FileMode -> Bool
Eq)

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

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

instance P.Ord FileMode where
    compare :: FileMode -> FileMode -> Ordering
compare a :: FileMode
a b :: 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)

foreign import ccall "ggit_file_mode_get_type" c_ggit_file_mode_get_type :: 
    IO GType

instance BoxedEnum FileMode where
    boxedEnumType :: FileMode -> IO GType
boxedEnumType _ = IO GType
c_ggit_file_mode_get_type

-- 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
showList :: [Error] -> ShowS
$cshowList :: [Error] -> ShowS
show :: Error -> String
$cshow :: Error -> String
showsPrec :: Int -> Error -> ShowS
$cshowsPrec :: Int -> Error -> ShowS
Show, Error -> Error -> Bool
(Error -> Error -> Bool) -> (Error -> Error -> Bool) -> Eq Error
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Error -> Error -> Bool
$c/= :: Error -> Error -> Bool
== :: Error -> Error -> Bool
$c== :: Error -> Error -> Bool
Eq)

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

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

instance P.Ord Error where
    compare :: Error -> Error -> Ordering
compare a :: Error
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "ggit_error_get_type" c_ggit_error_get_type :: 
    IO GType

instance BoxedEnum Error where
    boxedEnumType :: Error -> IO GType
boxedEnumType _ = IO GType
c_ggit_error_get_type

-- 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
showList :: [Direction] -> ShowS
$cshowList :: [Direction] -> ShowS
show :: Direction -> String
$cshow :: Direction -> String
showsPrec :: Int -> Direction -> ShowS
$cshowsPrec :: Int -> Direction -> ShowS
Show, Direction -> Direction -> Bool
(Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool) -> Eq Direction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c== :: Direction -> Direction -> Bool
Eq)

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

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

instance P.Ord Direction where
    compare :: Direction -> Direction -> Ordering
compare a :: Direction
a b :: 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)

foreign import ccall "ggit_direction_get_type" c_ggit_direction_get_type :: 
    IO GType

instance BoxedEnum Direction where
    boxedEnumType :: Direction -> IO GType
boxedEnumType _ = IO GType
c_ggit_direction_get_type

-- 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
showList :: [DiffLineType] -> ShowS
$cshowList :: [DiffLineType] -> ShowS
show :: DiffLineType -> String
$cshow :: DiffLineType -> String
showsPrec :: Int -> DiffLineType -> ShowS
$cshowsPrec :: Int -> DiffLineType -> ShowS
Show, DiffLineType -> DiffLineType -> Bool
(DiffLineType -> DiffLineType -> Bool)
-> (DiffLineType -> DiffLineType -> Bool) -> Eq DiffLineType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffLineType -> DiffLineType -> Bool
$c/= :: DiffLineType -> DiffLineType -> Bool
== :: DiffLineType -> DiffLineType -> Bool
$c== :: DiffLineType -> DiffLineType -> Bool
Eq)

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

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

instance P.Ord DiffLineType where
    compare :: DiffLineType -> DiffLineType -> Ordering
compare a :: DiffLineType
a b :: 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)

foreign import ccall "ggit_diff_line_type_get_type" c_ggit_diff_line_type_get_type :: 
    IO GType

instance BoxedEnum DiffLineType where
    boxedEnumType :: DiffLineType -> IO GType
boxedEnumType _ = IO GType
c_ggit_diff_line_type_get_type

-- 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
showList :: [DiffFormatType] -> ShowS
$cshowList :: [DiffFormatType] -> ShowS
show :: DiffFormatType -> String
$cshow :: DiffFormatType -> String
showsPrec :: Int -> DiffFormatType -> ShowS
$cshowsPrec :: Int -> DiffFormatType -> ShowS
Show, DiffFormatType -> DiffFormatType -> Bool
(DiffFormatType -> DiffFormatType -> Bool)
-> (DiffFormatType -> DiffFormatType -> Bool) -> Eq DiffFormatType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffFormatType -> DiffFormatType -> Bool
$c/= :: DiffFormatType -> DiffFormatType -> Bool
== :: DiffFormatType -> DiffFormatType -> Bool
$c== :: DiffFormatType -> DiffFormatType -> Bool
Eq)

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

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

instance P.Ord DiffFormatType where
    compare :: DiffFormatType -> DiffFormatType -> Ordering
compare a :: DiffFormatType
a b :: 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)

foreign import ccall "ggit_diff_format_type_get_type" c_ggit_diff_format_type_get_type :: 
    IO GType

instance BoxedEnum DiffFormatType where
    boxedEnumType :: DiffFormatType -> IO GType
boxedEnumType _ = IO GType
c_ggit_diff_format_type_get_type

-- 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
showList :: [DiffBinaryType] -> ShowS
$cshowList :: [DiffBinaryType] -> ShowS
show :: DiffBinaryType -> String
$cshow :: DiffBinaryType -> String
showsPrec :: Int -> DiffBinaryType -> ShowS
$cshowsPrec :: Int -> DiffBinaryType -> ShowS
Show, DiffBinaryType -> DiffBinaryType -> Bool
(DiffBinaryType -> DiffBinaryType -> Bool)
-> (DiffBinaryType -> DiffBinaryType -> Bool) -> Eq DiffBinaryType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DiffBinaryType -> DiffBinaryType -> Bool
$c/= :: DiffBinaryType -> DiffBinaryType -> Bool
== :: DiffBinaryType -> DiffBinaryType -> Bool
$c== :: DiffBinaryType -> DiffBinaryType -> Bool
Eq)

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

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

instance P.Ord DiffBinaryType where
    compare :: DiffBinaryType -> DiffBinaryType -> Ordering
compare a :: DiffBinaryType
a b :: 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)

foreign import ccall "ggit_diff_binary_type_get_type" c_ggit_diff_binary_type_get_type :: 
    IO GType

instance BoxedEnum DiffBinaryType where
    boxedEnumType :: DiffBinaryType -> IO GType
boxedEnumType _ = IO GType
c_ggit_diff_binary_type_get_type

-- 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.
    | 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
showList :: [DeltaType] -> ShowS
$cshowList :: [DeltaType] -> ShowS
show :: DeltaType -> String
$cshow :: DeltaType -> String
showsPrec :: Int -> DeltaType -> ShowS
$cshowsPrec :: Int -> DeltaType -> ShowS
Show, DeltaType -> DeltaType -> Bool
(DeltaType -> DeltaType -> Bool)
-> (DeltaType -> DeltaType -> Bool) -> Eq DeltaType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeltaType -> DeltaType -> Bool
$c/= :: DeltaType -> DeltaType -> Bool
== :: DeltaType -> DeltaType -> Bool
$c== :: DeltaType -> DeltaType -> Bool
Eq)

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

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

instance P.Ord DeltaType where
    compare :: DeltaType -> DeltaType -> Ordering
compare a :: DeltaType
a b :: 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)

foreign import ccall "ggit_delta_type_get_type" c_ggit_delta_type_get_type :: 
    IO GType

instance BoxedEnum DeltaType where
    boxedEnumType :: DeltaType -> IO GType
boxedEnumType _ = IO GType
c_ggit_delta_type_get_type

-- 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
showList :: [ConfigLevel] -> ShowS
$cshowList :: [ConfigLevel] -> ShowS
show :: ConfigLevel -> String
$cshow :: ConfigLevel -> String
showsPrec :: Int -> ConfigLevel -> ShowS
$cshowsPrec :: Int -> ConfigLevel -> ShowS
Show, ConfigLevel -> ConfigLevel -> Bool
(ConfigLevel -> ConfigLevel -> Bool)
-> (ConfigLevel -> ConfigLevel -> Bool) -> Eq ConfigLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConfigLevel -> ConfigLevel -> Bool
$c/= :: ConfigLevel -> ConfigLevel -> Bool
== :: ConfigLevel -> ConfigLevel -> Bool
$c== :: ConfigLevel -> ConfigLevel -> Bool
Eq)

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

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

instance P.Ord ConfigLevel where
    compare :: ConfigLevel -> ConfigLevel -> Ordering
compare a :: ConfigLevel
a b :: 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)

foreign import ccall "ggit_config_level_get_type" c_ggit_config_level_get_type :: 
    IO GType

instance BoxedEnum ConfigLevel where
    boxedEnumType :: ConfigLevel -> IO GType
boxedEnumType _ = IO GType
c_ggit_config_level_get_type

-- 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
showList :: [CloneLocal] -> ShowS
$cshowList :: [CloneLocal] -> ShowS
show :: CloneLocal -> String
$cshow :: CloneLocal -> String
showsPrec :: Int -> CloneLocal -> ShowS
$cshowsPrec :: Int -> CloneLocal -> ShowS
Show, CloneLocal -> CloneLocal -> Bool
(CloneLocal -> CloneLocal -> Bool)
-> (CloneLocal -> CloneLocal -> Bool) -> Eq CloneLocal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CloneLocal -> CloneLocal -> Bool
$c/= :: CloneLocal -> CloneLocal -> Bool
== :: CloneLocal -> CloneLocal -> Bool
$c== :: CloneLocal -> CloneLocal -> Bool
Eq)

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

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

instance P.Ord CloneLocal where
    compare :: CloneLocal -> CloneLocal -> Ordering
compare a :: CloneLocal
a b :: 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)

foreign import ccall "ggit_clone_local_get_type" c_ggit_clone_local_get_type :: 
    IO GType

instance BoxedEnum CloneLocal where
    boxedEnumType :: CloneLocal -> IO GType
boxedEnumType _ = IO GType
c_ggit_clone_local_get_type

-- 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
showList :: [BranchType] -> ShowS
$cshowList :: [BranchType] -> ShowS
show :: BranchType -> String
$cshow :: BranchType -> String
showsPrec :: Int -> BranchType -> ShowS
$cshowsPrec :: Int -> BranchType -> ShowS
Show, BranchType -> BranchType -> Bool
(BranchType -> BranchType -> Bool)
-> (BranchType -> BranchType -> Bool) -> Eq BranchType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BranchType -> BranchType -> Bool
$c/= :: BranchType -> BranchType -> Bool
== :: BranchType -> BranchType -> Bool
$c== :: BranchType -> BranchType -> Bool
Eq)

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

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

instance P.Ord BranchType where
    compare :: BranchType -> BranchType -> Ordering
compare a :: BranchType
a b :: 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)

foreign import ccall "ggit_branch_type_get_type" c_ggit_branch_type_get_type :: 
    IO GType

instance BoxedEnum BranchType where
    boxedEnumType :: BranchType -> IO GType
boxedEnumType _ = IO GType
c_ggit_branch_type_get_type