-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.OSTree.Enums
    ( 

 -- * Enumerations


-- ** DeploymentUnlockedState #enum:DeploymentUnlockedState#

    DeploymentUnlockedState(..)             ,


-- ** GpgError #enum:GpgError#

    GpgError(..)                            ,
    catchGpgError                           ,
    handleGpgError                          ,


-- ** GpgSignatureAttr #enum:GpgSignatureAttr#

    GpgSignatureAttr(..)                    ,


-- ** ObjectType #enum:ObjectType#

    ObjectType(..)                          ,


-- ** RepoCheckoutFilterResult #enum:RepoCheckoutFilterResult#

    RepoCheckoutFilterResult(..)            ,


-- ** RepoCheckoutMode #enum:RepoCheckoutMode#

    RepoCheckoutMode(..)                    ,


-- ** RepoCheckoutOverwriteMode #enum:RepoCheckoutOverwriteMode#

    RepoCheckoutOverwriteMode(..)           ,


-- ** RepoCommitFilterResult #enum:RepoCommitFilterResult#

    RepoCommitFilterResult(..)              ,


-- ** RepoCommitIterResult #enum:RepoCommitIterResult#

    RepoCommitIterResult(..)                ,


-- ** RepoLockType #enum:RepoLockType#

    RepoLockType(..)                        ,


-- ** RepoMode #enum:RepoMode#

    RepoMode(..)                            ,


-- ** RepoRemoteChange #enum:RepoRemoteChange#

    RepoRemoteChange(..)                    ,


-- ** StaticDeltaGenerateOpt #enum:StaticDeltaGenerateOpt#

    StaticDeltaGenerateOpt(..)              ,


-- ** StaticDeltaIndexFlags #enum:StaticDeltaIndexFlags#

    StaticDeltaIndexFlags(..)               ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.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


-- Enum StaticDeltaIndexFlags
-- | Flags controlling static delta index generation.
data StaticDeltaIndexFlags = 
      StaticDeltaIndexFlagsStaticDeltaIndexFlagsNone
    -- ^ No special flags
    | AnotherStaticDeltaIndexFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StaticDeltaIndexFlags -> ShowS
[StaticDeltaIndexFlags] -> ShowS
StaticDeltaIndexFlags -> String
(Int -> StaticDeltaIndexFlags -> ShowS)
-> (StaticDeltaIndexFlags -> String)
-> ([StaticDeltaIndexFlags] -> ShowS)
-> Show StaticDeltaIndexFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StaticDeltaIndexFlags -> ShowS
showsPrec :: Int -> StaticDeltaIndexFlags -> ShowS
$cshow :: StaticDeltaIndexFlags -> String
show :: StaticDeltaIndexFlags -> String
$cshowList :: [StaticDeltaIndexFlags] -> ShowS
showList :: [StaticDeltaIndexFlags] -> ShowS
Show, StaticDeltaIndexFlags -> StaticDeltaIndexFlags -> Bool
(StaticDeltaIndexFlags -> StaticDeltaIndexFlags -> Bool)
-> (StaticDeltaIndexFlags -> StaticDeltaIndexFlags -> Bool)
-> Eq StaticDeltaIndexFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StaticDeltaIndexFlags -> StaticDeltaIndexFlags -> Bool
== :: StaticDeltaIndexFlags -> StaticDeltaIndexFlags -> Bool
$c/= :: StaticDeltaIndexFlags -> StaticDeltaIndexFlags -> Bool
/= :: StaticDeltaIndexFlags -> StaticDeltaIndexFlags -> Bool
Eq)

instance P.Enum StaticDeltaIndexFlags where
    fromEnum :: StaticDeltaIndexFlags -> Int
fromEnum StaticDeltaIndexFlags
StaticDeltaIndexFlagsStaticDeltaIndexFlagsNone = Int
0
    fromEnum (AnotherStaticDeltaIndexFlags Int
k) = Int
k

    toEnum :: Int -> StaticDeltaIndexFlags
toEnum Int
0 = StaticDeltaIndexFlags
StaticDeltaIndexFlagsStaticDeltaIndexFlagsNone
    toEnum Int
k = Int -> StaticDeltaIndexFlags
AnotherStaticDeltaIndexFlags Int
k

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

-- Enum StaticDeltaGenerateOpt
-- | Parameters controlling optimization of static deltas.
data StaticDeltaGenerateOpt = 
      StaticDeltaGenerateOptLowlatency
    -- ^ Optimize for speed of delta creation over space
    | StaticDeltaGenerateOptMajor
    -- ^ Optimize for delta size (may be very slow)
    | AnotherStaticDeltaGenerateOpt Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StaticDeltaGenerateOpt -> ShowS
[StaticDeltaGenerateOpt] -> ShowS
StaticDeltaGenerateOpt -> String
(Int -> StaticDeltaGenerateOpt -> ShowS)
-> (StaticDeltaGenerateOpt -> String)
-> ([StaticDeltaGenerateOpt] -> ShowS)
-> Show StaticDeltaGenerateOpt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StaticDeltaGenerateOpt -> ShowS
showsPrec :: Int -> StaticDeltaGenerateOpt -> ShowS
$cshow :: StaticDeltaGenerateOpt -> String
show :: StaticDeltaGenerateOpt -> String
$cshowList :: [StaticDeltaGenerateOpt] -> ShowS
showList :: [StaticDeltaGenerateOpt] -> ShowS
Show, StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Bool
(StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Bool)
-> (StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Bool)
-> Eq StaticDeltaGenerateOpt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Bool
== :: StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Bool
$c/= :: StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Bool
/= :: StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Bool
Eq)

instance P.Enum StaticDeltaGenerateOpt where
    fromEnum :: StaticDeltaGenerateOpt -> Int
fromEnum StaticDeltaGenerateOpt
StaticDeltaGenerateOptLowlatency = Int
0
    fromEnum StaticDeltaGenerateOpt
StaticDeltaGenerateOptMajor = Int
1
    fromEnum (AnotherStaticDeltaGenerateOpt Int
k) = Int
k

    toEnum :: Int -> StaticDeltaGenerateOpt
toEnum Int
0 = StaticDeltaGenerateOpt
StaticDeltaGenerateOptLowlatency
    toEnum Int
1 = StaticDeltaGenerateOpt
StaticDeltaGenerateOptMajor
    toEnum Int
k = Int -> StaticDeltaGenerateOpt
AnotherStaticDeltaGenerateOpt Int
k

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

-- Enum RepoRemoteChange
-- | The remote change operation.
data RepoRemoteChange = 
      RepoRemoteChangeAdd
    -- ^ Add a remote
    | RepoRemoteChangeAddIfNotExists
    -- ^ Like above, but do nothing if the remote exists
    | RepoRemoteChangeDelete
    -- ^ Delete a remote
    | RepoRemoteChangeDeleteIfExists
    -- ^ Delete a remote, do nothing if the remote does not exist
    | RepoRemoteChangeReplace
    -- ^ Add or replace a remote (Since: 2019.2)
    | AnotherRepoRemoteChange Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoRemoteChange -> ShowS
[RepoRemoteChange] -> ShowS
RepoRemoteChange -> String
(Int -> RepoRemoteChange -> ShowS)
-> (RepoRemoteChange -> String)
-> ([RepoRemoteChange] -> ShowS)
-> Show RepoRemoteChange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoRemoteChange -> ShowS
showsPrec :: Int -> RepoRemoteChange -> ShowS
$cshow :: RepoRemoteChange -> String
show :: RepoRemoteChange -> String
$cshowList :: [RepoRemoteChange] -> ShowS
showList :: [RepoRemoteChange] -> ShowS
Show, RepoRemoteChange -> RepoRemoteChange -> Bool
(RepoRemoteChange -> RepoRemoteChange -> Bool)
-> (RepoRemoteChange -> RepoRemoteChange -> Bool)
-> Eq RepoRemoteChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoRemoteChange -> RepoRemoteChange -> Bool
== :: RepoRemoteChange -> RepoRemoteChange -> Bool
$c/= :: RepoRemoteChange -> RepoRemoteChange -> Bool
/= :: RepoRemoteChange -> RepoRemoteChange -> Bool
Eq)

instance P.Enum RepoRemoteChange where
    fromEnum :: RepoRemoteChange -> Int
fromEnum RepoRemoteChange
RepoRemoteChangeAdd = Int
0
    fromEnum RepoRemoteChange
RepoRemoteChangeAddIfNotExists = Int
1
    fromEnum RepoRemoteChange
RepoRemoteChangeDelete = Int
2
    fromEnum RepoRemoteChange
RepoRemoteChangeDeleteIfExists = Int
3
    fromEnum RepoRemoteChange
RepoRemoteChangeReplace = Int
4
    fromEnum (AnotherRepoRemoteChange Int
k) = Int
k

    toEnum :: Int -> RepoRemoteChange
toEnum Int
0 = RepoRemoteChange
RepoRemoteChangeAdd
    toEnum Int
1 = RepoRemoteChange
RepoRemoteChangeAddIfNotExists
    toEnum Int
2 = RepoRemoteChange
RepoRemoteChangeDelete
    toEnum Int
3 = RepoRemoteChange
RepoRemoteChangeDeleteIfExists
    toEnum Int
4 = RepoRemoteChange
RepoRemoteChangeReplace
    toEnum Int
k = Int -> RepoRemoteChange
AnotherRepoRemoteChange Int
k

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

-- Enum RepoMode
-- | See the documentation of t'GI.OSTree.Objects.Repo.Repo' for more information about the
-- possible modes.
data RepoMode = 
      RepoModeBare
    -- ^ Files are stored as themselves; checkouts are hardlinks; can only be written as root
    | RepoModeArchive
    -- ^ Files are compressed, should be owned by non-root.  Can be served via HTTP.  Since: 2017.12
    | RepoModeArchiveZ2
    -- ^ Legacy alias for @OSTREE_REPO_MODE_ARCHIVE@
    | RepoModeBareUser
    -- ^ Files are stored as themselves, except ownership; can be written by user. Hardlinks work only in user checkouts.
    | RepoModeBareUserOnly
    -- ^ Same as BARE_USER, but all metadata is not stored, so it can only be used for user checkouts. Does not need xattrs.
    | RepoModeBareSplitXattrs
    -- ^ Same as BARE_USER, but xattrs are stored separately from file content, with dedicated object types.
    | AnotherRepoMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoMode -> ShowS
[RepoMode] -> ShowS
RepoMode -> String
(Int -> RepoMode -> ShowS)
-> (RepoMode -> String) -> ([RepoMode] -> ShowS) -> Show RepoMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoMode -> ShowS
showsPrec :: Int -> RepoMode -> ShowS
$cshow :: RepoMode -> String
show :: RepoMode -> String
$cshowList :: [RepoMode] -> ShowS
showList :: [RepoMode] -> ShowS
Show, RepoMode -> RepoMode -> Bool
(RepoMode -> RepoMode -> Bool)
-> (RepoMode -> RepoMode -> Bool) -> Eq RepoMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoMode -> RepoMode -> Bool
== :: RepoMode -> RepoMode -> Bool
$c/= :: RepoMode -> RepoMode -> Bool
/= :: RepoMode -> RepoMode -> Bool
Eq)

instance P.Enum RepoMode where
    fromEnum :: RepoMode -> Int
fromEnum RepoMode
RepoModeBare = Int
0
    fromEnum RepoMode
RepoModeArchive = Int
1
    fromEnum RepoMode
RepoModeArchiveZ2 = Int
1
    fromEnum RepoMode
RepoModeBareUser = Int
2
    fromEnum RepoMode
RepoModeBareUserOnly = Int
3
    fromEnum RepoMode
RepoModeBareSplitXattrs = Int
4
    fromEnum (AnotherRepoMode Int
k) = Int
k

    toEnum :: Int -> RepoMode
toEnum Int
0 = RepoMode
RepoModeBare
    toEnum Int
1 = RepoMode
RepoModeArchive
    toEnum Int
2 = RepoMode
RepoModeBareUser
    toEnum Int
3 = RepoMode
RepoModeBareUserOnly
    toEnum Int
4 = RepoMode
RepoModeBareSplitXattrs
    toEnum Int
k = Int -> RepoMode
AnotherRepoMode Int
k

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

-- Enum RepoLockType
-- | Flags controlling repository locking.
-- 
-- /Since: 2021.3/
data RepoLockType = 
      RepoLockTypeShared
    -- ^ A \"read only\" lock; multiple readers are allowed.
    | RepoLockTypeExclusive
    -- ^ A writable lock at most one writer can be active, and zero readers.
    | AnotherRepoLockType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoLockType -> ShowS
[RepoLockType] -> ShowS
RepoLockType -> String
(Int -> RepoLockType -> ShowS)
-> (RepoLockType -> String)
-> ([RepoLockType] -> ShowS)
-> Show RepoLockType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoLockType -> ShowS
showsPrec :: Int -> RepoLockType -> ShowS
$cshow :: RepoLockType -> String
show :: RepoLockType -> String
$cshowList :: [RepoLockType] -> ShowS
showList :: [RepoLockType] -> ShowS
Show, RepoLockType -> RepoLockType -> Bool
(RepoLockType -> RepoLockType -> Bool)
-> (RepoLockType -> RepoLockType -> Bool) -> Eq RepoLockType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoLockType -> RepoLockType -> Bool
== :: RepoLockType -> RepoLockType -> Bool
$c/= :: RepoLockType -> RepoLockType -> Bool
/= :: RepoLockType -> RepoLockType -> Bool
Eq)

instance P.Enum RepoLockType where
    fromEnum :: RepoLockType -> Int
fromEnum RepoLockType
RepoLockTypeShared = Int
0
    fromEnum RepoLockType
RepoLockTypeExclusive = Int
1
    fromEnum (AnotherRepoLockType Int
k) = Int
k

    toEnum :: Int -> RepoLockType
toEnum Int
0 = RepoLockType
RepoLockTypeShared
    toEnum Int
1 = RepoLockType
RepoLockTypeExclusive
    toEnum Int
k = Int -> RepoLockType
AnotherRepoLockType Int
k

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

-- Enum RepoCommitIterResult
-- | /No description available in the introspection data./
data RepoCommitIterResult = 
      RepoCommitIterResultError
    -- ^ /No description available in the introspection data./
    | RepoCommitIterResultEnd
    -- ^ /No description available in the introspection data./
    | RepoCommitIterResultFile
    -- ^ /No description available in the introspection data./
    | RepoCommitIterResultDir
    -- ^ /No description available in the introspection data./
    | AnotherRepoCommitIterResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoCommitIterResult -> ShowS
[RepoCommitIterResult] -> ShowS
RepoCommitIterResult -> String
(Int -> RepoCommitIterResult -> ShowS)
-> (RepoCommitIterResult -> String)
-> ([RepoCommitIterResult] -> ShowS)
-> Show RepoCommitIterResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoCommitIterResult -> ShowS
showsPrec :: Int -> RepoCommitIterResult -> ShowS
$cshow :: RepoCommitIterResult -> String
show :: RepoCommitIterResult -> String
$cshowList :: [RepoCommitIterResult] -> ShowS
showList :: [RepoCommitIterResult] -> ShowS
Show, RepoCommitIterResult -> RepoCommitIterResult -> Bool
(RepoCommitIterResult -> RepoCommitIterResult -> Bool)
-> (RepoCommitIterResult -> RepoCommitIterResult -> Bool)
-> Eq RepoCommitIterResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
== :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
$c/= :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
/= :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
Eq)

instance P.Enum RepoCommitIterResult where
    fromEnum :: RepoCommitIterResult -> Int
fromEnum RepoCommitIterResult
RepoCommitIterResultError = Int
0
    fromEnum RepoCommitIterResult
RepoCommitIterResultEnd = Int
1
    fromEnum RepoCommitIterResult
RepoCommitIterResultFile = Int
2
    fromEnum RepoCommitIterResult
RepoCommitIterResultDir = Int
3
    fromEnum (AnotherRepoCommitIterResult Int
k) = Int
k

    toEnum :: Int -> RepoCommitIterResult
toEnum Int
0 = RepoCommitIterResult
RepoCommitIterResultError
    toEnum Int
1 = RepoCommitIterResult
RepoCommitIterResultEnd
    toEnum Int
2 = RepoCommitIterResult
RepoCommitIterResultFile
    toEnum Int
3 = RepoCommitIterResult
RepoCommitIterResultDir
    toEnum Int
k = Int -> RepoCommitIterResult
AnotherRepoCommitIterResult Int
k

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

-- Enum RepoCommitFilterResult
-- | /No description available in the introspection data./
data RepoCommitFilterResult = 
      RepoCommitFilterResultAllow
    -- ^ Do commit this object
    | RepoCommitFilterResultSkip
    -- ^ Ignore this object
    | AnotherRepoCommitFilterResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoCommitFilterResult -> ShowS
[RepoCommitFilterResult] -> ShowS
RepoCommitFilterResult -> String
(Int -> RepoCommitFilterResult -> ShowS)
-> (RepoCommitFilterResult -> String)
-> ([RepoCommitFilterResult] -> ShowS)
-> Show RepoCommitFilterResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoCommitFilterResult -> ShowS
showsPrec :: Int -> RepoCommitFilterResult -> ShowS
$cshow :: RepoCommitFilterResult -> String
show :: RepoCommitFilterResult -> String
$cshowList :: [RepoCommitFilterResult] -> ShowS
showList :: [RepoCommitFilterResult] -> ShowS
Show, RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
(RepoCommitFilterResult -> RepoCommitFilterResult -> Bool)
-> (RepoCommitFilterResult -> RepoCommitFilterResult -> Bool)
-> Eq RepoCommitFilterResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
== :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
$c/= :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
/= :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
Eq)

instance P.Enum RepoCommitFilterResult where
    fromEnum :: RepoCommitFilterResult -> Int
fromEnum RepoCommitFilterResult
RepoCommitFilterResultAllow = Int
0
    fromEnum RepoCommitFilterResult
RepoCommitFilterResultSkip = Int
1
    fromEnum (AnotherRepoCommitFilterResult Int
k) = Int
k

    toEnum :: Int -> RepoCommitFilterResult
toEnum Int
0 = RepoCommitFilterResult
RepoCommitFilterResultAllow
    toEnum Int
1 = RepoCommitFilterResult
RepoCommitFilterResultSkip
    toEnum Int
k = Int -> RepoCommitFilterResult
AnotherRepoCommitFilterResult Int
k

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

-- Enum RepoCheckoutOverwriteMode
-- | /No description available in the introspection data./
data RepoCheckoutOverwriteMode = 
      RepoCheckoutOverwriteModeNone
    -- ^ No special options
    | RepoCheckoutOverwriteModeUnionFiles
    -- ^ When layering checkouts, @/unlink()/@ and replace existing files, but do not modify existing directories (unless whiteouts are enabled, then directories are replaced)
    | RepoCheckoutOverwriteModeAddFiles
    -- ^ Only add new files\/directories
    | RepoCheckoutOverwriteModeUnionIdentical
    -- ^ Like UNION_FILES, but error if files are not identical (requires hardlink checkouts)
    | AnotherRepoCheckoutOverwriteMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoCheckoutOverwriteMode -> ShowS
[RepoCheckoutOverwriteMode] -> ShowS
RepoCheckoutOverwriteMode -> String
(Int -> RepoCheckoutOverwriteMode -> ShowS)
-> (RepoCheckoutOverwriteMode -> String)
-> ([RepoCheckoutOverwriteMode] -> ShowS)
-> Show RepoCheckoutOverwriteMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoCheckoutOverwriteMode -> ShowS
showsPrec :: Int -> RepoCheckoutOverwriteMode -> ShowS
$cshow :: RepoCheckoutOverwriteMode -> String
show :: RepoCheckoutOverwriteMode -> String
$cshowList :: [RepoCheckoutOverwriteMode] -> ShowS
showList :: [RepoCheckoutOverwriteMode] -> ShowS
Show, RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
(RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool)
-> (RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool)
-> Eq RepoCheckoutOverwriteMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
== :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
$c/= :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
/= :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
Eq)

instance P.Enum RepoCheckoutOverwriteMode where
    fromEnum :: RepoCheckoutOverwriteMode -> Int
fromEnum RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeNone = Int
0
    fromEnum RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeUnionFiles = Int
1
    fromEnum RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeAddFiles = Int
2
    fromEnum RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeUnionIdentical = Int
3
    fromEnum (AnotherRepoCheckoutOverwriteMode Int
k) = Int
k

    toEnum :: Int -> RepoCheckoutOverwriteMode
toEnum Int
0 = RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeNone
    toEnum Int
1 = RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeUnionFiles
    toEnum Int
2 = RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeAddFiles
    toEnum Int
3 = RepoCheckoutOverwriteMode
RepoCheckoutOverwriteModeUnionIdentical
    toEnum Int
k = Int -> RepoCheckoutOverwriteMode
AnotherRepoCheckoutOverwriteMode Int
k

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

-- Enum RepoCheckoutMode
-- | /No description available in the introspection data./
data RepoCheckoutMode = 
      RepoCheckoutModeNone
    -- ^ No special options
    | RepoCheckoutModeUser
    -- ^ Ignore uid\/gid of files
    | AnotherRepoCheckoutMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoCheckoutMode -> ShowS
[RepoCheckoutMode] -> ShowS
RepoCheckoutMode -> String
(Int -> RepoCheckoutMode -> ShowS)
-> (RepoCheckoutMode -> String)
-> ([RepoCheckoutMode] -> ShowS)
-> Show RepoCheckoutMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoCheckoutMode -> ShowS
showsPrec :: Int -> RepoCheckoutMode -> ShowS
$cshow :: RepoCheckoutMode -> String
show :: RepoCheckoutMode -> String
$cshowList :: [RepoCheckoutMode] -> ShowS
showList :: [RepoCheckoutMode] -> ShowS
Show, RepoCheckoutMode -> RepoCheckoutMode -> Bool
(RepoCheckoutMode -> RepoCheckoutMode -> Bool)
-> (RepoCheckoutMode -> RepoCheckoutMode -> Bool)
-> Eq RepoCheckoutMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
== :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
$c/= :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
/= :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
Eq)

instance P.Enum RepoCheckoutMode where
    fromEnum :: RepoCheckoutMode -> Int
fromEnum RepoCheckoutMode
RepoCheckoutModeNone = Int
0
    fromEnum RepoCheckoutMode
RepoCheckoutModeUser = Int
1
    fromEnum (AnotherRepoCheckoutMode Int
k) = Int
k

    toEnum :: Int -> RepoCheckoutMode
toEnum Int
0 = RepoCheckoutMode
RepoCheckoutModeNone
    toEnum Int
1 = RepoCheckoutMode
RepoCheckoutModeUser
    toEnum Int
k = Int -> RepoCheckoutMode
AnotherRepoCheckoutMode Int
k

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

-- Enum RepoCheckoutFilterResult
-- | /No description available in the introspection data./
-- 
-- /Since: 2018.2/
data RepoCheckoutFilterResult = 
      RepoCheckoutFilterResultAllow
    -- ^ Do checkout this object
    | RepoCheckoutFilterResultSkip
    -- ^ Ignore this object
    | AnotherRepoCheckoutFilterResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RepoCheckoutFilterResult -> ShowS
[RepoCheckoutFilterResult] -> ShowS
RepoCheckoutFilterResult -> String
(Int -> RepoCheckoutFilterResult -> ShowS)
-> (RepoCheckoutFilterResult -> String)
-> ([RepoCheckoutFilterResult] -> ShowS)
-> Show RepoCheckoutFilterResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepoCheckoutFilterResult -> ShowS
showsPrec :: Int -> RepoCheckoutFilterResult -> ShowS
$cshow :: RepoCheckoutFilterResult -> String
show :: RepoCheckoutFilterResult -> String
$cshowList :: [RepoCheckoutFilterResult] -> ShowS
showList :: [RepoCheckoutFilterResult] -> ShowS
Show, RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
(RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool)
-> (RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool)
-> Eq RepoCheckoutFilterResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
== :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
$c/= :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
/= :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
Eq)

instance P.Enum RepoCheckoutFilterResult where
    fromEnum :: RepoCheckoutFilterResult -> Int
fromEnum RepoCheckoutFilterResult
RepoCheckoutFilterResultAllow = Int
0
    fromEnum RepoCheckoutFilterResult
RepoCheckoutFilterResultSkip = Int
1
    fromEnum (AnotherRepoCheckoutFilterResult Int
k) = Int
k

    toEnum :: Int -> RepoCheckoutFilterResult
toEnum Int
0 = RepoCheckoutFilterResult
RepoCheckoutFilterResultAllow
    toEnum Int
1 = RepoCheckoutFilterResult
RepoCheckoutFilterResultSkip
    toEnum Int
k = Int -> RepoCheckoutFilterResult
AnotherRepoCheckoutFilterResult Int
k

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

-- Enum ObjectType
-- | Enumeration for core object types; 'GI.OSTree.Enums.ObjectTypeFile' is for
-- content, the other types are metadata.
data ObjectType = 
      ObjectTypeFile
    -- ^ Content; regular file, symbolic link
    | ObjectTypeDirTree
    -- ^ List of children (trees or files), and metadata
    | ObjectTypeDirMeta
    -- ^ Directory metadata
    | ObjectTypeCommit
    -- ^ Toplevel object, refers to tree and dirmeta for root
    | ObjectTypeTombstoneCommit
    -- ^ Toplevel object, refers to a deleted commit
    | ObjectTypeCommitMeta
    -- ^ Detached metadata for a commit
    | ObjectTypePayloadLink
    -- ^ Symlink to a .file given its checksum on the payload only.
    | ObjectTypeFileXattrs
    -- ^ Detached xattrs content, for \'bare-split-xattrs\' mode.
    | ObjectTypeFileXattrsLink
    -- ^ Hardlink to a .file-xattrs given the checksum of its .file object.
    | AnotherObjectType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ObjectType -> ShowS
[ObjectType] -> ShowS
ObjectType -> String
(Int -> ObjectType -> ShowS)
-> (ObjectType -> String)
-> ([ObjectType] -> ShowS)
-> Show ObjectType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ObjectType -> ShowS
showsPrec :: Int -> ObjectType -> ShowS
$cshow :: ObjectType -> String
show :: ObjectType -> String
$cshowList :: [ObjectType] -> ShowS
showList :: [ObjectType] -> ShowS
Show, ObjectType -> ObjectType -> Bool
(ObjectType -> ObjectType -> Bool)
-> (ObjectType -> ObjectType -> Bool) -> Eq ObjectType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectType -> ObjectType -> Bool
== :: ObjectType -> ObjectType -> Bool
$c/= :: ObjectType -> ObjectType -> Bool
/= :: ObjectType -> ObjectType -> Bool
Eq)

instance P.Enum ObjectType where
    fromEnum :: ObjectType -> Int
fromEnum ObjectType
ObjectTypeFile = Int
1
    fromEnum ObjectType
ObjectTypeDirTree = Int
2
    fromEnum ObjectType
ObjectTypeDirMeta = Int
3
    fromEnum ObjectType
ObjectTypeCommit = Int
4
    fromEnum ObjectType
ObjectTypeTombstoneCommit = Int
5
    fromEnum ObjectType
ObjectTypeCommitMeta = Int
6
    fromEnum ObjectType
ObjectTypePayloadLink = Int
7
    fromEnum ObjectType
ObjectTypeFileXattrs = Int
8
    fromEnum ObjectType
ObjectTypeFileXattrsLink = Int
9
    fromEnum (AnotherObjectType Int
k) = Int
k

    toEnum :: Int -> ObjectType
toEnum Int
1 = ObjectType
ObjectTypeFile
    toEnum Int
2 = ObjectType
ObjectTypeDirTree
    toEnum Int
3 = ObjectType
ObjectTypeDirMeta
    toEnum Int
4 = ObjectType
ObjectTypeCommit
    toEnum Int
5 = ObjectType
ObjectTypeTombstoneCommit
    toEnum Int
6 = ObjectType
ObjectTypeCommitMeta
    toEnum Int
7 = ObjectType
ObjectTypePayloadLink
    toEnum Int
8 = ObjectType
ObjectTypeFileXattrs
    toEnum Int
9 = ObjectType
ObjectTypeFileXattrsLink
    toEnum Int
k = Int -> ObjectType
AnotherObjectType Int
k

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

-- Enum GpgSignatureAttr
-- | Signature attributes available from an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'.
-- The attribute\'s t'GI.GLib.Structs.VariantType.VariantType' is shown in brackets.
data GpgSignatureAttr = 
      GpgSignatureAttrValid
    -- ^ [@/G_VARIANT_TYPE_BOOLEAN/@] Is the signature valid?
    | GpgSignatureAttrSigExpired
    -- ^ [@/G_VARIANT_TYPE_BOOLEAN/@] Has the signature expired?
    | GpgSignatureAttrKeyExpired
    -- ^ [@/G_VARIANT_TYPE_BOOLEAN/@] Has the signing key expired?
    | GpgSignatureAttrKeyRevoked
    -- ^ [@/G_VARIANT_TYPE_BOOLEAN/@] Has the signing key been revoked?
    | GpgSignatureAttrKeyMissing
    -- ^ [@/G_VARIANT_TYPE_BOOLEAN/@] Is the signing key missing?
    | GpgSignatureAttrFingerprint
    -- ^ [@/G_VARIANT_TYPE_STRING/@] Fingerprint of the signing key
    | GpgSignatureAttrTimestamp
    -- ^ [@/G_VARIANT_TYPE_INT64/@] Signature creation Unix timestamp
    | GpgSignatureAttrExpTimestamp
    -- ^ [@/G_VARIANT_TYPE_INT64/@] Signature expiration Unix timestamp (0 if no
    --   expiration)
    | GpgSignatureAttrPubkeyAlgoName
    -- ^ [@/G_VARIANT_TYPE_STRING/@] Name of the public key algorithm used to create
    --   the signature
    | GpgSignatureAttrHashAlgoName
    -- ^ [@/G_VARIANT_TYPE_STRING/@] Name of the hash algorithm used to create the
    --   signature
    | GpgSignatureAttrUserName
    -- ^ [@/G_VARIANT_TYPE_STRING/@] The name of the signing key\'s primary user
    | GpgSignatureAttrUserEmail
    -- ^ [@/G_VARIANT_TYPE_STRING/@] The email address of the signing key\'s primary
    --   user
    | GpgSignatureAttrFingerprintPrimary
    -- ^ [@/G_VARIANT_TYPE_STRING/@] Fingerprint of the signing key\'s primary key
    --   (will be the same as OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT if the
    --   the signature is already from the primary key rather than a subkey,
    --   and will be the empty string if the key is missing.)
    | GpgSignatureAttrKeyExpTimestamp
    -- ^ [@/G_VARIANT_TYPE_INT64/@] Key expiration Unix timestamp (0 if no
    --   expiration or if the key is missing)
    | GpgSignatureAttrKeyExpTimestampPrimary
    -- ^ [@/G_VARIANT_TYPE_INT64/@] Key expiration Unix timestamp of the signing key\'s
    --   primary key (will be the same as OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP
    --   if the signing key is the primary key and 0 if no expiration or if the key
    --   is missing)
    | AnotherGpgSignatureAttr Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GpgSignatureAttr -> ShowS
[GpgSignatureAttr] -> ShowS
GpgSignatureAttr -> String
(Int -> GpgSignatureAttr -> ShowS)
-> (GpgSignatureAttr -> String)
-> ([GpgSignatureAttr] -> ShowS)
-> Show GpgSignatureAttr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GpgSignatureAttr -> ShowS
showsPrec :: Int -> GpgSignatureAttr -> ShowS
$cshow :: GpgSignatureAttr -> String
show :: GpgSignatureAttr -> String
$cshowList :: [GpgSignatureAttr] -> ShowS
showList :: [GpgSignatureAttr] -> ShowS
Show, GpgSignatureAttr -> GpgSignatureAttr -> Bool
(GpgSignatureAttr -> GpgSignatureAttr -> Bool)
-> (GpgSignatureAttr -> GpgSignatureAttr -> Bool)
-> Eq GpgSignatureAttr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GpgSignatureAttr -> GpgSignatureAttr -> Bool
== :: GpgSignatureAttr -> GpgSignatureAttr -> Bool
$c/= :: GpgSignatureAttr -> GpgSignatureAttr -> Bool
/= :: GpgSignatureAttr -> GpgSignatureAttr -> Bool
Eq)

instance P.Enum GpgSignatureAttr where
    fromEnum :: GpgSignatureAttr -> Int
fromEnum GpgSignatureAttr
GpgSignatureAttrValid = Int
0
    fromEnum GpgSignatureAttr
GpgSignatureAttrSigExpired = Int
1
    fromEnum GpgSignatureAttr
GpgSignatureAttrKeyExpired = Int
2
    fromEnum GpgSignatureAttr
GpgSignatureAttrKeyRevoked = Int
3
    fromEnum GpgSignatureAttr
GpgSignatureAttrKeyMissing = Int
4
    fromEnum GpgSignatureAttr
GpgSignatureAttrFingerprint = Int
5
    fromEnum GpgSignatureAttr
GpgSignatureAttrTimestamp = Int
6
    fromEnum GpgSignatureAttr
GpgSignatureAttrExpTimestamp = Int
7
    fromEnum GpgSignatureAttr
GpgSignatureAttrPubkeyAlgoName = Int
8
    fromEnum GpgSignatureAttr
GpgSignatureAttrHashAlgoName = Int
9
    fromEnum GpgSignatureAttr
GpgSignatureAttrUserName = Int
10
    fromEnum GpgSignatureAttr
GpgSignatureAttrUserEmail = Int
11
    fromEnum GpgSignatureAttr
GpgSignatureAttrFingerprintPrimary = Int
12
    fromEnum GpgSignatureAttr
GpgSignatureAttrKeyExpTimestamp = Int
13
    fromEnum GpgSignatureAttr
GpgSignatureAttrKeyExpTimestampPrimary = Int
14
    fromEnum (AnotherGpgSignatureAttr Int
k) = Int
k

    toEnum :: Int -> GpgSignatureAttr
toEnum Int
0 = GpgSignatureAttr
GpgSignatureAttrValid
    toEnum Int
1 = GpgSignatureAttr
GpgSignatureAttrSigExpired
    toEnum Int
2 = GpgSignatureAttr
GpgSignatureAttrKeyExpired
    toEnum Int
3 = GpgSignatureAttr
GpgSignatureAttrKeyRevoked
    toEnum Int
4 = GpgSignatureAttr
GpgSignatureAttrKeyMissing
    toEnum Int
5 = GpgSignatureAttr
GpgSignatureAttrFingerprint
    toEnum Int
6 = GpgSignatureAttr
GpgSignatureAttrTimestamp
    toEnum Int
7 = GpgSignatureAttr
GpgSignatureAttrExpTimestamp
    toEnum Int
8 = GpgSignatureAttr
GpgSignatureAttrPubkeyAlgoName
    toEnum Int
9 = GpgSignatureAttr
GpgSignatureAttrHashAlgoName
    toEnum Int
10 = GpgSignatureAttr
GpgSignatureAttrUserName
    toEnum Int
11 = GpgSignatureAttr
GpgSignatureAttrUserEmail
    toEnum Int
12 = GpgSignatureAttr
GpgSignatureAttrFingerprintPrimary
    toEnum Int
13 = GpgSignatureAttr
GpgSignatureAttrKeyExpTimestamp
    toEnum Int
14 = GpgSignatureAttr
GpgSignatureAttrKeyExpTimestampPrimary
    toEnum Int
k = Int -> GpgSignatureAttr
AnotherGpgSignatureAttr Int
k

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

-- Enum GpgError
-- | Errors returned by signature creation and verification operations in OSTree.
-- These may be returned by any API which creates or verifies signatures.
-- 
-- /Since: 2017.10/
data GpgError = 
      GpgErrorNoSignature
    -- ^ A signature was expected, but not found.
    | GpgErrorInvalidSignature
    -- ^ A signature was malformed.
    | GpgErrorMissingKey
    -- ^ A signature was found, but was created with a key not in the configured keyrings.
    | GpgErrorExpiredSignature
    -- ^ A signature was expired. Since: 2020.1.
    | GpgErrorExpiredKey
    -- ^ A signature was found, but the key used to
    --   sign it has expired. Since: 2020.1.
    | GpgErrorRevokedKey
    -- ^ A signature was found, but the key used to
    --   sign it has been revoked. Since: 2020.1.
    | AnotherGpgError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GpgError -> ShowS
[GpgError] -> ShowS
GpgError -> String
(Int -> GpgError -> ShowS)
-> (GpgError -> String) -> ([GpgError] -> ShowS) -> Show GpgError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GpgError -> ShowS
showsPrec :: Int -> GpgError -> ShowS
$cshow :: GpgError -> String
show :: GpgError -> String
$cshowList :: [GpgError] -> ShowS
showList :: [GpgError] -> ShowS
Show, GpgError -> GpgError -> Bool
(GpgError -> GpgError -> Bool)
-> (GpgError -> GpgError -> Bool) -> Eq GpgError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GpgError -> GpgError -> Bool
== :: GpgError -> GpgError -> Bool
$c/= :: GpgError -> GpgError -> Bool
/= :: GpgError -> GpgError -> Bool
Eq)

instance P.Enum GpgError where
    fromEnum :: GpgError -> Int
fromEnum GpgError
GpgErrorNoSignature = Int
0
    fromEnum GpgError
GpgErrorInvalidSignature = Int
1
    fromEnum GpgError
GpgErrorMissingKey = Int
2
    fromEnum GpgError
GpgErrorExpiredSignature = Int
3
    fromEnum GpgError
GpgErrorExpiredKey = Int
4
    fromEnum GpgError
GpgErrorRevokedKey = Int
5
    fromEnum (AnotherGpgError Int
k) = Int
k

    toEnum :: Int -> GpgError
toEnum Int
0 = GpgError
GpgErrorNoSignature
    toEnum Int
1 = GpgError
GpgErrorInvalidSignature
    toEnum Int
2 = GpgError
GpgErrorMissingKey
    toEnum Int
3 = GpgError
GpgErrorExpiredSignature
    toEnum Int
4 = GpgError
GpgErrorExpiredKey
    toEnum Int
5 = GpgError
GpgErrorRevokedKey
    toEnum Int
k = Int -> GpgError
AnotherGpgError Int
k

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

instance GErrorClass GpgError where
    gerrorClassDomain :: GpgError -> Text
gerrorClassDomain GpgError
_ = Text
"OstreeGpgError"

-- | Catch exceptions of type `GpgError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchGpgError ::
    IO a ->
    (GpgError -> GErrorMessage -> IO a) ->
    IO a
catchGpgError :: forall a. IO a -> (GpgError -> Text -> IO a) -> IO a
catchGpgError = IO a -> (GpgError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `GpgError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleGpgError ::
    (GpgError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleGpgError :: forall a. (GpgError -> Text -> IO a) -> IO a -> IO a
handleGpgError = (GpgError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

-- Enum DeploymentUnlockedState
-- | /No description available in the introspection data./
data DeploymentUnlockedState = 
      DeploymentUnlockedStateNone
    -- ^ /No description available in the introspection data./
    | DeploymentUnlockedStateDevelopment
    -- ^ /No description available in the introspection data./
    | DeploymentUnlockedStateHotfix
    -- ^ /No description available in the introspection data./
    | DeploymentUnlockedStateTransient
    -- ^ /No description available in the introspection data./
    | AnotherDeploymentUnlockedState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeploymentUnlockedState -> ShowS
[DeploymentUnlockedState] -> ShowS
DeploymentUnlockedState -> String
(Int -> DeploymentUnlockedState -> ShowS)
-> (DeploymentUnlockedState -> String)
-> ([DeploymentUnlockedState] -> ShowS)
-> Show DeploymentUnlockedState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeploymentUnlockedState -> ShowS
showsPrec :: Int -> DeploymentUnlockedState -> ShowS
$cshow :: DeploymentUnlockedState -> String
show :: DeploymentUnlockedState -> String
$cshowList :: [DeploymentUnlockedState] -> ShowS
showList :: [DeploymentUnlockedState] -> ShowS
Show, DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
(DeploymentUnlockedState -> DeploymentUnlockedState -> Bool)
-> (DeploymentUnlockedState -> DeploymentUnlockedState -> Bool)
-> Eq DeploymentUnlockedState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
== :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
$c/= :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
/= :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
Eq)

instance P.Enum DeploymentUnlockedState where
    fromEnum :: DeploymentUnlockedState -> Int
fromEnum DeploymentUnlockedState
DeploymentUnlockedStateNone = Int
0
    fromEnum DeploymentUnlockedState
DeploymentUnlockedStateDevelopment = Int
1
    fromEnum DeploymentUnlockedState
DeploymentUnlockedStateHotfix = Int
2
    fromEnum DeploymentUnlockedState
DeploymentUnlockedStateTransient = Int
3
    fromEnum (AnotherDeploymentUnlockedState Int
k) = Int
k

    toEnum :: Int -> DeploymentUnlockedState
toEnum Int
0 = DeploymentUnlockedState
DeploymentUnlockedStateNone
    toEnum Int
1 = DeploymentUnlockedState
DeploymentUnlockedStateDevelopment
    toEnum Int
2 = DeploymentUnlockedState
DeploymentUnlockedStateHotfix
    toEnum Int
3 = DeploymentUnlockedState
DeploymentUnlockedStateTransient
    toEnum Int
k = Int -> DeploymentUnlockedState
AnotherDeploymentUnlockedState Int
k

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