{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

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

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.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 (Show, Eq)

instance P.Enum SubmoduleStatus where
    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) = k

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

instance P.Ord SubmoduleStatus where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_submodule_status_get_type" c_ggit_submodule_status_get_type :: 
    IO GType

instance BoxedFlags SubmoduleStatus where
    boxedFlagsType _ = 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 (Show, Eq)

instance P.Enum StatusOption where
    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) = k

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

instance P.Ord StatusOption where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_status_option_get_type" c_ggit_status_option_get_type :: 
    IO GType

instance BoxedFlags StatusOption where
    boxedFlagsType _ = 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 (Show, Eq)

instance P.Enum StatusFlags where
    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) = k

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

instance P.Ord StatusFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_status_flags_get_type" c_ggit_status_flags_get_type :: 
    IO GType

instance BoxedFlags StatusFlags where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 0 = StashFlagsDefault
    toEnum 1 = StashFlagsKeepIndex
    toEnum 2 = StashFlagsIncludeUntracked
    toEnum 4 = StashFlagsIncludeIgnored
    toEnum k = AnotherStashFlags k

instance P.Ord StashFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_stash_flags_get_type" c_ggit_stash_flags_get_type :: 
    IO GType

instance BoxedFlags StashFlags where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 0 = SortModeNone
    toEnum 1 = SortModeTopological
    toEnum 2 = SortModeTime
    toEnum 4 = SortModeReverse
    toEnum k = AnotherSortMode k

instance P.Ord SortMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_sort_mode_get_type" c_ggit_sort_mode_get_type :: 
    IO GType

instance BoxedFlags SortMode where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 1 = MergeFlagsFindRenames
    toEnum 2 = MergeFlagsFailOnConflict
    toEnum 4 = MergeFlagsSkipReuc
    toEnum 8 = MergeFlagsNoRecursive
    toEnum k = AnotherMergeFlags k

instance P.Ord MergeFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_merge_flags_get_type" c_ggit_merge_flags_get_type :: 
    IO GType

instance BoxedFlags MergeFlags where
    boxedFlagsType _ = 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 (Show, Eq)

instance P.Enum MergeFileFlags where
    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) = k

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

instance P.Ord MergeFileFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_merge_file_flags_get_type" c_ggit_merge_file_flags_get_type :: 
    IO GType

instance BoxedFlags MergeFileFlags where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 1 = FeatureFlagsThreads
    toEnum 2 = FeatureFlagsHttps
    toEnum 4 = FeatureFlagsSsh
    toEnum k = AnotherFeatureFlags k

instance P.Ord FeatureFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_feature_flags_get_type" c_ggit_feature_flags_get_type :: 
    IO GType

instance BoxedFlags FeatureFlags where
    boxedFlagsType _ = 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 (Show, Eq)

instance P.Enum DiffOption where
    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) = k

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

instance P.Ord DiffOption where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_diff_option_get_type" c_ggit_diff_option_get_type :: 
    IO GType

instance BoxedFlags DiffOption where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 0 = DiffFormatEmailFlagsNone
    toEnum 1 = DiffFormatEmailFlagsExcludeSubjectPatchMarker
    toEnum k = AnotherDiffFormatEmailFlags k

instance P.Ord DiffFormatEmailFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 1 = DiffFlagBinary
    toEnum 2 = DiffFlagNotBinary
    toEnum 4 = DiffFlagValidId
    toEnum k = AnotherDiffFlag k

instance P.Ord DiffFlag where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_diff_flag_get_type" c_ggit_diff_flag_get_type :: 
    IO GType

instance BoxedFlags DiffFlag where
    boxedFlagsType _ = 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 (Show, Eq)

instance P.Enum DiffFindFlags where
    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) = k

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

instance P.Ord DiffFindFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_diff_find_flags_get_type" c_ggit_diff_find_flags_get_type :: 
    IO GType

instance BoxedFlags DiffFindFlags where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 1 = CredtypeUserpassPlaintext
    toEnum 2 = CredtypeSshKey
    toEnum 4 = CredtypeSshCustom
    toEnum 8 = CredtypeDefault
    toEnum 16 = CredtypeSshInteractive
    toEnum k = AnotherCredtype k

instance P.Ord Credtype where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_credtype_get_type" c_ggit_credtype_get_type :: 
    IO GType

instance BoxedFlags Credtype where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 0 = CreateFlagsNone
    toEnum 1 = CreateFlagsForce
    toEnum k = AnotherCreateFlags k

instance P.Ord CreateFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_create_flags_get_type" c_ggit_create_flags_get_type :: 
    IO GType

instance BoxedFlags CreateFlags where
    boxedFlagsType _ = 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 (Show, Eq)

instance P.Enum CheckoutStrategy where
    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) = k

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

instance P.Ord CheckoutStrategy where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_checkout_strategy_get_type" c_ggit_checkout_strategy_get_type :: 
    IO GType

instance BoxedFlags CheckoutStrategy where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 0 = CheckoutNotifyFlagsNone
    toEnum 1 = CheckoutNotifyFlagsConflict
    toEnum 2 = CheckoutNotifyFlagsDirty
    toEnum 4 = CheckoutNotifyFlagsUpdated
    toEnum 8 = CheckoutNotifyFlagsUntracked
    toEnum 16 = CheckoutNotifyFlagsIgnored
    toEnum 65535 = CheckoutNotifyFlagsAll
    toEnum k = AnotherCheckoutNotifyFlags k

instance P.Ord CheckoutNotifyFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_checkout_notify_flags_get_type" c_ggit_checkout_notify_flags_get_type :: 
    IO GType

instance BoxedFlags CheckoutNotifyFlags where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 0 = BlameFlagsNormal
    toEnum 1 = BlameFlagsTrackCopiesSameFile
    toEnum k = AnotherBlameFlags k

instance P.Ord BlameFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_blame_flags_get_type" c_ggit_blame_flags_get_type :: 
    IO GType

instance BoxedFlags BlameFlags where
    boxedFlagsType _ = 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 (Show, Eq)

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

    toEnum 0 = AttributeCheckFlagsFileThenIndex
    toEnum 1 = AttributeCheckFlagsIndexThenFile
    toEnum 2 = AttributeCheckFlagsIndexOnly
    toEnum 4 = AttributeCheckFlagsNoSystem
    toEnum k = AnotherAttributeCheckFlags k

instance P.Ord AttributeCheckFlags where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "ggit_attribute_check_flags_get_type" c_ggit_attribute_check_flags_get_type :: 
    IO GType

instance BoxedFlags AttributeCheckFlags where
    boxedFlagsType _ = c_ggit_attribute_check_flags_get_type

instance IsGFlag AttributeCheckFlags