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


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

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

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

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

foreign import ccall "ggit_submodule_status_get_type" c_ggit_submodule_status_get_type :: 
    IO GType

instance BoxedFlags SubmoduleStatus where
    boxedFlagsType :: Proxy SubmoduleStatus -> IO GType
boxedFlagsType _ = IO GType
c_ggit_submodule_status_get_type

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

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

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

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

foreign import ccall "ggit_status_option_get_type" c_ggit_status_option_get_type :: 
    IO GType

instance BoxedFlags StatusOption where
    boxedFlagsType :: Proxy StatusOption -> IO GType
boxedFlagsType _ = IO GType
c_ggit_status_option_get_type

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

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

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

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

foreign import ccall "ggit_status_flags_get_type" c_ggit_status_flags_get_type :: 
    IO GType

instance BoxedFlags StatusFlags where
    boxedFlagsType :: Proxy StatusFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_status_flags_get_type

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

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

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

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

foreign import ccall "ggit_stash_flags_get_type" c_ggit_stash_flags_get_type :: 
    IO GType

instance BoxedFlags StashFlags where
    boxedFlagsType :: Proxy StashFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_stash_flags_get_type

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

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

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

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

foreign import ccall "ggit_sort_mode_get_type" c_ggit_sort_mode_get_type :: 
    IO GType

instance BoxedFlags SortMode where
    boxedFlagsType :: Proxy SortMode -> IO GType
boxedFlagsType _ = IO GType
c_ggit_sort_mode_get_type

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

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

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

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

foreign import ccall "ggit_merge_flags_get_type" c_ggit_merge_flags_get_type :: 
    IO GType

instance BoxedFlags MergeFlags where
    boxedFlagsType :: Proxy MergeFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_merge_flags_get_type

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

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

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

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

foreign import ccall "ggit_merge_file_flags_get_type" c_ggit_merge_file_flags_get_type :: 
    IO GType

instance BoxedFlags MergeFileFlags where
    boxedFlagsType :: Proxy MergeFileFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_merge_file_flags_get_type

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

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

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

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

foreign import ccall "ggit_feature_flags_get_type" c_ggit_feature_flags_get_type :: 
    IO GType

instance BoxedFlags FeatureFlags where
    boxedFlagsType :: Proxy FeatureFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_feature_flags_get_type

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

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

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

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

foreign import ccall "ggit_diff_option_get_type" c_ggit_diff_option_get_type :: 
    IO GType

instance BoxedFlags DiffOption where
    boxedFlagsType :: Proxy DiffOption -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_option_get_type

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

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

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

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

foreign import ccall "ggit_diff_format_email_flags_get_type" c_ggit_diff_format_email_flags_get_type :: 
    IO GType

instance BoxedFlags DiffFormatEmailFlags where
    boxedFlagsType :: Proxy DiffFormatEmailFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_format_email_flags_get_type

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

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

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

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

foreign import ccall "ggit_diff_flag_get_type" c_ggit_diff_flag_get_type :: 
    IO GType

instance BoxedFlags DiffFlag where
    boxedFlagsType :: Proxy DiffFlag -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_flag_get_type

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

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

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

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

foreign import ccall "ggit_diff_find_flags_get_type" c_ggit_diff_find_flags_get_type :: 
    IO GType

instance BoxedFlags DiffFindFlags where
    boxedFlagsType :: Proxy DiffFindFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_diff_find_flags_get_type

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

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

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

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

foreign import ccall "ggit_credtype_get_type" c_ggit_credtype_get_type :: 
    IO GType

instance BoxedFlags Credtype where
    boxedFlagsType :: Proxy Credtype -> IO GType
boxedFlagsType _ = IO GType
c_ggit_credtype_get_type

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

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

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

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

foreign import ccall "ggit_create_flags_get_type" c_ggit_create_flags_get_type :: 
    IO GType

instance BoxedFlags CreateFlags where
    boxedFlagsType :: Proxy CreateFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_create_flags_get_type

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

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

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

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

foreign import ccall "ggit_checkout_strategy_get_type" c_ggit_checkout_strategy_get_type :: 
    IO GType

instance BoxedFlags CheckoutStrategy where
    boxedFlagsType :: Proxy CheckoutStrategy -> IO GType
boxedFlagsType _ = IO GType
c_ggit_checkout_strategy_get_type

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

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

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

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

foreign import ccall "ggit_checkout_notify_flags_get_type" c_ggit_checkout_notify_flags_get_type :: 
    IO GType

instance BoxedFlags CheckoutNotifyFlags where
    boxedFlagsType :: Proxy CheckoutNotifyFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_checkout_notify_flags_get_type

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

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

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

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

foreign import ccall "ggit_blame_flags_get_type" c_ggit_blame_flags_get_type :: 
    IO GType

instance BoxedFlags BlameFlags where
    boxedFlagsType :: Proxy BlameFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_blame_flags_get_type

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

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

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

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

foreign import ccall "ggit_attribute_check_flags_get_type" c_ggit_attribute_check_flags_get_type :: 
    IO GType

instance BoxedFlags AttributeCheckFlags where
    boxedFlagsType :: Proxy AttributeCheckFlags -> IO GType
boxedFlagsType _ = IO GType
c_ggit_attribute_check_flags_get_type

instance IsGFlag AttributeCheckFlags