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


-- 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 SysrootUpgraderPullFlagsNone = 0
    fromEnum SysrootUpgraderPullFlagsAllowOlder = 1
    fromEnum SysrootUpgraderPullFlagsSynthetic = 2
    fromEnum (AnotherSysrootUpgraderPullFlags k :: Int
k) = Int
k

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

instance P.Ord SysrootUpgraderPullFlags where
    compare :: SysrootUpgraderPullFlags -> SysrootUpgraderPullFlags -> Ordering
compare a :: SysrootUpgraderPullFlags
a b :: 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 SysrootUpgraderFlagsIgnoreUnconfigured = 2
    fromEnum (AnotherSysrootUpgraderFlags k :: Int
k) = Int
k

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

instance P.Ord SysrootUpgraderFlags where
    compare :: SysrootUpgraderFlags -> SysrootUpgraderFlags -> Ordering
compare a :: SysrootUpgraderFlags
a b :: 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 SysrootSimpleWriteDeploymentFlagsNone = 0
    fromEnum SysrootSimpleWriteDeploymentFlagsRetain = 1
    fromEnum SysrootSimpleWriteDeploymentFlagsNotDefault = 2
    fromEnum SysrootSimpleWriteDeploymentFlagsNoClean = 4
    fromEnum SysrootSimpleWriteDeploymentFlagsRetainPending = 8
    fromEnum SysrootSimpleWriteDeploymentFlagsRetainRollback = 16
    fromEnum (AnotherSysrootSimpleWriteDeploymentFlags k :: Int
k) = Int
k

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

instance P.Ord SysrootSimpleWriteDeploymentFlags where
    compare :: SysrootSimpleWriteDeploymentFlags
-> SysrootSimpleWriteDeploymentFlags -> Ordering
compare a :: SysrootSimpleWriteDeploymentFlags
a b :: 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 SePolicyRestoreconFlagsNone = 0
    fromEnum SePolicyRestoreconFlagsAllowNolabel = 1
    fromEnum SePolicyRestoreconFlagsKeepExisting = 2
    fromEnum (AnotherSePolicyRestoreconFlags k :: Int
k) = Int
k

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

instance P.Ord SePolicyRestoreconFlags where
    compare :: SePolicyRestoreconFlags -> SePolicyRestoreconFlags -> Ordering
compare a :: SePolicyRestoreconFlags
a b :: 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 RepoResolveRevExtFlagsNone = 0
    fromEnum RepoResolveRevExtFlagsLocalOnly = 1
    fromEnum (AnotherRepoResolveRevExtFlags k :: Int
k) = Int
k

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

instance P.Ord RepoResolveRevExtFlags where
    compare :: RepoResolveRevExtFlags -> RepoResolveRevExtFlags -> Ordering
compare a :: RepoResolveRevExtFlags
a b :: 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 RepoPullFlagsNone = 0
    fromEnum RepoPullFlagsMirror = 1
    fromEnum RepoPullFlagsCommitOnly = 2
    fromEnum RepoPullFlagsUntrusted = 4
    fromEnum RepoPullFlagsBareuseronlyFiles = 8
    fromEnum RepoPullFlagsTrustedHttp = 16
    fromEnum (AnotherRepoPullFlags k :: Int
k) = Int
k

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

instance P.Ord RepoPullFlags where
    compare :: RepoPullFlags -> RepoPullFlags -> Ordering
compare a :: RepoPullFlags
a b :: 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 RepoPruneFlagsNone = 0
    fromEnum RepoPruneFlagsNoPrune = 1
    fromEnum RepoPruneFlagsRefsOnly = 2
    fromEnum (AnotherRepoPruneFlags k :: Int
k) = Int
k

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

instance P.Ord RepoPruneFlags where
    compare :: RepoPruneFlags -> RepoPruneFlags -> Ordering
compare a :: RepoPruneFlags
a b :: 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 RepoListRefsExtFlagsNone = 0
    fromEnum RepoListRefsExtFlagsAliases = 1
    fromEnum RepoListRefsExtFlagsExcludeRemotes = 2
    fromEnum RepoListRefsExtFlagsExcludeMirrors = 4
    fromEnum (AnotherRepoListRefsExtFlags k :: Int
k) = Int
k

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

instance P.Ord RepoListRefsExtFlags where
    compare :: RepoListRefsExtFlags -> RepoListRefsExtFlags -> Ordering
compare a :: RepoListRefsExtFlags
a b :: 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 RepoListObjectsFlagsLoose = 1
    fromEnum RepoListObjectsFlagsPacked = 2
    fromEnum RepoListObjectsFlagsAll = 4
    fromEnum RepoListObjectsFlagsNoParents = 8
    fromEnum (AnotherRepoListObjectsFlags k :: Int
k) = Int
k

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

instance P.Ord RepoListObjectsFlags where
    compare :: RepoListObjectsFlags -> RepoListObjectsFlags -> Ordering
compare a :: RepoListObjectsFlags
a b :: 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 RepoCommitTraverseFlagsRepoCommitTraverseFlagNone = 1
    fromEnum (AnotherRepoCommitTraverseFlags k :: Int
k) = Int
k

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

instance P.Ord RepoCommitTraverseFlags where
    compare :: RepoCommitTraverseFlags -> RepoCommitTraverseFlags -> Ordering
compare a :: RepoCommitTraverseFlags
a b :: 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 RepoCommitStateNormal = 0
    fromEnum RepoCommitStatePartial = 1
    fromEnum RepoCommitStateFsckPartial = 2
    fromEnum (AnotherRepoCommitState k :: Int
k) = Int
k

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

instance P.Ord RepoCommitState where
    compare :: RepoCommitState -> RepoCommitState -> Ordering
compare a :: RepoCommitState
a b :: 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 RepoCommitModifierFlagsNone = 0
    fromEnum RepoCommitModifierFlagsSkipXattrs = 1
    fromEnum RepoCommitModifierFlagsGenerateSizes = 2
    fromEnum RepoCommitModifierFlagsCanonicalPermissions = 4
    fromEnum RepoCommitModifierFlagsErrorOnUnlabeled = 8
    fromEnum RepoCommitModifierFlagsConsume = 16
    fromEnum RepoCommitModifierFlagsDevinoCanonical = 32
    fromEnum (AnotherRepoCommitModifierFlags k :: Int
k) = Int
k

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

instance P.Ord RepoCommitModifierFlags where
    compare :: RepoCommitModifierFlags -> RepoCommitModifierFlags -> Ordering
compare a :: RepoCommitModifierFlags
a b :: 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 GpgSignatureFormatFlagsGpgSignatureFormatDefault = 0
    fromEnum (AnotherGpgSignatureFormatFlags k :: Int
k) = Int
k

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

instance P.Ord GpgSignatureFormatFlags where
    compare :: GpgSignatureFormatFlags -> GpgSignatureFormatFlags -> Ordering
compare a :: GpgSignatureFormatFlags
a b :: 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 DiffFlagsNone = 0
    fromEnum DiffFlagsIgnoreXattrs = 1
    fromEnum (AnotherDiffFlags k :: Int
k) = Int
k

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

instance P.Ord DiffFlags where
    compare :: DiffFlags -> DiffFlags -> Ordering
compare a :: DiffFlags
a b :: 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 ChecksumFlagsNone = 0
    fromEnum ChecksumFlagsIgnoreXattrs = 1
    fromEnum (AnotherChecksumFlags k :: Int
k) = Int
k

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

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