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

 -- * Flags


-- ** ChecksumFlags #flag:ChecksumFlags#

    ChecksumFlags(..)                       ,


-- ** DiffFlags #flag:DiffFlags#

    DiffFlags(..)                           ,


-- ** GpgSignatureFormatFlags #flag:GpgSignatureFormatFlags#

    GpgSignatureFormatFlags(..)             ,


-- ** RepoCommitModifierFlags #flag:RepoCommitModifierFlags#

    RepoCommitModifierFlags(..)             ,


-- ** RepoCommitState #flag:RepoCommitState#

    RepoCommitState(..)                     ,


-- ** RepoCommitTraverseFlags #flag:RepoCommitTraverseFlags#

    RepoCommitTraverseFlags(..)             ,


-- ** RepoListObjectsFlags #flag:RepoListObjectsFlags#

    RepoListObjectsFlags(..)                ,


-- ** RepoListRefsExtFlags #flag:RepoListRefsExtFlags#

    RepoListRefsExtFlags(..)                ,


-- ** RepoPruneFlags #flag:RepoPruneFlags#

    RepoPruneFlags(..)                      ,


-- ** RepoPullFlags #flag:RepoPullFlags#

    RepoPullFlags(..)                       ,


-- ** RepoResolveRevExtFlags #flag:RepoResolveRevExtFlags#

    RepoResolveRevExtFlags(..)              ,


-- ** SePolicyRestoreconFlags #flag:SePolicyRestoreconFlags#

    SePolicyRestoreconFlags(..)             ,


-- ** SysrootSimpleWriteDeploymentFlags #flag:SysrootSimpleWriteDeploymentFlags#

    SysrootSimpleWriteDeploymentFlags(..)   ,


-- ** SysrootUpgraderFlags #flag:SysrootUpgraderFlags#

    SysrootUpgraderFlags(..)                ,


-- ** SysrootUpgraderPullFlags #flag:SysrootUpgraderPullFlags#

    SysrootUpgraderPullFlags(..)            ,




    ) where

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

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


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

instance P.Enum SysrootUpgraderPullFlags where
    fromEnum :: SysrootUpgraderPullFlags -> Int
fromEnum SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsNone = Int
0
    fromEnum SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsAllowOlder = Int
1
    fromEnum SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsSynthetic = Int
2
    fromEnum (AnotherSysrootUpgraderPullFlags Int
k) = Int
k

    toEnum :: Int -> SysrootUpgraderPullFlags
toEnum Int
0 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsNone
    toEnum Int
1 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsAllowOlder
    toEnum Int
2 = SysrootUpgraderPullFlags
SysrootUpgraderPullFlagsSynthetic
    toEnum Int
k = Int -> SysrootUpgraderPullFlags
AnotherSysrootUpgraderPullFlags Int
k

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

instance IsGFlag SysrootUpgraderPullFlags

-- Flags SysrootUpgraderFlags
-- | Flags controlling operation of an t'GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader'.
data SysrootUpgraderFlags = 
      SysrootUpgraderFlagsIgnoreUnconfigured
    -- ^ Do not error if the origin has an unconfigured-state key
    | AnotherSysrootUpgraderFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SysrootUpgraderFlags -> ShowS
[SysrootUpgraderFlags] -> ShowS
SysrootUpgraderFlags -> String
(Int -> SysrootUpgraderFlags -> ShowS)
-> (SysrootUpgraderFlags -> String)
-> ([SysrootUpgraderFlags] -> ShowS)
-> Show SysrootUpgraderFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SysrootUpgraderFlags] -> ShowS
$cshowList :: [SysrootUpgraderFlags] -> ShowS
show :: SysrootUpgraderFlags -> String
$cshow :: SysrootUpgraderFlags -> String
showsPrec :: Int -> SysrootUpgraderFlags -> ShowS
$cshowsPrec :: Int -> SysrootUpgraderFlags -> ShowS
Show, SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
(SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool)
-> (SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool)
-> Eq SysrootUpgraderFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
$c/= :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
== :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
$c== :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Bool
Eq)

instance P.Enum SysrootUpgraderFlags where
    fromEnum :: SysrootUpgraderFlags -> Int
fromEnum SysrootUpgraderFlags
SysrootUpgraderFlagsIgnoreUnconfigured = Int
2
    fromEnum (AnotherSysrootUpgraderFlags Int
k) = Int
k

    toEnum :: Int -> SysrootUpgraderFlags
toEnum Int
2 = SysrootUpgraderFlags
SysrootUpgraderFlagsIgnoreUnconfigured
    toEnum Int
k = Int -> SysrootUpgraderFlags
AnotherSysrootUpgraderFlags Int
k

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

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

foreign import ccall "ostree_sysroot_upgrader_flags_get_type" c_ostree_sysroot_upgrader_flags_get_type :: 
    IO GType

instance B.Types.TypedObject SysrootUpgraderFlags where
    glibType :: IO GType
glibType = IO GType
c_ostree_sysroot_upgrader_flags_get_type

instance B.Types.BoxedFlags SysrootUpgraderFlags

instance IsGFlag SysrootUpgraderFlags

-- Flags SysrootSimpleWriteDeploymentFlags
-- | /No description available in the introspection data./
data SysrootSimpleWriteDeploymentFlags = 
      SysrootSimpleWriteDeploymentFlagsNone
    -- ^ /No description available in the introspection data./
    | SysrootSimpleWriteDeploymentFlagsRetain
    -- ^ /No description available in the introspection data./
    | SysrootSimpleWriteDeploymentFlagsNotDefault
    -- ^ /No description available in the introspection data./
    | SysrootSimpleWriteDeploymentFlagsNoClean
    -- ^ /No description available in the introspection data./
    | SysrootSimpleWriteDeploymentFlagsRetainPending
    -- ^ /No description available in the introspection data./
    | SysrootSimpleWriteDeploymentFlagsRetainRollback
    -- ^ /No description available in the introspection data./
    | AnotherSysrootSimpleWriteDeploymentFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SysrootSimpleWriteDeploymentFlags -> ShowS
[SysrootSimpleWriteDeploymentFlags] -> ShowS
SysrootSimpleWriteDeploymentFlags -> String
(Int -> SysrootSimpleWriteDeploymentFlags -> ShowS)
-> (SysrootSimpleWriteDeploymentFlags -> String)
-> ([SysrootSimpleWriteDeploymentFlags] -> ShowS)
-> Show SysrootSimpleWriteDeploymentFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SysrootSimpleWriteDeploymentFlags] -> ShowS
$cshowList :: [SysrootSimpleWriteDeploymentFlags] -> ShowS
show :: SysrootSimpleWriteDeploymentFlags -> String
$cshow :: SysrootSimpleWriteDeploymentFlags -> String
showsPrec :: Int -> SysrootSimpleWriteDeploymentFlags -> ShowS
$cshowsPrec :: Int -> SysrootSimpleWriteDeploymentFlags -> ShowS
Show, SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
(SysrootSimpleWriteDeploymentFlags
 -> SysrootSimpleWriteDeploymentFlags -> Bool)
-> (SysrootSimpleWriteDeploymentFlags
    -> SysrootSimpleWriteDeploymentFlags -> Bool)
-> Eq SysrootSimpleWriteDeploymentFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
$c/= :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
== :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
$c== :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Bool
Eq)

instance P.Enum SysrootSimpleWriteDeploymentFlags where
    fromEnum :: SysrootSimpleWriteDeploymentFlags -> Int
fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNone = Int
0
    fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetain = Int
1
    fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNotDefault = Int
2
    fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNoClean = Int
4
    fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainPending = Int
8
    fromEnum SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainRollback = Int
16
    fromEnum (AnotherSysrootSimpleWriteDeploymentFlags Int
k) = Int
k

    toEnum :: Int -> SysrootSimpleWriteDeploymentFlags
toEnum Int
0 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNone
    toEnum Int
1 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetain
    toEnum Int
2 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNotDefault
    toEnum Int
4 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsNoClean
    toEnum Int
8 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainPending
    toEnum Int
16 = SysrootSimpleWriteDeploymentFlags
SysrootSimpleWriteDeploymentFlagsRetainRollback
    toEnum Int
k = Int -> SysrootSimpleWriteDeploymentFlags
AnotherSysrootSimpleWriteDeploymentFlags Int
k

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

instance IsGFlag SysrootSimpleWriteDeploymentFlags

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

instance P.Enum SePolicyRestoreconFlags where
    fromEnum :: SePolicyRestoreconFlags -> Int
fromEnum SePolicyRestoreconFlags
SePolicyRestoreconFlagsNone = Int
0
    fromEnum SePolicyRestoreconFlags
SePolicyRestoreconFlagsAllowNolabel = Int
1
    fromEnum SePolicyRestoreconFlags
SePolicyRestoreconFlagsKeepExisting = Int
2
    fromEnum (AnotherSePolicyRestoreconFlags Int
k) = Int
k

    toEnum :: Int -> SePolicyRestoreconFlags
toEnum Int
0 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsNone
    toEnum Int
1 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsAllowNolabel
    toEnum Int
2 = SePolicyRestoreconFlags
SePolicyRestoreconFlagsKeepExisting
    toEnum Int
k = Int -> SePolicyRestoreconFlags
AnotherSePolicyRestoreconFlags Int
k

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

instance IsGFlag SePolicyRestoreconFlags

-- Flags RepoResolveRevExtFlags
-- | /No description available in the introspection data./
data RepoResolveRevExtFlags = 
      RepoResolveRevExtFlagsNone
    -- ^ No flags.
    | RepoResolveRevExtFlagsLocalOnly
    -- ^ Exclude remote and mirrored refs. Since: 2019.2
    | AnotherRepoResolveRevExtFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoResolveRevExtFlags -> ShowS
[RepoResolveRevExtFlags] -> ShowS
RepoResolveRevExtFlags -> String
(Int -> RepoResolveRevExtFlags -> ShowS)
-> (RepoResolveRevExtFlags -> String)
-> ([RepoResolveRevExtFlags] -> ShowS)
-> Show RepoResolveRevExtFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoResolveRevExtFlags] -> ShowS
$cshowList :: [RepoResolveRevExtFlags] -> ShowS
show :: RepoResolveRevExtFlags -> String
$cshow :: RepoResolveRevExtFlags -> String
showsPrec :: Int -> RepoResolveRevExtFlags -> ShowS
$cshowsPrec :: Int -> RepoResolveRevExtFlags -> ShowS
Show, RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
(RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool)
-> (RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool)
-> Eq RepoResolveRevExtFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
$c/= :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
== :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
$c== :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Bool
Eq)

instance P.Enum RepoResolveRevExtFlags where
    fromEnum :: RepoResolveRevExtFlags -> Int
fromEnum RepoResolveRevExtFlags
RepoResolveRevExtFlagsNone = Int
0
    fromEnum RepoResolveRevExtFlags
RepoResolveRevExtFlagsLocalOnly = Int
1
    fromEnum (AnotherRepoResolveRevExtFlags Int
k) = Int
k

    toEnum :: Int -> RepoResolveRevExtFlags
toEnum Int
0 = RepoResolveRevExtFlags
RepoResolveRevExtFlagsNone
    toEnum Int
1 = RepoResolveRevExtFlags
RepoResolveRevExtFlagsLocalOnly
    toEnum Int
k = Int -> RepoResolveRevExtFlags
AnotherRepoResolveRevExtFlags Int
k

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

instance IsGFlag RepoResolveRevExtFlags

-- Flags RepoPullFlags
-- | /No description available in the introspection data./
data RepoPullFlags = 
      RepoPullFlagsNone
    -- ^ No special options for pull
    | RepoPullFlagsMirror
    -- ^ Write out refs suitable for mirrors and fetch all refs if none requested
    | RepoPullFlagsCommitOnly
    -- ^ Fetch only the commit metadata
    | RepoPullFlagsUntrusted
    -- ^ Do verify checksums of local (filesystem-accessible) repositories (defaults on for HTTP)
    | RepoPullFlagsBareuseronlyFiles
    -- ^ Since 2017.7.  Reject writes of content objects with modes outside of 0775.
    | RepoPullFlagsTrustedHttp
    -- ^ Don\'t verify checksums of objects HTTP repositories (Since: 2017.12)
    | AnotherRepoPullFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoPullFlags -> ShowS
[RepoPullFlags] -> ShowS
RepoPullFlags -> String
(Int -> RepoPullFlags -> ShowS)
-> (RepoPullFlags -> String)
-> ([RepoPullFlags] -> ShowS)
-> Show RepoPullFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoPullFlags] -> ShowS
$cshowList :: [RepoPullFlags] -> ShowS
show :: RepoPullFlags -> String
$cshow :: RepoPullFlags -> String
showsPrec :: Int -> RepoPullFlags -> ShowS
$cshowsPrec :: Int -> RepoPullFlags -> ShowS
Show, RepoPullFlags -> RepoPullFlags -> Bool
(RepoPullFlags -> RepoPullFlags -> Bool)
-> (RepoPullFlags -> RepoPullFlags -> Bool) -> Eq RepoPullFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoPullFlags -> RepoPullFlags -> Bool
$c/= :: RepoPullFlags -> RepoPullFlags -> Bool
== :: RepoPullFlags -> RepoPullFlags -> Bool
$c== :: RepoPullFlags -> RepoPullFlags -> Bool
Eq)

instance P.Enum RepoPullFlags where
    fromEnum :: RepoPullFlags -> Int
fromEnum RepoPullFlags
RepoPullFlagsNone = Int
0
    fromEnum RepoPullFlags
RepoPullFlagsMirror = Int
1
    fromEnum RepoPullFlags
RepoPullFlagsCommitOnly = Int
2
    fromEnum RepoPullFlags
RepoPullFlagsUntrusted = Int
4
    fromEnum RepoPullFlags
RepoPullFlagsBareuseronlyFiles = Int
8
    fromEnum RepoPullFlags
RepoPullFlagsTrustedHttp = Int
16
    fromEnum (AnotherRepoPullFlags Int
k) = Int
k

    toEnum :: Int -> RepoPullFlags
toEnum Int
0 = RepoPullFlags
RepoPullFlagsNone
    toEnum Int
1 = RepoPullFlags
RepoPullFlagsMirror
    toEnum Int
2 = RepoPullFlags
RepoPullFlagsCommitOnly
    toEnum Int
4 = RepoPullFlags
RepoPullFlagsUntrusted
    toEnum Int
8 = RepoPullFlags
RepoPullFlagsBareuseronlyFiles
    toEnum Int
16 = RepoPullFlags
RepoPullFlagsTrustedHttp
    toEnum Int
k = Int -> RepoPullFlags
AnotherRepoPullFlags Int
k

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

instance IsGFlag RepoPullFlags

-- Flags RepoPruneFlags
-- | /No description available in the introspection data./
data RepoPruneFlags = 
      RepoPruneFlagsNone
    -- ^ No special options for pruning
    | RepoPruneFlagsNoPrune
    -- ^ Don\'t actually delete objects
    | RepoPruneFlagsRefsOnly
    -- ^ Do not traverse individual commit objects, only follow refs
    | AnotherRepoPruneFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoPruneFlags -> ShowS
[RepoPruneFlags] -> ShowS
RepoPruneFlags -> String
(Int -> RepoPruneFlags -> ShowS)
-> (RepoPruneFlags -> String)
-> ([RepoPruneFlags] -> ShowS)
-> Show RepoPruneFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoPruneFlags] -> ShowS
$cshowList :: [RepoPruneFlags] -> ShowS
show :: RepoPruneFlags -> String
$cshow :: RepoPruneFlags -> String
showsPrec :: Int -> RepoPruneFlags -> ShowS
$cshowsPrec :: Int -> RepoPruneFlags -> ShowS
Show, RepoPruneFlags -> RepoPruneFlags -> Bool
(RepoPruneFlags -> RepoPruneFlags -> Bool)
-> (RepoPruneFlags -> RepoPruneFlags -> Bool) -> Eq RepoPruneFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoPruneFlags -> RepoPruneFlags -> Bool
$c/= :: RepoPruneFlags -> RepoPruneFlags -> Bool
== :: RepoPruneFlags -> RepoPruneFlags -> Bool
$c== :: RepoPruneFlags -> RepoPruneFlags -> Bool
Eq)

instance P.Enum RepoPruneFlags where
    fromEnum :: RepoPruneFlags -> Int
fromEnum RepoPruneFlags
RepoPruneFlagsNone = Int
0
    fromEnum RepoPruneFlags
RepoPruneFlagsNoPrune = Int
1
    fromEnum RepoPruneFlags
RepoPruneFlagsRefsOnly = Int
2
    fromEnum (AnotherRepoPruneFlags Int
k) = Int
k

    toEnum :: Int -> RepoPruneFlags
toEnum Int
0 = RepoPruneFlags
RepoPruneFlagsNone
    toEnum Int
1 = RepoPruneFlags
RepoPruneFlagsNoPrune
    toEnum Int
2 = RepoPruneFlags
RepoPruneFlagsRefsOnly
    toEnum Int
k = Int -> RepoPruneFlags
AnotherRepoPruneFlags Int
k

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

instance IsGFlag RepoPruneFlags

-- Flags RepoListRefsExtFlags
-- | /No description available in the introspection data./
data RepoListRefsExtFlags = 
      RepoListRefsExtFlagsNone
    -- ^ No flags.
    | RepoListRefsExtFlagsAliases
    -- ^ Only list aliases.  Since: 2017.10
    | RepoListRefsExtFlagsExcludeRemotes
    -- ^ Exclude remote refs.  Since: 2017.11
    | RepoListRefsExtFlagsExcludeMirrors
    -- ^ Exclude mirrored refs.  Since: 2019.2
    | AnotherRepoListRefsExtFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoListRefsExtFlags -> ShowS
[RepoListRefsExtFlags] -> ShowS
RepoListRefsExtFlags -> String
(Int -> RepoListRefsExtFlags -> ShowS)
-> (RepoListRefsExtFlags -> String)
-> ([RepoListRefsExtFlags] -> ShowS)
-> Show RepoListRefsExtFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoListRefsExtFlags] -> ShowS
$cshowList :: [RepoListRefsExtFlags] -> ShowS
show :: RepoListRefsExtFlags -> String
$cshow :: RepoListRefsExtFlags -> String
showsPrec :: Int -> RepoListRefsExtFlags -> ShowS
$cshowsPrec :: Int -> RepoListRefsExtFlags -> ShowS
Show, RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
(RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool)
-> (RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool)
-> Eq RepoListRefsExtFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
$c/= :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
== :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
$c== :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Bool
Eq)

instance P.Enum RepoListRefsExtFlags where
    fromEnum :: RepoListRefsExtFlags -> Int
fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsNone = Int
0
    fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsAliases = Int
1
    fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeRemotes = Int
2
    fromEnum RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeMirrors = Int
4
    fromEnum (AnotherRepoListRefsExtFlags Int
k) = Int
k

    toEnum :: Int -> RepoListRefsExtFlags
toEnum Int
0 = RepoListRefsExtFlags
RepoListRefsExtFlagsNone
    toEnum Int
1 = RepoListRefsExtFlags
RepoListRefsExtFlagsAliases
    toEnum Int
2 = RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeRemotes
    toEnum Int
4 = RepoListRefsExtFlags
RepoListRefsExtFlagsExcludeMirrors
    toEnum Int
k = Int -> RepoListRefsExtFlags
AnotherRepoListRefsExtFlags Int
k

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

instance IsGFlag RepoListRefsExtFlags

-- Flags RepoListObjectsFlags
-- | /No description available in the introspection data./
data RepoListObjectsFlags = 
      RepoListObjectsFlagsLoose
    -- ^ List only loose (plain file) objects
    | RepoListObjectsFlagsPacked
    -- ^ List only packed (compacted into blobs) objects
    | RepoListObjectsFlagsAll
    -- ^ List all objects
    | RepoListObjectsFlagsNoParents
    -- ^ Only list objects in this repo, not parents
    | AnotherRepoListObjectsFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoListObjectsFlags -> ShowS
[RepoListObjectsFlags] -> ShowS
RepoListObjectsFlags -> String
(Int -> RepoListObjectsFlags -> ShowS)
-> (RepoListObjectsFlags -> String)
-> ([RepoListObjectsFlags] -> ShowS)
-> Show RepoListObjectsFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoListObjectsFlags] -> ShowS
$cshowList :: [RepoListObjectsFlags] -> ShowS
show :: RepoListObjectsFlags -> String
$cshow :: RepoListObjectsFlags -> String
showsPrec :: Int -> RepoListObjectsFlags -> ShowS
$cshowsPrec :: Int -> RepoListObjectsFlags -> ShowS
Show, RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
(RepoListObjectsFlags -> RepoListObjectsFlags -> Bool)
-> (RepoListObjectsFlags -> RepoListObjectsFlags -> Bool)
-> Eq RepoListObjectsFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
$c/= :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
== :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
$c== :: RepoListObjectsFlags -> RepoListObjectsFlags -> Bool
Eq)

instance P.Enum RepoListObjectsFlags where
    fromEnum :: RepoListObjectsFlags -> Int
fromEnum RepoListObjectsFlags
RepoListObjectsFlagsLoose = Int
1
    fromEnum RepoListObjectsFlags
RepoListObjectsFlagsPacked = Int
2
    fromEnum RepoListObjectsFlags
RepoListObjectsFlagsAll = Int
4
    fromEnum RepoListObjectsFlags
RepoListObjectsFlagsNoParents = Int
8
    fromEnum (AnotherRepoListObjectsFlags Int
k) = Int
k

    toEnum :: Int -> RepoListObjectsFlags
toEnum Int
1 = RepoListObjectsFlags
RepoListObjectsFlagsLoose
    toEnum Int
2 = RepoListObjectsFlags
RepoListObjectsFlagsPacked
    toEnum Int
4 = RepoListObjectsFlags
RepoListObjectsFlagsAll
    toEnum Int
8 = RepoListObjectsFlags
RepoListObjectsFlagsNoParents
    toEnum Int
k = Int -> RepoListObjectsFlags
AnotherRepoListObjectsFlags Int
k

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

instance IsGFlag RepoListObjectsFlags

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

instance P.Enum RepoCommitTraverseFlags where
    fromEnum :: RepoCommitTraverseFlags -> Int
fromEnum RepoCommitTraverseFlags
RepoCommitTraverseFlagsRepoCommitTraverseFlagNone = Int
1
    fromEnum (AnotherRepoCommitTraverseFlags Int
k) = Int
k

    toEnum :: Int -> RepoCommitTraverseFlags
toEnum Int
1 = RepoCommitTraverseFlags
RepoCommitTraverseFlagsRepoCommitTraverseFlagNone
    toEnum Int
k = Int -> RepoCommitTraverseFlags
AnotherRepoCommitTraverseFlags Int
k

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

instance IsGFlag RepoCommitTraverseFlags

-- Flags RepoCommitState
-- | Flags representing the state of a commit in the local repository, as returned
-- by 'GI.OSTree.Objects.Repo.repoLoadCommit'.
-- 
-- /Since: 2015.7/
data RepoCommitState = 
      RepoCommitStateNormal
    -- ^ Commit is complete. This is the default.
    --    (Since: 2017.14.)
    | RepoCommitStatePartial
    -- ^ One or more objects are missing from the
    --    local copy of the commit, but metadata is present. (Since: 2015.7.)
    | RepoCommitStateFsckPartial
    -- ^ One or more objects are missing from the
    --    local copy of the commit, due to an fsck --delete. (Since: 2019.4.)
    | AnotherRepoCommitState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoCommitState -> ShowS
[RepoCommitState] -> ShowS
RepoCommitState -> String
(Int -> RepoCommitState -> ShowS)
-> (RepoCommitState -> String)
-> ([RepoCommitState] -> ShowS)
-> Show RepoCommitState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoCommitState] -> ShowS
$cshowList :: [RepoCommitState] -> ShowS
show :: RepoCommitState -> String
$cshow :: RepoCommitState -> String
showsPrec :: Int -> RepoCommitState -> ShowS
$cshowsPrec :: Int -> RepoCommitState -> ShowS
Show, RepoCommitState -> RepoCommitState -> Bool
(RepoCommitState -> RepoCommitState -> Bool)
-> (RepoCommitState -> RepoCommitState -> Bool)
-> Eq RepoCommitState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitState -> RepoCommitState -> Bool
$c/= :: RepoCommitState -> RepoCommitState -> Bool
== :: RepoCommitState -> RepoCommitState -> Bool
$c== :: RepoCommitState -> RepoCommitState -> Bool
Eq)

instance P.Enum RepoCommitState where
    fromEnum :: RepoCommitState -> Int
fromEnum RepoCommitState
RepoCommitStateNormal = Int
0
    fromEnum RepoCommitState
RepoCommitStatePartial = Int
1
    fromEnum RepoCommitState
RepoCommitStateFsckPartial = Int
2
    fromEnum (AnotherRepoCommitState Int
k) = Int
k

    toEnum :: Int -> RepoCommitState
toEnum Int
0 = RepoCommitState
RepoCommitStateNormal
    toEnum Int
1 = RepoCommitState
RepoCommitStatePartial
    toEnum Int
2 = RepoCommitState
RepoCommitStateFsckPartial
    toEnum Int
k = Int -> RepoCommitState
AnotherRepoCommitState Int
k

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

instance IsGFlag RepoCommitState

-- Flags RepoCommitModifierFlags
-- | /No description available in the introspection data./
data RepoCommitModifierFlags = 
      RepoCommitModifierFlagsNone
    -- ^ No special flags
    | RepoCommitModifierFlagsSkipXattrs
    -- ^ Do not process extended attributes
    | RepoCommitModifierFlagsGenerateSizes
    -- ^ Generate size information.
    | RepoCommitModifierFlagsCanonicalPermissions
    -- ^ Canonicalize permissions for bare-user-only mode.
    | RepoCommitModifierFlagsErrorOnUnlabeled
    -- ^ Emit an error if configured SELinux policy does not provide a label
    | RepoCommitModifierFlagsConsume
    -- ^ Delete added files\/directories after commit; Since: 2017.13
    | RepoCommitModifierFlagsDevinoCanonical
    -- ^ If a devino cache hit is found, skip modifier filters (non-directories only); Since: 2017.14
    | AnotherRepoCommitModifierFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoCommitModifierFlags -> ShowS
[RepoCommitModifierFlags] -> ShowS
RepoCommitModifierFlags -> String
(Int -> RepoCommitModifierFlags -> ShowS)
-> (RepoCommitModifierFlags -> String)
-> ([RepoCommitModifierFlags] -> ShowS)
-> Show RepoCommitModifierFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepoCommitModifierFlags] -> ShowS
$cshowList :: [RepoCommitModifierFlags] -> ShowS
show :: RepoCommitModifierFlags -> String
$cshow :: RepoCommitModifierFlags -> String
showsPrec :: Int -> RepoCommitModifierFlags -> ShowS
$cshowsPrec :: Int -> RepoCommitModifierFlags -> ShowS
Show, RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
(RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool)
-> (RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool)
-> Eq RepoCommitModifierFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
$c/= :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
== :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
$c== :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Bool
Eq)

instance P.Enum RepoCommitModifierFlags where
    fromEnum :: RepoCommitModifierFlags -> Int
fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsNone = Int
0
    fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsSkipXattrs = Int
1
    fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsGenerateSizes = Int
2
    fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsCanonicalPermissions = Int
4
    fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsErrorOnUnlabeled = Int
8
    fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsConsume = Int
16
    fromEnum RepoCommitModifierFlags
RepoCommitModifierFlagsDevinoCanonical = Int
32
    fromEnum (AnotherRepoCommitModifierFlags Int
k) = Int
k

    toEnum :: Int -> RepoCommitModifierFlags
toEnum Int
0 = RepoCommitModifierFlags
RepoCommitModifierFlagsNone
    toEnum Int
1 = RepoCommitModifierFlags
RepoCommitModifierFlagsSkipXattrs
    toEnum Int
2 = RepoCommitModifierFlags
RepoCommitModifierFlagsGenerateSizes
    toEnum Int
4 = RepoCommitModifierFlags
RepoCommitModifierFlagsCanonicalPermissions
    toEnum Int
8 = RepoCommitModifierFlags
RepoCommitModifierFlagsErrorOnUnlabeled
    toEnum Int
16 = RepoCommitModifierFlags
RepoCommitModifierFlagsConsume
    toEnum Int
32 = RepoCommitModifierFlags
RepoCommitModifierFlagsDevinoCanonical
    toEnum Int
k = Int -> RepoCommitModifierFlags
AnotherRepoCommitModifierFlags Int
k

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

instance IsGFlag RepoCommitModifierFlags

-- Flags GpgSignatureFormatFlags
-- | Formatting flags for 'GI.OSTree.Objects.GpgVerifyResult.gpgVerifyResultDescribe'.  Currently
-- there\'s only one possible output format, but this enumeration allows
-- for future variations.
data GpgSignatureFormatFlags = 
      GpgSignatureFormatFlagsGpgSignatureFormatDefault
    -- ^ Use the default output format
    | AnotherGpgSignatureFormatFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GpgSignatureFormatFlags -> ShowS
[GpgSignatureFormatFlags] -> ShowS
GpgSignatureFormatFlags -> String
(Int -> GpgSignatureFormatFlags -> ShowS)
-> (GpgSignatureFormatFlags -> String)
-> ([GpgSignatureFormatFlags] -> ShowS)
-> Show GpgSignatureFormatFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GpgSignatureFormatFlags] -> ShowS
$cshowList :: [GpgSignatureFormatFlags] -> ShowS
show :: GpgSignatureFormatFlags -> String
$cshow :: GpgSignatureFormatFlags -> String
showsPrec :: Int -> GpgSignatureFormatFlags -> ShowS
$cshowsPrec :: Int -> GpgSignatureFormatFlags -> ShowS
Show, GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
(GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool)
-> (GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool)
-> Eq GpgSignatureFormatFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
$c/= :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
== :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
$c== :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Bool
Eq)

instance P.Enum GpgSignatureFormatFlags where
    fromEnum :: GpgSignatureFormatFlags -> Int
fromEnum GpgSignatureFormatFlags
GpgSignatureFormatFlagsGpgSignatureFormatDefault = Int
0
    fromEnum (AnotherGpgSignatureFormatFlags Int
k) = Int
k

    toEnum :: Int -> GpgSignatureFormatFlags
toEnum Int
0 = GpgSignatureFormatFlags
GpgSignatureFormatFlagsGpgSignatureFormatDefault
    toEnum Int
k = Int -> GpgSignatureFormatFlags
AnotherGpgSignatureFormatFlags Int
k

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

instance IsGFlag GpgSignatureFormatFlags

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

instance P.Enum DiffFlags where
    fromEnum :: DiffFlags -> Int
fromEnum DiffFlags
DiffFlagsNone = Int
0
    fromEnum DiffFlags
DiffFlagsIgnoreXattrs = Int
1
    fromEnum (AnotherDiffFlags Int
k) = Int
k

    toEnum :: Int -> DiffFlags
toEnum Int
0 = DiffFlags
DiffFlagsNone
    toEnum Int
1 = DiffFlags
DiffFlagsIgnoreXattrs
    toEnum Int
k = Int -> DiffFlags
AnotherDiffFlags Int
k

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

instance IsGFlag DiffFlags

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

instance P.Enum ChecksumFlags where
    fromEnum :: ChecksumFlags -> Int
fromEnum ChecksumFlags
ChecksumFlagsNone = Int
0
    fromEnum ChecksumFlags
ChecksumFlagsIgnoreXattrs = Int
1
    fromEnum (AnotherChecksumFlags Int
k) = Int
k

    toEnum :: Int -> ChecksumFlags
toEnum Int
0 = ChecksumFlags
ChecksumFlagsNone
    toEnum Int
1 = ChecksumFlags
ChecksumFlagsIgnoreXattrs
    toEnum Int
k = Int -> ChecksumFlags
AnotherChecksumFlags Int
k

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

instance IsGFlag ChecksumFlags