-- | 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.Flags
    ( 

 -- * Flags


-- ** AttributeCheckFlags #flag:AttributeCheckFlags#

    AttributeCheckFlags(..)                 ,


-- ** BlameFlags #flag:BlameFlags#

    BlameFlags(..)                          ,


-- ** CheckoutNotifyFlags #flag:CheckoutNotifyFlags#

    CheckoutNotifyFlags(..)                 ,


-- ** CheckoutStrategy #flag:CheckoutStrategy#

    CheckoutStrategy(..)                    ,


-- ** CreateFlags #flag:CreateFlags#

    CreateFlags(..)                         ,


-- ** Credtype #flag:Credtype#

    Credtype(..)                            ,


-- ** DiffFindFlags #flag:DiffFindFlags#

    DiffFindFlags(..)                       ,


-- ** DiffFlag #flag:DiffFlag#

    DiffFlag(..)                            ,


-- ** DiffFormatEmailFlags #flag:DiffFormatEmailFlags#

    DiffFormatEmailFlags(..)                ,


-- ** DiffOption #flag:DiffOption#

    DiffOption(..)                          ,


-- ** FeatureFlags #flag:FeatureFlags#

    FeatureFlags(..)                        ,


-- ** MergeFileFlags #flag:MergeFileFlags#

    MergeFileFlags(..)                      ,


-- ** MergeFlags #flag:MergeFlags#

    MergeFlags(..)                          ,


-- ** SortMode #flag:SortMode#

    SortMode(..)                            ,


-- ** StashFlags #flag:StashFlags#

    StashFlags(..)                          ,


-- ** StatusFlags #flag:StatusFlags#

    StatusFlags(..)                         ,


-- ** StatusOption #flag:StatusOption#

    StatusOption(..)                        ,


-- ** SubmoduleStatus #flag:SubmoduleStatus#

    SubmoduleStatus(..)                     ,




    ) 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.Kind as DK
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


-- Flags SubmoduleStatus
-- | FIXME
data SubmoduleStatus = 
      SubmoduleStatusInHead
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusInIndex
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusInConfig
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusInWd
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusIndexAdded
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusIndexDeleted
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusIndexModified
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusWdUninitialized
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusWdAdded
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusWdDeleted
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusWdModified
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusWdIndexModified
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusWdWdModified
    -- ^ /No description available in the introspection data./
    | SubmoduleStatusWdUntracked
    -- ^ /No description available in the introspection data./
    | AnotherSubmoduleStatus Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SubmoduleStatus -> ShowS
[SubmoduleStatus] -> ShowS
SubmoduleStatus -> String
(Int -> SubmoduleStatus -> ShowS)
-> (SubmoduleStatus -> String)
-> ([SubmoduleStatus] -> ShowS)
-> Show SubmoduleStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubmoduleStatus -> ShowS
showsPrec :: Int -> SubmoduleStatus -> ShowS
$cshow :: SubmoduleStatus -> String
show :: SubmoduleStatus -> String
$cshowList :: [SubmoduleStatus] -> ShowS
showList :: [SubmoduleStatus] -> ShowS
Show, SubmoduleStatus -> SubmoduleStatus -> Bool
(SubmoduleStatus -> SubmoduleStatus -> Bool)
-> (SubmoduleStatus -> SubmoduleStatus -> Bool)
-> Eq SubmoduleStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubmoduleStatus -> SubmoduleStatus -> Bool
== :: SubmoduleStatus -> SubmoduleStatus -> Bool
$c/= :: SubmoduleStatus -> SubmoduleStatus -> Bool
/= :: SubmoduleStatus -> SubmoduleStatus -> Bool
Eq)

instance P.Enum SubmoduleStatus where
    fromEnum :: SubmoduleStatus -> Int
fromEnum SubmoduleStatus
SubmoduleStatusInHead = Int
1
    fromEnum SubmoduleStatus
SubmoduleStatusInIndex = Int
2
    fromEnum SubmoduleStatus
SubmoduleStatusInConfig = Int
4
    fromEnum SubmoduleStatus
SubmoduleStatusInWd = Int
8
    fromEnum SubmoduleStatus
SubmoduleStatusIndexAdded = Int
16
    fromEnum SubmoduleStatus
SubmoduleStatusIndexDeleted = Int
32
    fromEnum SubmoduleStatus
SubmoduleStatusIndexModified = Int
64
    fromEnum SubmoduleStatus
SubmoduleStatusWdUninitialized = Int
128
    fromEnum SubmoduleStatus
SubmoduleStatusWdAdded = Int
256
    fromEnum SubmoduleStatus
SubmoduleStatusWdDeleted = Int
512
    fromEnum SubmoduleStatus
SubmoduleStatusWdModified = Int
1024
    fromEnum SubmoduleStatus
SubmoduleStatusWdIndexModified = Int
2048
    fromEnum SubmoduleStatus
SubmoduleStatusWdWdModified = Int
4096
    fromEnum SubmoduleStatus
SubmoduleStatusWdUntracked = Int
8192
    fromEnum (AnotherSubmoduleStatus Int
k) = Int
k

    toEnum :: Int -> SubmoduleStatus
toEnum Int
1 = SubmoduleStatus
SubmoduleStatusInHead
    toEnum Int
2 = SubmoduleStatus
SubmoduleStatusInIndex
    toEnum Int
4 = SubmoduleStatus
SubmoduleStatusInConfig
    toEnum Int
8 = SubmoduleStatus
SubmoduleStatusInWd
    toEnum Int
16 = SubmoduleStatus
SubmoduleStatusIndexAdded
    toEnum Int
32 = SubmoduleStatus
SubmoduleStatusIndexDeleted
    toEnum Int
64 = SubmoduleStatus
SubmoduleStatusIndexModified
    toEnum Int
128 = SubmoduleStatus
SubmoduleStatusWdUninitialized
    toEnum Int
256 = SubmoduleStatus
SubmoduleStatusWdAdded
    toEnum Int
512 = SubmoduleStatus
SubmoduleStatusWdDeleted
    toEnum Int
1024 = SubmoduleStatus
SubmoduleStatusWdModified
    toEnum Int
2048 = SubmoduleStatus
SubmoduleStatusWdIndexModified
    toEnum Int
4096 = SubmoduleStatus
SubmoduleStatusWdWdModified
    toEnum Int
8192 = SubmoduleStatus
SubmoduleStatusWdUntracked
    toEnum Int
k = Int -> SubmoduleStatus
AnotherSubmoduleStatus Int
k

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

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

foreign import ccall "ggit_submodule_status_get_type" c_ggit_submodule_status_get_type :: 
    IO GType

instance B.Types.TypedObject SubmoduleStatus where
    glibType :: IO GType
glibType = IO GType
c_ggit_submodule_status_get_type

instance B.Types.BoxedFlags SubmoduleStatus

instance IsGFlag SubmoduleStatus

-- Flags StatusOption
-- | GGIT_STATUS_OPTION_INCLUDE_UNTRACKED: include untracked files (default).
-- GGIT_STATUS_OPTION_INCLUDE_IGNORED: include ignored files (default).
-- GGIT_STATUS_OPTION_INCLUDE_UNMODIFIED: include unmodified files.
-- GGIT_STATUS_OPTION_EXCLUDE_SUBMODULES: exclude submodules.
-- GGIT_STATUS_OPTION_RECURSE_UNTRACKED_DIRS: search untracked directories recursively (default).
-- GGIT_STATUS_OPTION_DISABLE_PATHSPEC_MATCH: do not match path specifications.
-- GGIT_STATUS_OPTION_RECURSE_IGNORED_DIRS: search ignored directories recursively.
-- GGIT_STATUS_OPTION_RENAMES_HEAD_TO_INDEX: indicates that rename detection
-- should be processed between the head and the index and enables
-- the GIT_STATUS_INDEX_RENAMED as a possible status flag.
-- GGIT_STATUS_OPTION_RENAMES_INDEX_TO_WORKDIR: indicates tha rename
-- detection should be run between the index and the working directory
-- and enabled GIT_STATUS_WT_RENAMED as a possible status flag.
-- GGIT_STATUS_OPTION_SORT_CASE_SENSITIVELY: sort case sensitive.
-- GGIT_STATUS_OPTION_SORT_CASE_INSENSITIVELY: sort case insensitive.
-- GGIT_STATUS_OPTION_DEFAULT: default flags.
-- Status options specified when using @/ggit_repository_file_status_foreach/@.
data StatusOption = 
      StatusOptionIncludeUntracked
    -- ^ /No description available in the introspection data./
    | StatusOptionIncludeIgnored
    -- ^ /No description available in the introspection data./
    | StatusOptionIncludeUnmodified
    -- ^ /No description available in the introspection data./
    | StatusOptionExcludeSubmodules
    -- ^ /No description available in the introspection data./
    | StatusOptionRecurseUntrackedDirs
    -- ^ /No description available in the introspection data./
    | StatusOptionDisablePathspecMatch
    -- ^ /No description available in the introspection data./
    | StatusOptionRecurseIgnoredDirs
    -- ^ /No description available in the introspection data./
    | StatusOptionRenamesHeadToIndex
    -- ^ /No description available in the introspection data./
    | StatusOptionRenamesIndexToWorkdir
    -- ^ /No description available in the introspection data./
    | StatusOptionSortCaseSensitively
    -- ^ /No description available in the introspection data./
    | StatusOptionSortCaseInsensitively
    -- ^ /No description available in the introspection data./
    | StatusOptionDefault
    -- ^ /No description available in the introspection data./
    | AnotherStatusOption Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StatusOption -> ShowS
[StatusOption] -> ShowS
StatusOption -> String
(Int -> StatusOption -> ShowS)
-> (StatusOption -> String)
-> ([StatusOption] -> ShowS)
-> Show StatusOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusOption -> ShowS
showsPrec :: Int -> StatusOption -> ShowS
$cshow :: StatusOption -> String
show :: StatusOption -> String
$cshowList :: [StatusOption] -> ShowS
showList :: [StatusOption] -> ShowS
Show, StatusOption -> StatusOption -> Bool
(StatusOption -> StatusOption -> Bool)
-> (StatusOption -> StatusOption -> Bool) -> Eq StatusOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusOption -> StatusOption -> Bool
== :: StatusOption -> StatusOption -> Bool
$c/= :: StatusOption -> StatusOption -> Bool
/= :: StatusOption -> StatusOption -> Bool
Eq)

instance P.Enum StatusOption where
    fromEnum :: StatusOption -> Int
fromEnum StatusOption
StatusOptionIncludeUntracked = Int
1
    fromEnum StatusOption
StatusOptionIncludeIgnored = Int
2
    fromEnum StatusOption
StatusOptionIncludeUnmodified = Int
4
    fromEnum StatusOption
StatusOptionExcludeSubmodules = Int
8
    fromEnum StatusOption
StatusOptionRecurseUntrackedDirs = Int
16
    fromEnum StatusOption
StatusOptionDisablePathspecMatch = Int
32
    fromEnum StatusOption
StatusOptionRecurseIgnoredDirs = Int
64
    fromEnum StatusOption
StatusOptionRenamesHeadToIndex = Int
128
    fromEnum StatusOption
StatusOptionRenamesIndexToWorkdir = Int
256
    fromEnum StatusOption
StatusOptionSortCaseSensitively = Int
512
    fromEnum StatusOption
StatusOptionSortCaseInsensitively = Int
1024
    fromEnum StatusOption
StatusOptionDefault = Int
19
    fromEnum (AnotherStatusOption Int
k) = Int
k

    toEnum :: Int -> StatusOption
toEnum Int
1 = StatusOption
StatusOptionIncludeUntracked
    toEnum Int
2 = StatusOption
StatusOptionIncludeIgnored
    toEnum Int
4 = StatusOption
StatusOptionIncludeUnmodified
    toEnum Int
8 = StatusOption
StatusOptionExcludeSubmodules
    toEnum Int
16 = StatusOption
StatusOptionRecurseUntrackedDirs
    toEnum Int
32 = StatusOption
StatusOptionDisablePathspecMatch
    toEnum Int
64 = StatusOption
StatusOptionRecurseIgnoredDirs
    toEnum Int
128 = StatusOption
StatusOptionRenamesHeadToIndex
    toEnum Int
256 = StatusOption
StatusOptionRenamesIndexToWorkdir
    toEnum Int
512 = StatusOption
StatusOptionSortCaseSensitively
    toEnum Int
1024 = StatusOption
StatusOptionSortCaseInsensitively
    toEnum Int
19 = StatusOption
StatusOptionDefault
    toEnum Int
k = Int -> StatusOption
AnotherStatusOption Int
k

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

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

foreign import ccall "ggit_status_option_get_type" c_ggit_status_option_get_type :: 
    IO GType

instance B.Types.TypedObject StatusOption where
    glibType :: IO GType
glibType = IO GType
c_ggit_status_option_get_type

instance B.Types.BoxedFlags StatusOption

instance IsGFlag StatusOption

-- Flags StatusFlags
-- | Describes a file\'s status.
data StatusFlags = 
      StatusFlagsCurrent
    -- ^ file is current.
    | StatusFlagsIndexNew
    -- ^ file in index is new.
    | StatusFlagsIndexModified
    -- ^ file in index is modified.
    | StatusFlagsIndexDeleted
    -- ^ file in index is deleted.
    | StatusFlagsIndexRenamed
    -- ^ /No description available in the introspection data./
    | StatusFlagsIndexTypechange
    -- ^ /No description available in the introspection data./
    | StatusFlagsWorkingTreeNew
    -- ^ file in working tree is new.
    | StatusFlagsWorkingTreeModified
    -- ^ file in working tree is modified.
    | StatusFlagsWorkingTreeDeleted
    -- ^ file in working tree is deleted.
    | StatusFlagsWorkingTreeTypechange
    -- ^ /No description available in the introspection data./
    | StatusFlagsWorkingTreeRenamed
    -- ^ /No description available in the introspection data./
    | StatusFlagsWorkingTreeUnreadable
    -- ^ /No description available in the introspection data./
    | StatusFlagsIgnored
    -- ^ file is ignored.
    | StatusFlagsConflicted
    -- ^ /No description available in the introspection data./
    | AnotherStatusFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StatusFlags -> ShowS
[StatusFlags] -> ShowS
StatusFlags -> String
(Int -> StatusFlags -> ShowS)
-> (StatusFlags -> String)
-> ([StatusFlags] -> ShowS)
-> Show StatusFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StatusFlags -> ShowS
showsPrec :: Int -> StatusFlags -> ShowS
$cshow :: StatusFlags -> String
show :: StatusFlags -> String
$cshowList :: [StatusFlags] -> ShowS
showList :: [StatusFlags] -> ShowS
Show, StatusFlags -> StatusFlags -> Bool
(StatusFlags -> StatusFlags -> Bool)
-> (StatusFlags -> StatusFlags -> Bool) -> Eq StatusFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatusFlags -> StatusFlags -> Bool
== :: StatusFlags -> StatusFlags -> Bool
$c/= :: StatusFlags -> StatusFlags -> Bool
/= :: StatusFlags -> StatusFlags -> Bool
Eq)

instance P.Enum StatusFlags where
    fromEnum :: StatusFlags -> Int
fromEnum StatusFlags
StatusFlagsCurrent = Int
0
    fromEnum StatusFlags
StatusFlagsIndexNew = Int
1
    fromEnum StatusFlags
StatusFlagsIndexModified = Int
2
    fromEnum StatusFlags
StatusFlagsIndexDeleted = Int
4
    fromEnum StatusFlags
StatusFlagsIndexRenamed = Int
8
    fromEnum StatusFlags
StatusFlagsIndexTypechange = Int
16
    fromEnum StatusFlags
StatusFlagsWorkingTreeNew = Int
128
    fromEnum StatusFlags
StatusFlagsWorkingTreeModified = Int
256
    fromEnum StatusFlags
StatusFlagsWorkingTreeDeleted = Int
512
    fromEnum StatusFlags
StatusFlagsWorkingTreeTypechange = Int
1024
    fromEnum StatusFlags
StatusFlagsWorkingTreeRenamed = Int
2048
    fromEnum StatusFlags
StatusFlagsWorkingTreeUnreadable = Int
4096
    fromEnum StatusFlags
StatusFlagsIgnored = Int
16384
    fromEnum StatusFlags
StatusFlagsConflicted = Int
32768
    fromEnum (AnotherStatusFlags Int
k) = Int
k

    toEnum :: Int -> StatusFlags
toEnum Int
0 = StatusFlags
StatusFlagsCurrent
    toEnum Int
1 = StatusFlags
StatusFlagsIndexNew
    toEnum Int
2 = StatusFlags
StatusFlagsIndexModified
    toEnum Int
4 = StatusFlags
StatusFlagsIndexDeleted
    toEnum Int
8 = StatusFlags
StatusFlagsIndexRenamed
    toEnum Int
16 = StatusFlags
StatusFlagsIndexTypechange
    toEnum Int
128 = StatusFlags
StatusFlagsWorkingTreeNew
    toEnum Int
256 = StatusFlags
StatusFlagsWorkingTreeModified
    toEnum Int
512 = StatusFlags
StatusFlagsWorkingTreeDeleted
    toEnum Int
1024 = StatusFlags
StatusFlagsWorkingTreeTypechange
    toEnum Int
2048 = StatusFlags
StatusFlagsWorkingTreeRenamed
    toEnum Int
4096 = StatusFlags
StatusFlagsWorkingTreeUnreadable
    toEnum Int
16384 = StatusFlags
StatusFlagsIgnored
    toEnum Int
32768 = StatusFlags
StatusFlagsConflicted
    toEnum Int
k = Int -> StatusFlags
AnotherStatusFlags Int
k

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

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

foreign import ccall "ggit_status_flags_get_type" c_ggit_status_flags_get_type :: 
    IO GType

instance B.Types.TypedObject StatusFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_status_flags_get_type

instance B.Types.BoxedFlags StatusFlags

instance IsGFlag StatusFlags

-- Flags StashFlags
-- | Describes how a stash should be applied.
data StashFlags = 
      StashFlagsDefault
    -- ^ default stash.
    | StashFlagsKeepIndex
    -- ^ All changes already added to the index
    -- are left intact in the working directory.
    | StashFlagsIncludeUntracked
    -- ^ All untracked files are also stashed and then
    -- cleaned up from the working directory.
    | StashFlagsIncludeIgnored
    -- ^ All ignored files are also stashed and then
    -- cleaned up from the working directory.
    | AnotherStashFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StashFlags -> ShowS
[StashFlags] -> ShowS
StashFlags -> String
(Int -> StashFlags -> ShowS)
-> (StashFlags -> String)
-> ([StashFlags] -> ShowS)
-> Show StashFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StashFlags -> ShowS
showsPrec :: Int -> StashFlags -> ShowS
$cshow :: StashFlags -> String
show :: StashFlags -> String
$cshowList :: [StashFlags] -> ShowS
showList :: [StashFlags] -> ShowS
Show, StashFlags -> StashFlags -> Bool
(StashFlags -> StashFlags -> Bool)
-> (StashFlags -> StashFlags -> Bool) -> Eq StashFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StashFlags -> StashFlags -> Bool
== :: StashFlags -> StashFlags -> Bool
$c/= :: StashFlags -> StashFlags -> Bool
/= :: StashFlags -> StashFlags -> Bool
Eq)

instance P.Enum StashFlags where
    fromEnum :: StashFlags -> Int
fromEnum StashFlags
StashFlagsDefault = Int
0
    fromEnum StashFlags
StashFlagsKeepIndex = Int
1
    fromEnum StashFlags
StashFlagsIncludeUntracked = Int
2
    fromEnum StashFlags
StashFlagsIncludeIgnored = Int
4
    fromEnum (AnotherStashFlags Int
k) = Int
k

    toEnum :: Int -> StashFlags
toEnum Int
0 = StashFlags
StashFlagsDefault
    toEnum Int
1 = StashFlags
StashFlagsKeepIndex
    toEnum Int
2 = StashFlags
StashFlagsIncludeUntracked
    toEnum Int
4 = StashFlags
StashFlagsIncludeIgnored
    toEnum Int
k = Int -> StashFlags
AnotherStashFlags Int
k

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

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

foreign import ccall "ggit_stash_flags_get_type" c_ggit_stash_flags_get_type :: 
    IO GType

instance B.Types.TypedObject StashFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_stash_flags_get_type

instance B.Types.BoxedFlags StashFlags

instance IsGFlag StashFlags

-- Flags SortMode
-- | The type of sorting mode for the revision walker.
data SortMode = 
      SortModeNone
    -- ^ Sorts the repository contents in no particular ordering;
    --                  this sorting is arbitrary, implementation-specific
    --                  and subject to change at any time.
    | SortModeTopological
    -- ^ Sorts the repository contents in topological order
    --                         (parents before children); this sorting mode
    --                         can be combined with time sorting.
    | SortModeTime
    -- ^ Sort the repository contents by commit time;
    --                  this sorting mode can be combined with
    --                  topological sorting.
    | SortModeReverse
    -- ^ Iterate through the repository contents in reverse
    --                     order; this sorting mode can be combined with
    --                     any of the above.
    | AnotherSortMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SortMode -> ShowS
[SortMode] -> ShowS
SortMode -> String
(Int -> SortMode -> ShowS)
-> (SortMode -> String) -> ([SortMode] -> ShowS) -> Show SortMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortMode -> ShowS
showsPrec :: Int -> SortMode -> ShowS
$cshow :: SortMode -> String
show :: SortMode -> String
$cshowList :: [SortMode] -> ShowS
showList :: [SortMode] -> ShowS
Show, SortMode -> SortMode -> Bool
(SortMode -> SortMode -> Bool)
-> (SortMode -> SortMode -> Bool) -> Eq SortMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortMode -> SortMode -> Bool
== :: SortMode -> SortMode -> Bool
$c/= :: SortMode -> SortMode -> Bool
/= :: SortMode -> SortMode -> Bool
Eq)

instance P.Enum SortMode where
    fromEnum :: SortMode -> Int
fromEnum SortMode
SortModeNone = Int
0
    fromEnum SortMode
SortModeTopological = Int
1
    fromEnum SortMode
SortModeTime = Int
2
    fromEnum SortMode
SortModeReverse = Int
4
    fromEnum (AnotherSortMode Int
k) = Int
k

    toEnum :: Int -> SortMode
toEnum Int
0 = SortMode
SortModeNone
    toEnum Int
1 = SortMode
SortModeTopological
    toEnum Int
2 = SortMode
SortModeTime
    toEnum Int
4 = SortMode
SortModeReverse
    toEnum Int
k = Int -> SortMode
AnotherSortMode Int
k

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

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

foreign import ccall "ggit_sort_mode_get_type" c_ggit_sort_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SortMode where
    glibType :: IO GType
glibType = IO GType
c_ggit_sort_mode_get_type

instance B.Types.BoxedFlags SortMode

instance IsGFlag SortMode

-- Flags MergeFlags
-- | /No description available in the introspection data./
data MergeFlags = 
      MergeFlagsFindRenames
    -- ^ detect renames that occur between the common
    -- ancestor and the \"ours\" side or the common ancestor and the \"theirs\" side.
    -- This will enable the ability to merge between a modified and renamed file.
    | MergeFlagsFailOnConflict
    -- ^ If a conflict occurs, exit immediately instead
    -- of attempting to continue resolving conflicts.  The merge operation will
    -- fail with /@gGITEMERGECONFLICT@/ and no index will be returned.
    | MergeFlagsSkipReuc
    -- ^ do not write the REUC extension on the generated index.
    | MergeFlagsNoRecursive
    -- ^ If the commits being merged have multiple merge bases,
    -- do not build a recursive merge base (by merging the multiple merge bases),
    -- instead simply use the first base.  This flag provides a similar
    -- merge base to @git-merge-resolve@.
    | AnotherMergeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MergeFlags -> ShowS
[MergeFlags] -> ShowS
MergeFlags -> String
(Int -> MergeFlags -> ShowS)
-> (MergeFlags -> String)
-> ([MergeFlags] -> ShowS)
-> Show MergeFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeFlags -> ShowS
showsPrec :: Int -> MergeFlags -> ShowS
$cshow :: MergeFlags -> String
show :: MergeFlags -> String
$cshowList :: [MergeFlags] -> ShowS
showList :: [MergeFlags] -> ShowS
Show, MergeFlags -> MergeFlags -> Bool
(MergeFlags -> MergeFlags -> Bool)
-> (MergeFlags -> MergeFlags -> Bool) -> Eq MergeFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeFlags -> MergeFlags -> Bool
== :: MergeFlags -> MergeFlags -> Bool
$c/= :: MergeFlags -> MergeFlags -> Bool
/= :: MergeFlags -> MergeFlags -> Bool
Eq)

instance P.Enum MergeFlags where
    fromEnum :: MergeFlags -> Int
fromEnum MergeFlags
MergeFlagsFindRenames = Int
1
    fromEnum MergeFlags
MergeFlagsFailOnConflict = Int
2
    fromEnum MergeFlags
MergeFlagsSkipReuc = Int
4
    fromEnum MergeFlags
MergeFlagsNoRecursive = Int
8
    fromEnum (AnotherMergeFlags Int
k) = Int
k

    toEnum :: Int -> MergeFlags
toEnum Int
1 = MergeFlags
MergeFlagsFindRenames
    toEnum Int
2 = MergeFlags
MergeFlagsFailOnConflict
    toEnum Int
4 = MergeFlags
MergeFlagsSkipReuc
    toEnum Int
8 = MergeFlags
MergeFlagsNoRecursive
    toEnum Int
k = Int -> MergeFlags
AnotherMergeFlags Int
k

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

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

foreign import ccall "ggit_merge_flags_get_type" c_ggit_merge_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MergeFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_merge_flags_get_type

instance B.Types.BoxedFlags MergeFlags

instance IsGFlag MergeFlags

-- Flags MergeFileFlags
-- | GGIT_MERGE_FILE_DEFAULT: Defaults.
-- GGIT_MERGE_FILE_STYLE_MERGE: Create standard conflicted merge files.
-- GGIT_MERGE_FILE_STYLE_DIFF3: Create diff3-style files.
-- GGIT_MERGE_FILE_SIMPLIFY_ALNUM: Condense non-alphanumeric regions for simplified diff file.
-- GGIT_MERGE_FILE_IGNORE_WHITESPACE: Ignore all whitespace.
-- GGIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE: Ignore changes in amount of whitespace.
-- GGIT_MERGE_FILE_IGNORE_WHITESPACE_EOL: Ignore whitespace at end of line.
-- GGIT_MERGE_FILE_DIFF_PATIENCE: Use the \"patience diff\" algorithm.
-- GGIT_MERGE_FILE_DIFF_MINIMAL: Take extra time to find minimal diff.
data MergeFileFlags = 
      MergeFileFlagsDefault
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsStyleMerge
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsStyleDiff3
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsSimplifyAlnum
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsIgnoreWhitespace
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsIgnoreWhitespaceChange
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsIgnoreWhitespaceEol
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsDiffPatience
    -- ^ /No description available in the introspection data./
    | MergeFileFlagsDiffMinimal
    -- ^ /No description available in the introspection data./
    | AnotherMergeFileFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MergeFileFlags -> ShowS
[MergeFileFlags] -> ShowS
MergeFileFlags -> String
(Int -> MergeFileFlags -> ShowS)
-> (MergeFileFlags -> String)
-> ([MergeFileFlags] -> ShowS)
-> Show MergeFileFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeFileFlags -> ShowS
showsPrec :: Int -> MergeFileFlags -> ShowS
$cshow :: MergeFileFlags -> String
show :: MergeFileFlags -> String
$cshowList :: [MergeFileFlags] -> ShowS
showList :: [MergeFileFlags] -> ShowS
Show, MergeFileFlags -> MergeFileFlags -> Bool
(MergeFileFlags -> MergeFileFlags -> Bool)
-> (MergeFileFlags -> MergeFileFlags -> Bool) -> Eq MergeFileFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeFileFlags -> MergeFileFlags -> Bool
== :: MergeFileFlags -> MergeFileFlags -> Bool
$c/= :: MergeFileFlags -> MergeFileFlags -> Bool
/= :: MergeFileFlags -> MergeFileFlags -> Bool
Eq)

instance P.Enum MergeFileFlags where
    fromEnum :: MergeFileFlags -> Int
fromEnum MergeFileFlags
MergeFileFlagsDefault = Int
0
    fromEnum MergeFileFlags
MergeFileFlagsStyleMerge = Int
1
    fromEnum MergeFileFlags
MergeFileFlagsStyleDiff3 = Int
2
    fromEnum MergeFileFlags
MergeFileFlagsSimplifyAlnum = Int
4
    fromEnum MergeFileFlags
MergeFileFlagsIgnoreWhitespace = Int
8
    fromEnum MergeFileFlags
MergeFileFlagsIgnoreWhitespaceChange = Int
16
    fromEnum MergeFileFlags
MergeFileFlagsIgnoreWhitespaceEol = Int
32
    fromEnum MergeFileFlags
MergeFileFlagsDiffPatience = Int
64
    fromEnum MergeFileFlags
MergeFileFlagsDiffMinimal = Int
128
    fromEnum (AnotherMergeFileFlags Int
k) = Int
k

    toEnum :: Int -> MergeFileFlags
toEnum Int
0 = MergeFileFlags
MergeFileFlagsDefault
    toEnum Int
1 = MergeFileFlags
MergeFileFlagsStyleMerge
    toEnum Int
2 = MergeFileFlags
MergeFileFlagsStyleDiff3
    toEnum Int
4 = MergeFileFlags
MergeFileFlagsSimplifyAlnum
    toEnum Int
8 = MergeFileFlags
MergeFileFlagsIgnoreWhitespace
    toEnum Int
16 = MergeFileFlags
MergeFileFlagsIgnoreWhitespaceChange
    toEnum Int
32 = MergeFileFlags
MergeFileFlagsIgnoreWhitespaceEol
    toEnum Int
64 = MergeFileFlags
MergeFileFlagsDiffPatience
    toEnum Int
128 = MergeFileFlags
MergeFileFlagsDiffMinimal
    toEnum Int
k = Int -> MergeFileFlags
AnotherMergeFileFlags Int
k

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

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

foreign import ccall "ggit_merge_file_flags_get_type" c_ggit_merge_file_flags_get_type :: 
    IO GType

instance B.Types.TypedObject MergeFileFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_merge_file_flags_get_type

instance B.Types.BoxedFlags MergeFileFlags

instance IsGFlag MergeFileFlags

-- Flags FeatureFlags
-- | /No description available in the introspection data./
data FeatureFlags = 
      FeatureFlagsThreads
    -- ^ /No description available in the introspection data./
    | FeatureFlagsHttps
    -- ^ /No description available in the introspection data./
    | FeatureFlagsSsh
    -- ^ /No description available in the introspection data./
    | AnotherFeatureFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FeatureFlags -> ShowS
[FeatureFlags] -> ShowS
FeatureFlags -> String
(Int -> FeatureFlags -> ShowS)
-> (FeatureFlags -> String)
-> ([FeatureFlags] -> ShowS)
-> Show FeatureFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FeatureFlags -> ShowS
showsPrec :: Int -> FeatureFlags -> ShowS
$cshow :: FeatureFlags -> String
show :: FeatureFlags -> String
$cshowList :: [FeatureFlags] -> ShowS
showList :: [FeatureFlags] -> ShowS
Show, FeatureFlags -> FeatureFlags -> Bool
(FeatureFlags -> FeatureFlags -> Bool)
-> (FeatureFlags -> FeatureFlags -> Bool) -> Eq FeatureFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FeatureFlags -> FeatureFlags -> Bool
== :: FeatureFlags -> FeatureFlags -> Bool
$c/= :: FeatureFlags -> FeatureFlags -> Bool
/= :: FeatureFlags -> FeatureFlags -> Bool
Eq)

instance P.Enum FeatureFlags where
    fromEnum :: FeatureFlags -> Int
fromEnum FeatureFlags
FeatureFlagsThreads = Int
1
    fromEnum FeatureFlags
FeatureFlagsHttps = Int
2
    fromEnum FeatureFlags
FeatureFlagsSsh = Int
4
    fromEnum (AnotherFeatureFlags Int
k) = Int
k

    toEnum :: Int -> FeatureFlags
toEnum Int
1 = FeatureFlags
FeatureFlagsThreads
    toEnum Int
2 = FeatureFlags
FeatureFlagsHttps
    toEnum Int
4 = FeatureFlags
FeatureFlagsSsh
    toEnum Int
k = Int -> FeatureFlags
AnotherFeatureFlags Int
k

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

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

foreign import ccall "ggit_feature_flags_get_type" c_ggit_feature_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FeatureFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_feature_flags_get_type

instance B.Types.BoxedFlags FeatureFlags

instance IsGFlag FeatureFlags

-- Flags DiffOption
-- | How the diff should be generated.
data DiffOption = 
      DiffOptionNormal
    -- ^ normal.
    | DiffOptionReverse
    -- ^ reverse the sides of the diff.
    | DiffOptionIncludeIgnored
    -- ^ include ignored files.
    | DiffOptionRecurseIgnoredDirs
    -- ^ also add all files under ignored dirs.
    | DiffOptionIncludeUntracked
    -- ^ include untracked files.
    | DiffOptionRecurseUntrackedDirs
    -- ^ recurse to untracked directories.
    | DiffOptionIncludeUnmodified
    -- ^ include unmodified files.
    | DiffOptionIncludeTypechange
    -- ^ enable generation of typechange detal records.
    | DiffOptionIncludeTypechangeTrees
    -- ^ try to label tree transitions as type changes.
    | DiffOptionIgnoreFileMode
    -- ^ ignore file mode changes.
    | DiffOptionIgnoreSubmodules
    -- ^ ignore submodules.
    | DiffOptionIgnoreCase
    -- ^ use case insensitive filename comparison.
    | DiffOptionDisablePathspecMatch
    -- ^ use exact path matching.
    | DiffOptionSkipBinaryCheck
    -- ^ disable updating the binary flag in delta records.
    | DiffOptionEnableFastUntrackedDirs
    -- ^ immediately label untracked directories as
    -- untracked, without checking inside.
    | DiffOptionForceText
    -- ^ force text.
    | DiffOptionForceBinary
    -- ^ treat all files as binary, disabling text diffs.
    | DiffOptionIgnoreWhitespace
    -- ^ ignore whitespace.
    | DiffOptionIgnoreWhitespaceChange
    -- ^ ignore whitespace change.
    | DiffOptionIgnoreWhitespaceEol
    -- ^ ignore whitespace at end-of-line.
    | DiffOptionShowUntrackedContent
    -- ^ include content of untracked files.
    -- this implies GGIT_DIFF_INCLUDE_UNTRACKED but not GGIT_DIFF_RECURSE_UNTRACKED_DIRS.
    | DiffOptionShowUnmodified
    -- ^ show unmodified files.
    | DiffOptionPatience
    -- ^ generate using the \"patience diff\" algorithm.
    | DiffOptionMinimal
    -- ^ take extra time to find minimal diff.
    | DiffOptionShowBinary
    -- ^ include deflate\/delta information for binary files.
    | AnotherDiffOption Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DiffOption -> ShowS
[DiffOption] -> ShowS
DiffOption -> String
(Int -> DiffOption -> ShowS)
-> (DiffOption -> String)
-> ([DiffOption] -> ShowS)
-> Show DiffOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffOption -> ShowS
showsPrec :: Int -> DiffOption -> ShowS
$cshow :: DiffOption -> String
show :: DiffOption -> String
$cshowList :: [DiffOption] -> ShowS
showList :: [DiffOption] -> ShowS
Show, DiffOption -> DiffOption -> Bool
(DiffOption -> DiffOption -> Bool)
-> (DiffOption -> DiffOption -> Bool) -> Eq DiffOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffOption -> DiffOption -> Bool
== :: DiffOption -> DiffOption -> Bool
$c/= :: DiffOption -> DiffOption -> Bool
/= :: DiffOption -> DiffOption -> Bool
Eq)

instance P.Enum DiffOption where
    fromEnum :: DiffOption -> Int
fromEnum DiffOption
DiffOptionNormal = Int
0
    fromEnum DiffOption
DiffOptionReverse = Int
1
    fromEnum DiffOption
DiffOptionIncludeIgnored = Int
2
    fromEnum DiffOption
DiffOptionRecurseIgnoredDirs = Int
4
    fromEnum DiffOption
DiffOptionIncludeUntracked = Int
8
    fromEnum DiffOption
DiffOptionRecurseUntrackedDirs = Int
16
    fromEnum DiffOption
DiffOptionIncludeUnmodified = Int
32
    fromEnum DiffOption
DiffOptionIncludeTypechange = Int
64
    fromEnum DiffOption
DiffOptionIncludeTypechangeTrees = Int
128
    fromEnum DiffOption
DiffOptionIgnoreFileMode = Int
256
    fromEnum DiffOption
DiffOptionIgnoreSubmodules = Int
512
    fromEnum DiffOption
DiffOptionIgnoreCase = Int
1024
    fromEnum DiffOption
DiffOptionDisablePathspecMatch = Int
4096
    fromEnum DiffOption
DiffOptionSkipBinaryCheck = Int
8192
    fromEnum DiffOption
DiffOptionEnableFastUntrackedDirs = Int
16384
    fromEnum DiffOption
DiffOptionForceText = Int
1048576
    fromEnum DiffOption
DiffOptionForceBinary = Int
2097152
    fromEnum DiffOption
DiffOptionIgnoreWhitespace = Int
4194304
    fromEnum DiffOption
DiffOptionIgnoreWhitespaceChange = Int
8388608
    fromEnum DiffOption
DiffOptionIgnoreWhitespaceEol = Int
16777216
    fromEnum DiffOption
DiffOptionShowUntrackedContent = Int
33554432
    fromEnum DiffOption
DiffOptionShowUnmodified = Int
67108864
    fromEnum DiffOption
DiffOptionPatience = Int
268435456
    fromEnum DiffOption
DiffOptionMinimal = Int
536870912
    fromEnum DiffOption
DiffOptionShowBinary = Int
1073741824
    fromEnum (AnotherDiffOption Int
k) = Int
k

    toEnum :: Int -> DiffOption
toEnum Int
0 = DiffOption
DiffOptionNormal
    toEnum Int
1 = DiffOption
DiffOptionReverse
    toEnum Int
2 = DiffOption
DiffOptionIncludeIgnored
    toEnum Int
4 = DiffOption
DiffOptionRecurseIgnoredDirs
    toEnum Int
8 = DiffOption
DiffOptionIncludeUntracked
    toEnum Int
16 = DiffOption
DiffOptionRecurseUntrackedDirs
    toEnum Int
32 = DiffOption
DiffOptionIncludeUnmodified
    toEnum Int
64 = DiffOption
DiffOptionIncludeTypechange
    toEnum Int
128 = DiffOption
DiffOptionIncludeTypechangeTrees
    toEnum Int
256 = DiffOption
DiffOptionIgnoreFileMode
    toEnum Int
512 = DiffOption
DiffOptionIgnoreSubmodules
    toEnum Int
1024 = DiffOption
DiffOptionIgnoreCase
    toEnum Int
4096 = DiffOption
DiffOptionDisablePathspecMatch
    toEnum Int
8192 = DiffOption
DiffOptionSkipBinaryCheck
    toEnum Int
16384 = DiffOption
DiffOptionEnableFastUntrackedDirs
    toEnum Int
1048576 = DiffOption
DiffOptionForceText
    toEnum Int
2097152 = DiffOption
DiffOptionForceBinary
    toEnum Int
4194304 = DiffOption
DiffOptionIgnoreWhitespace
    toEnum Int
8388608 = DiffOption
DiffOptionIgnoreWhitespaceChange
    toEnum Int
16777216 = DiffOption
DiffOptionIgnoreWhitespaceEol
    toEnum Int
33554432 = DiffOption
DiffOptionShowUntrackedContent
    toEnum Int
67108864 = DiffOption
DiffOptionShowUnmodified
    toEnum Int
268435456 = DiffOption
DiffOptionPatience
    toEnum Int
536870912 = DiffOption
DiffOptionMinimal
    toEnum Int
1073741824 = DiffOption
DiffOptionShowBinary
    toEnum Int
k = Int -> DiffOption
AnotherDiffOption Int
k

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

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

foreign import ccall "ggit_diff_option_get_type" c_ggit_diff_option_get_type :: 
    IO GType

instance B.Types.TypedObject DiffOption where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_option_get_type

instance B.Types.BoxedFlags DiffOption

instance IsGFlag DiffOption

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

instance P.Enum DiffFormatEmailFlags where
    fromEnum :: DiffFormatEmailFlags -> Int
fromEnum DiffFormatEmailFlags
DiffFormatEmailFlagsNone = Int
0
    fromEnum DiffFormatEmailFlags
DiffFormatEmailFlagsExcludeSubjectPatchMarker = Int
1
    fromEnum (AnotherDiffFormatEmailFlags Int
k) = Int
k

    toEnum :: Int -> DiffFormatEmailFlags
toEnum Int
0 = DiffFormatEmailFlags
DiffFormatEmailFlagsNone
    toEnum Int
1 = DiffFormatEmailFlags
DiffFormatEmailFlagsExcludeSubjectPatchMarker
    toEnum Int
k = Int -> DiffFormatEmailFlags
AnotherDiffFormatEmailFlags Int
k

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

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

foreign import ccall "ggit_diff_format_email_flags_get_type" c_ggit_diff_format_email_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DiffFormatEmailFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_format_email_flags_get_type

instance B.Types.BoxedFlags DiffFormatEmailFlags

instance IsGFlag DiffFormatEmailFlags

-- Flags DiffFlag
-- | Describes the diff file and\/or delta flags
data DiffFlag = 
      DiffFlagBinary
    -- ^ if the file is binary.
    | DiffFlagNotBinary
    -- ^ if the file is not binary.
    | DiffFlagValidId
    -- ^ if the ID is valid.
    | AnotherDiffFlag Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DiffFlag -> ShowS
[DiffFlag] -> ShowS
DiffFlag -> String
(Int -> DiffFlag -> ShowS)
-> (DiffFlag -> String) -> ([DiffFlag] -> ShowS) -> Show DiffFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffFlag -> ShowS
showsPrec :: Int -> DiffFlag -> ShowS
$cshow :: DiffFlag -> String
show :: DiffFlag -> String
$cshowList :: [DiffFlag] -> ShowS
showList :: [DiffFlag] -> ShowS
Show, DiffFlag -> DiffFlag -> Bool
(DiffFlag -> DiffFlag -> Bool)
-> (DiffFlag -> DiffFlag -> Bool) -> Eq DiffFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffFlag -> DiffFlag -> Bool
== :: DiffFlag -> DiffFlag -> Bool
$c/= :: DiffFlag -> DiffFlag -> Bool
/= :: DiffFlag -> DiffFlag -> Bool
Eq)

instance P.Enum DiffFlag where
    fromEnum :: DiffFlag -> Int
fromEnum DiffFlag
DiffFlagBinary = Int
1
    fromEnum DiffFlag
DiffFlagNotBinary = Int
2
    fromEnum DiffFlag
DiffFlagValidId = Int
4
    fromEnum (AnotherDiffFlag Int
k) = Int
k

    toEnum :: Int -> DiffFlag
toEnum Int
1 = DiffFlag
DiffFlagBinary
    toEnum Int
2 = DiffFlag
DiffFlagNotBinary
    toEnum Int
4 = DiffFlag
DiffFlagValidId
    toEnum Int
k = Int -> DiffFlag
AnotherDiffFlag Int
k

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

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

foreign import ccall "ggit_diff_flag_get_type" c_ggit_diff_flag_get_type :: 
    IO GType

instance B.Types.TypedObject DiffFlag where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_flag_get_type

instance B.Types.BoxedFlags DiffFlag

instance IsGFlag DiffFlag

-- Flags DiffFindFlags
-- | /No description available in the introspection data./
data DiffFindFlags = 
      DiffFindFlagsFindByConfig
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindRenames
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindRenamesFromRewrites
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindCopies
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindCopiesFromUnmodified
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindRewrites
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsBreakRewrites
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindAndBreakRewrites
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindForUntracked
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindAll
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindIgnoreLeadingWhitespace
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindIgnoreWhitespace
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindDontIgnoreWhitespace
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindExactMatchOnly
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsBreakRewritesForRenamesOnly
    -- ^ /No description available in the introspection data./
    | DiffFindFlagsFindRemoveUnmodified
    -- ^ /No description available in the introspection data./
    | AnotherDiffFindFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DiffFindFlags -> ShowS
[DiffFindFlags] -> ShowS
DiffFindFlags -> String
(Int -> DiffFindFlags -> ShowS)
-> (DiffFindFlags -> String)
-> ([DiffFindFlags] -> ShowS)
-> Show DiffFindFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DiffFindFlags -> ShowS
showsPrec :: Int -> DiffFindFlags -> ShowS
$cshow :: DiffFindFlags -> String
show :: DiffFindFlags -> String
$cshowList :: [DiffFindFlags] -> ShowS
showList :: [DiffFindFlags] -> ShowS
Show, DiffFindFlags -> DiffFindFlags -> Bool
(DiffFindFlags -> DiffFindFlags -> Bool)
-> (DiffFindFlags -> DiffFindFlags -> Bool) -> Eq DiffFindFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DiffFindFlags -> DiffFindFlags -> Bool
== :: DiffFindFlags -> DiffFindFlags -> Bool
$c/= :: DiffFindFlags -> DiffFindFlags -> Bool
/= :: DiffFindFlags -> DiffFindFlags -> Bool
Eq)

instance P.Enum DiffFindFlags where
    fromEnum :: DiffFindFlags -> Int
fromEnum DiffFindFlags
DiffFindFlagsFindByConfig = Int
0
    fromEnum DiffFindFlags
DiffFindFlagsFindRenames = Int
1
    fromEnum DiffFindFlags
DiffFindFlagsFindRenamesFromRewrites = Int
2
    fromEnum DiffFindFlags
DiffFindFlagsFindCopies = Int
4
    fromEnum DiffFindFlags
DiffFindFlagsFindCopiesFromUnmodified = Int
8
    fromEnum DiffFindFlags
DiffFindFlagsFindRewrites = Int
16
    fromEnum DiffFindFlags
DiffFindFlagsBreakRewrites = Int
32
    fromEnum DiffFindFlags
DiffFindFlagsFindAndBreakRewrites = Int
48
    fromEnum DiffFindFlags
DiffFindFlagsFindForUntracked = Int
64
    fromEnum DiffFindFlags
DiffFindFlagsFindAll = Int
255
    fromEnum DiffFindFlags
DiffFindFlagsFindIgnoreLeadingWhitespace = Int
0
    fromEnum DiffFindFlags
DiffFindFlagsFindIgnoreWhitespace = Int
4096
    fromEnum DiffFindFlags
DiffFindFlagsFindDontIgnoreWhitespace = Int
8192
    fromEnum DiffFindFlags
DiffFindFlagsFindExactMatchOnly = Int
16384
    fromEnum DiffFindFlags
DiffFindFlagsBreakRewritesForRenamesOnly = Int
32768
    fromEnum DiffFindFlags
DiffFindFlagsFindRemoveUnmodified = Int
65536
    fromEnum (AnotherDiffFindFlags Int
k) = Int
k

    toEnum :: Int -> DiffFindFlags
toEnum Int
0 = DiffFindFlags
DiffFindFlagsFindByConfig
    toEnum Int
1 = DiffFindFlags
DiffFindFlagsFindRenames
    toEnum Int
2 = DiffFindFlags
DiffFindFlagsFindRenamesFromRewrites
    toEnum Int
4 = DiffFindFlags
DiffFindFlagsFindCopies
    toEnum Int
8 = DiffFindFlags
DiffFindFlagsFindCopiesFromUnmodified
    toEnum Int
16 = DiffFindFlags
DiffFindFlagsFindRewrites
    toEnum Int
32 = DiffFindFlags
DiffFindFlagsBreakRewrites
    toEnum Int
48 = DiffFindFlags
DiffFindFlagsFindAndBreakRewrites
    toEnum Int
64 = DiffFindFlags
DiffFindFlagsFindForUntracked
    toEnum Int
255 = DiffFindFlags
DiffFindFlagsFindAll
    toEnum Int
4096 = DiffFindFlags
DiffFindFlagsFindIgnoreWhitespace
    toEnum Int
8192 = DiffFindFlags
DiffFindFlagsFindDontIgnoreWhitespace
    toEnum Int
16384 = DiffFindFlags
DiffFindFlagsFindExactMatchOnly
    toEnum Int
32768 = DiffFindFlags
DiffFindFlagsBreakRewritesForRenamesOnly
    toEnum Int
65536 = DiffFindFlags
DiffFindFlagsFindRemoveUnmodified
    toEnum Int
k = Int -> DiffFindFlags
AnotherDiffFindFlags Int
k

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

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

foreign import ccall "ggit_diff_find_flags_get_type" c_ggit_diff_find_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DiffFindFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_diff_find_flags_get_type

instance B.Types.BoxedFlags DiffFindFlags

instance IsGFlag DiffFindFlags

-- Flags Credtype
-- | /No description available in the introspection data./
data Credtype = 
      CredtypeUserpassPlaintext
    -- ^ /No description available in the introspection data./
    | CredtypeSshKey
    -- ^ /No description available in the introspection data./
    | CredtypeSshCustom
    -- ^ /No description available in the introspection data./
    | CredtypeDefault
    -- ^ /No description available in the introspection data./
    | CredtypeSshInteractive
    -- ^ /No description available in the introspection data./
    | AnotherCredtype Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Credtype -> ShowS
[Credtype] -> ShowS
Credtype -> String
(Int -> Credtype -> ShowS)
-> (Credtype -> String) -> ([Credtype] -> ShowS) -> Show Credtype
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Credtype -> ShowS
showsPrec :: Int -> Credtype -> ShowS
$cshow :: Credtype -> String
show :: Credtype -> String
$cshowList :: [Credtype] -> ShowS
showList :: [Credtype] -> ShowS
Show, Credtype -> Credtype -> Bool
(Credtype -> Credtype -> Bool)
-> (Credtype -> Credtype -> Bool) -> Eq Credtype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Credtype -> Credtype -> Bool
== :: Credtype -> Credtype -> Bool
$c/= :: Credtype -> Credtype -> Bool
/= :: Credtype -> Credtype -> Bool
Eq)

instance P.Enum Credtype where
    fromEnum :: Credtype -> Int
fromEnum Credtype
CredtypeUserpassPlaintext = Int
1
    fromEnum Credtype
CredtypeSshKey = Int
2
    fromEnum Credtype
CredtypeSshCustom = Int
4
    fromEnum Credtype
CredtypeDefault = Int
8
    fromEnum Credtype
CredtypeSshInteractive = Int
16
    fromEnum (AnotherCredtype Int
k) = Int
k

    toEnum :: Int -> Credtype
toEnum Int
1 = Credtype
CredtypeUserpassPlaintext
    toEnum Int
2 = Credtype
CredtypeSshKey
    toEnum Int
4 = Credtype
CredtypeSshCustom
    toEnum Int
8 = Credtype
CredtypeDefault
    toEnum Int
16 = Credtype
CredtypeSshInteractive
    toEnum Int
k = Int -> Credtype
AnotherCredtype Int
k

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

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

foreign import ccall "ggit_credtype_get_type" c_ggit_credtype_get_type :: 
    IO GType

instance B.Types.TypedObject Credtype where
    glibType :: IO GType
glibType = IO GType
c_ggit_credtype_get_type

instance B.Types.BoxedFlags Credtype

instance IsGFlag Credtype

-- Flags CreateFlags
-- | Describes how something should be created.
data CreateFlags = 
      CreateFlagsNone
    -- ^ attempt to create.
    | CreateFlagsForce
    -- ^ force creation.
    | AnotherCreateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CreateFlags -> ShowS
[CreateFlags] -> ShowS
CreateFlags -> String
(Int -> CreateFlags -> ShowS)
-> (CreateFlags -> String)
-> ([CreateFlags] -> ShowS)
-> Show CreateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CreateFlags -> ShowS
showsPrec :: Int -> CreateFlags -> ShowS
$cshow :: CreateFlags -> String
show :: CreateFlags -> String
$cshowList :: [CreateFlags] -> ShowS
showList :: [CreateFlags] -> ShowS
Show, CreateFlags -> CreateFlags -> Bool
(CreateFlags -> CreateFlags -> Bool)
-> (CreateFlags -> CreateFlags -> Bool) -> Eq CreateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CreateFlags -> CreateFlags -> Bool
== :: CreateFlags -> CreateFlags -> Bool
$c/= :: CreateFlags -> CreateFlags -> Bool
/= :: CreateFlags -> CreateFlags -> Bool
Eq)

instance P.Enum CreateFlags where
    fromEnum :: CreateFlags -> Int
fromEnum CreateFlags
CreateFlagsNone = Int
0
    fromEnum CreateFlags
CreateFlagsForce = Int
1
    fromEnum (AnotherCreateFlags Int
k) = Int
k

    toEnum :: Int -> CreateFlags
toEnum Int
0 = CreateFlags
CreateFlagsNone
    toEnum Int
1 = CreateFlags
CreateFlagsForce
    toEnum Int
k = Int -> CreateFlags
AnotherCreateFlags Int
k

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

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

foreign import ccall "ggit_create_flags_get_type" c_ggit_create_flags_get_type :: 
    IO GType

instance B.Types.TypedObject CreateFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_create_flags_get_type

instance B.Types.BoxedFlags CreateFlags

instance IsGFlag CreateFlags

-- Flags CheckoutStrategy
-- | /No description available in the introspection data./
data CheckoutStrategy = 
      CheckoutStrategyNone
    -- ^ /No description available in the introspection data./
    | CheckoutStrategySafe
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyForce
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyRecreateMissing
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyAllowConflicts
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyRemoveUntracked
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyRemoveIgnored
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyUpdateOnly
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyDontUpdateIndex
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyNoRefresh
    -- ^ /No description available in the introspection data./
    | CheckoutStrategySkipUnmerged
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyUseOurs
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyUseTheirs
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyDisablePathspecMatch
    -- ^ /No description available in the introspection data./
    | CheckoutStrategySkipLockedDirectories
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyDontOverwriteIgnored
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyConflictStyleMerge
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyConflictStyleDiff3
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyDontRemoveExisting
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyDontWriteIndex
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyUpdateSubmodules
    -- ^ /No description available in the introspection data./
    | CheckoutStrategyUpdateSubmodulesIfChanged
    -- ^ /No description available in the introspection data./
    | AnotherCheckoutStrategy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CheckoutStrategy -> ShowS
[CheckoutStrategy] -> ShowS
CheckoutStrategy -> String
(Int -> CheckoutStrategy -> ShowS)
-> (CheckoutStrategy -> String)
-> ([CheckoutStrategy] -> ShowS)
-> Show CheckoutStrategy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckoutStrategy -> ShowS
showsPrec :: Int -> CheckoutStrategy -> ShowS
$cshow :: CheckoutStrategy -> String
show :: CheckoutStrategy -> String
$cshowList :: [CheckoutStrategy] -> ShowS
showList :: [CheckoutStrategy] -> ShowS
Show, CheckoutStrategy -> CheckoutStrategy -> Bool
(CheckoutStrategy -> CheckoutStrategy -> Bool)
-> (CheckoutStrategy -> CheckoutStrategy -> Bool)
-> Eq CheckoutStrategy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckoutStrategy -> CheckoutStrategy -> Bool
== :: CheckoutStrategy -> CheckoutStrategy -> Bool
$c/= :: CheckoutStrategy -> CheckoutStrategy -> Bool
/= :: CheckoutStrategy -> CheckoutStrategy -> Bool
Eq)

instance P.Enum CheckoutStrategy where
    fromEnum :: CheckoutStrategy -> Int
fromEnum CheckoutStrategy
CheckoutStrategyNone = Int
0
    fromEnum CheckoutStrategy
CheckoutStrategySafe = Int
1
    fromEnum CheckoutStrategy
CheckoutStrategyForce = Int
2
    fromEnum CheckoutStrategy
CheckoutStrategyRecreateMissing = Int
4
    fromEnum CheckoutStrategy
CheckoutStrategyAllowConflicts = Int
16
    fromEnum CheckoutStrategy
CheckoutStrategyRemoveUntracked = Int
32
    fromEnum CheckoutStrategy
CheckoutStrategyRemoveIgnored = Int
64
    fromEnum CheckoutStrategy
CheckoutStrategyUpdateOnly = Int
128
    fromEnum CheckoutStrategy
CheckoutStrategyDontUpdateIndex = Int
256
    fromEnum CheckoutStrategy
CheckoutStrategyNoRefresh = Int
512
    fromEnum CheckoutStrategy
CheckoutStrategySkipUnmerged = Int
1024
    fromEnum CheckoutStrategy
CheckoutStrategyUseOurs = Int
2048
    fromEnum CheckoutStrategy
CheckoutStrategyUseTheirs = Int
4096
    fromEnum CheckoutStrategy
CheckoutStrategyDisablePathspecMatch = Int
8192
    fromEnum CheckoutStrategy
CheckoutStrategySkipLockedDirectories = Int
262144
    fromEnum CheckoutStrategy
CheckoutStrategyDontOverwriteIgnored = Int
524288
    fromEnum CheckoutStrategy
CheckoutStrategyConflictStyleMerge = Int
1048576
    fromEnum CheckoutStrategy
CheckoutStrategyConflictStyleDiff3 = Int
2097152
    fromEnum CheckoutStrategy
CheckoutStrategyDontRemoveExisting = Int
4194304
    fromEnum CheckoutStrategy
CheckoutStrategyDontWriteIndex = Int
8388608
    fromEnum CheckoutStrategy
CheckoutStrategyUpdateSubmodules = Int
65536
    fromEnum CheckoutStrategy
CheckoutStrategyUpdateSubmodulesIfChanged = Int
131072
    fromEnum (AnotherCheckoutStrategy Int
k) = Int
k

    toEnum :: Int -> CheckoutStrategy
toEnum Int
0 = CheckoutStrategy
CheckoutStrategyNone
    toEnum Int
1 = CheckoutStrategy
CheckoutStrategySafe
    toEnum Int
2 = CheckoutStrategy
CheckoutStrategyForce
    toEnum Int
4 = CheckoutStrategy
CheckoutStrategyRecreateMissing
    toEnum Int
16 = CheckoutStrategy
CheckoutStrategyAllowConflicts
    toEnum Int
32 = CheckoutStrategy
CheckoutStrategyRemoveUntracked
    toEnum Int
64 = CheckoutStrategy
CheckoutStrategyRemoveIgnored
    toEnum Int
128 = CheckoutStrategy
CheckoutStrategyUpdateOnly
    toEnum Int
256 = CheckoutStrategy
CheckoutStrategyDontUpdateIndex
    toEnum Int
512 = CheckoutStrategy
CheckoutStrategyNoRefresh
    toEnum Int
1024 = CheckoutStrategy
CheckoutStrategySkipUnmerged
    toEnum Int
2048 = CheckoutStrategy
CheckoutStrategyUseOurs
    toEnum Int
4096 = CheckoutStrategy
CheckoutStrategyUseTheirs
    toEnum Int
8192 = CheckoutStrategy
CheckoutStrategyDisablePathspecMatch
    toEnum Int
262144 = CheckoutStrategy
CheckoutStrategySkipLockedDirectories
    toEnum Int
524288 = CheckoutStrategy
CheckoutStrategyDontOverwriteIgnored
    toEnum Int
1048576 = CheckoutStrategy
CheckoutStrategyConflictStyleMerge
    toEnum Int
2097152 = CheckoutStrategy
CheckoutStrategyConflictStyleDiff3
    toEnum Int
4194304 = CheckoutStrategy
CheckoutStrategyDontRemoveExisting
    toEnum Int
8388608 = CheckoutStrategy
CheckoutStrategyDontWriteIndex
    toEnum Int
65536 = CheckoutStrategy
CheckoutStrategyUpdateSubmodules
    toEnum Int
131072 = CheckoutStrategy
CheckoutStrategyUpdateSubmodulesIfChanged
    toEnum Int
k = Int -> CheckoutStrategy
AnotherCheckoutStrategy Int
k

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

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

foreign import ccall "ggit_checkout_strategy_get_type" c_ggit_checkout_strategy_get_type :: 
    IO GType

instance B.Types.TypedObject CheckoutStrategy where
    glibType :: IO GType
glibType = IO GType
c_ggit_checkout_strategy_get_type

instance B.Types.BoxedFlags CheckoutStrategy

instance IsGFlag CheckoutStrategy

-- Flags CheckoutNotifyFlags
-- | /No description available in the introspection data./
data CheckoutNotifyFlags = 
      CheckoutNotifyFlagsNone
    -- ^ /No description available in the introspection data./
    | CheckoutNotifyFlagsConflict
    -- ^ /No description available in the introspection data./
    | CheckoutNotifyFlagsDirty
    -- ^ /No description available in the introspection data./
    | CheckoutNotifyFlagsUpdated
    -- ^ /No description available in the introspection data./
    | CheckoutNotifyFlagsUntracked
    -- ^ /No description available in the introspection data./
    | CheckoutNotifyFlagsIgnored
    -- ^ /No description available in the introspection data./
    | CheckoutNotifyFlagsAll
    -- ^ /No description available in the introspection data./
    | AnotherCheckoutNotifyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CheckoutNotifyFlags -> ShowS
[CheckoutNotifyFlags] -> ShowS
CheckoutNotifyFlags -> String
(Int -> CheckoutNotifyFlags -> ShowS)
-> (CheckoutNotifyFlags -> String)
-> ([CheckoutNotifyFlags] -> ShowS)
-> Show CheckoutNotifyFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CheckoutNotifyFlags -> ShowS
showsPrec :: Int -> CheckoutNotifyFlags -> ShowS
$cshow :: CheckoutNotifyFlags -> String
show :: CheckoutNotifyFlags -> String
$cshowList :: [CheckoutNotifyFlags] -> ShowS
showList :: [CheckoutNotifyFlags] -> ShowS
Show, CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
(CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool)
-> (CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool)
-> Eq CheckoutNotifyFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
== :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
$c/= :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
/= :: CheckoutNotifyFlags -> CheckoutNotifyFlags -> Bool
Eq)

instance P.Enum CheckoutNotifyFlags where
    fromEnum :: CheckoutNotifyFlags -> Int
fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsNone = Int
0
    fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsConflict = Int
1
    fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsDirty = Int
2
    fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsUpdated = Int
4
    fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsUntracked = Int
8
    fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsIgnored = Int
16
    fromEnum CheckoutNotifyFlags
CheckoutNotifyFlagsAll = Int
65535
    fromEnum (AnotherCheckoutNotifyFlags Int
k) = Int
k

    toEnum :: Int -> CheckoutNotifyFlags
toEnum Int
0 = CheckoutNotifyFlags
CheckoutNotifyFlagsNone
    toEnum Int
1 = CheckoutNotifyFlags
CheckoutNotifyFlagsConflict
    toEnum Int
2 = CheckoutNotifyFlags
CheckoutNotifyFlagsDirty
    toEnum Int
4 = CheckoutNotifyFlags
CheckoutNotifyFlagsUpdated
    toEnum Int
8 = CheckoutNotifyFlags
CheckoutNotifyFlagsUntracked
    toEnum Int
16 = CheckoutNotifyFlags
CheckoutNotifyFlagsIgnored
    toEnum Int
65535 = CheckoutNotifyFlags
CheckoutNotifyFlagsAll
    toEnum Int
k = Int -> CheckoutNotifyFlags
AnotherCheckoutNotifyFlags Int
k

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

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

foreign import ccall "ggit_checkout_notify_flags_get_type" c_ggit_checkout_notify_flags_get_type :: 
    IO GType

instance B.Types.TypedObject CheckoutNotifyFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_checkout_notify_flags_get_type

instance B.Types.BoxedFlags CheckoutNotifyFlags

instance IsGFlag CheckoutNotifyFlags

-- Flags BlameFlags
-- | /No description available in the introspection data./
data BlameFlags = 
      BlameFlagsNormal
    -- ^ Normal blame, the default.
    | BlameFlagsTrackCopiesSameFile
    -- ^ Track lines that have moved within a file
    --                                     (like git blame -M)
    | AnotherBlameFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BlameFlags -> ShowS
[BlameFlags] -> ShowS
BlameFlags -> String
(Int -> BlameFlags -> ShowS)
-> (BlameFlags -> String)
-> ([BlameFlags] -> ShowS)
-> Show BlameFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlameFlags -> ShowS
showsPrec :: Int -> BlameFlags -> ShowS
$cshow :: BlameFlags -> String
show :: BlameFlags -> String
$cshowList :: [BlameFlags] -> ShowS
showList :: [BlameFlags] -> ShowS
Show, BlameFlags -> BlameFlags -> Bool
(BlameFlags -> BlameFlags -> Bool)
-> (BlameFlags -> BlameFlags -> Bool) -> Eq BlameFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlameFlags -> BlameFlags -> Bool
== :: BlameFlags -> BlameFlags -> Bool
$c/= :: BlameFlags -> BlameFlags -> Bool
/= :: BlameFlags -> BlameFlags -> Bool
Eq)

instance P.Enum BlameFlags where
    fromEnum :: BlameFlags -> Int
fromEnum BlameFlags
BlameFlagsNormal = Int
0
    fromEnum BlameFlags
BlameFlagsTrackCopiesSameFile = Int
1
    fromEnum (AnotherBlameFlags Int
k) = Int
k

    toEnum :: Int -> BlameFlags
toEnum Int
0 = BlameFlags
BlameFlagsNormal
    toEnum Int
1 = BlameFlags
BlameFlagsTrackCopiesSameFile
    toEnum Int
k = Int -> BlameFlags
AnotherBlameFlags Int
k

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

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

foreign import ccall "ggit_blame_flags_get_type" c_ggit_blame_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BlameFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_blame_flags_get_type

instance B.Types.BoxedFlags BlameFlags

instance IsGFlag BlameFlags

-- Flags AttributeCheckFlags
-- | Attribute check flags indicate the order in which to check for gitattributes.
-- git core uses /@gGITATTRIBUTECHECKFILETHENINDEX@/ for all operations,
-- except on checkout, where it uses /@gGITATTRIBUTECHECKINDEXTHENFILE@/.
data AttributeCheckFlags = 
      AttributeCheckFlagsFileThenIndex
    -- ^ check working directory, then index.
    | AttributeCheckFlagsIndexThenFile
    -- ^ check index, then working directory.
    | AttributeCheckFlagsIndexOnly
    -- ^ check only index.
    | AttributeCheckFlagsNoSystem
    -- ^ ignore system wide attributes.
    | AnotherAttributeCheckFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AttributeCheckFlags -> ShowS
[AttributeCheckFlags] -> ShowS
AttributeCheckFlags -> String
(Int -> AttributeCheckFlags -> ShowS)
-> (AttributeCheckFlags -> String)
-> ([AttributeCheckFlags] -> ShowS)
-> Show AttributeCheckFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AttributeCheckFlags -> ShowS
showsPrec :: Int -> AttributeCheckFlags -> ShowS
$cshow :: AttributeCheckFlags -> String
show :: AttributeCheckFlags -> String
$cshowList :: [AttributeCheckFlags] -> ShowS
showList :: [AttributeCheckFlags] -> ShowS
Show, AttributeCheckFlags -> AttributeCheckFlags -> Bool
(AttributeCheckFlags -> AttributeCheckFlags -> Bool)
-> (AttributeCheckFlags -> AttributeCheckFlags -> Bool)
-> Eq AttributeCheckFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
== :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
$c/= :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
/= :: AttributeCheckFlags -> AttributeCheckFlags -> Bool
Eq)

instance P.Enum AttributeCheckFlags where
    fromEnum :: AttributeCheckFlags -> Int
fromEnum AttributeCheckFlags
AttributeCheckFlagsFileThenIndex = Int
0
    fromEnum AttributeCheckFlags
AttributeCheckFlagsIndexThenFile = Int
1
    fromEnum AttributeCheckFlags
AttributeCheckFlagsIndexOnly = Int
2
    fromEnum AttributeCheckFlags
AttributeCheckFlagsNoSystem = Int
4
    fromEnum (AnotherAttributeCheckFlags Int
k) = Int
k

    toEnum :: Int -> AttributeCheckFlags
toEnum Int
0 = AttributeCheckFlags
AttributeCheckFlagsFileThenIndex
    toEnum Int
1 = AttributeCheckFlags
AttributeCheckFlagsIndexThenFile
    toEnum Int
2 = AttributeCheckFlags
AttributeCheckFlagsIndexOnly
    toEnum Int
4 = AttributeCheckFlags
AttributeCheckFlagsNoSystem
    toEnum Int
k = Int -> AttributeCheckFlags
AnotherAttributeCheckFlags Int
k

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

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

foreign import ccall "ggit_attribute_check_flags_get_type" c_ggit_attribute_check_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AttributeCheckFlags where
    glibType :: IO GType
glibType = IO GType
c_ggit_attribute_check_flags_get_type

instance B.Types.BoxedFlags AttributeCheckFlags

instance IsGFlag AttributeCheckFlags