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

 -- * Enumerations
-- ** DeploymentUnlockedState #enum:DeploymentUnlockedState#

    DeploymentUnlockedState(..)             ,


-- ** GpgError #enum:GpgError#

    GpgError(..)                            ,
    catchGpgError                           ,
    handleGpgError                          ,


-- ** GpgSignatureAttr #enum:GpgSignatureAttr#

    GpgSignatureAttr(..)                    ,


-- ** GpgSignatureFormatFlags #enum:GpgSignatureFormatFlags#

    GpgSignatureFormatFlags(..)             ,


-- ** ObjectType #enum:ObjectType#

    ObjectType(..)                          ,


-- ** RepoCheckoutFilterResult #enum:RepoCheckoutFilterResult#

    RepoCheckoutFilterResult(..)            ,


-- ** RepoCheckoutMode #enum:RepoCheckoutMode#

    RepoCheckoutMode(..)                    ,


-- ** RepoCheckoutOverwriteMode #enum:RepoCheckoutOverwriteMode#

    RepoCheckoutOverwriteMode(..)           ,


-- ** RepoCommitFilterResult #enum:RepoCommitFilterResult#

    RepoCommitFilterResult(..)              ,


-- ** RepoCommitIterResult #enum:RepoCommitIterResult#

    RepoCommitIterResult(..)                ,


-- ** RepoMode #enum:RepoMode#

    RepoMode(..)                            ,


-- ** RepoPruneFlags #enum:RepoPruneFlags#

    RepoPruneFlags(..)                      ,


-- ** RepoRemoteChange #enum:RepoRemoteChange#

    RepoRemoteChange(..)                    ,


-- ** StaticDeltaGenerateOpt #enum:StaticDeltaGenerateOpt#

    StaticDeltaGenerateOpt(..)              ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


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

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

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

instance P.Ord StaticDeltaGenerateOpt where
    compare :: StaticDeltaGenerateOpt -> StaticDeltaGenerateOpt -> Ordering
compare a :: StaticDeltaGenerateOpt
a b :: 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
showList :: [RepoRemoteChange] -> ShowS
$cshowList :: [RepoRemoteChange] -> ShowS
show :: RepoRemoteChange -> String
$cshow :: RepoRemoteChange -> String
showsPrec :: Int -> RepoRemoteChange -> ShowS
$cshowsPrec :: Int -> RepoRemoteChange -> ShowS
Show, RepoRemoteChange -> RepoRemoteChange -> Bool
(RepoRemoteChange -> RepoRemoteChange -> Bool)
-> (RepoRemoteChange -> RepoRemoteChange -> Bool)
-> Eq RepoRemoteChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoRemoteChange -> RepoRemoteChange -> Bool
$c/= :: RepoRemoteChange -> RepoRemoteChange -> Bool
== :: RepoRemoteChange -> RepoRemoteChange -> Bool
$c== :: RepoRemoteChange -> RepoRemoteChange -> Bool
Eq)

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

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

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

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

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

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

instance P.Ord RepoMode where
    compare :: RepoMode -> RepoMode -> Ordering
compare a :: RepoMode
a b :: 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 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
showList :: [RepoCommitIterResult] -> ShowS
$cshowList :: [RepoCommitIterResult] -> ShowS
show :: RepoCommitIterResult -> String
$cshow :: RepoCommitIterResult -> String
showsPrec :: Int -> RepoCommitIterResult -> ShowS
$cshowsPrec :: Int -> RepoCommitIterResult -> ShowS
Show, RepoCommitIterResult -> RepoCommitIterResult -> Bool
(RepoCommitIterResult -> RepoCommitIterResult -> Bool)
-> (RepoCommitIterResult -> RepoCommitIterResult -> Bool)
-> Eq RepoCommitIterResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
$c/= :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
== :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
$c== :: RepoCommitIterResult -> RepoCommitIterResult -> Bool
Eq)

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

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

instance P.Ord RepoCommitIterResult where
    compare :: RepoCommitIterResult -> RepoCommitIterResult -> Ordering
compare a :: RepoCommitIterResult
a b :: 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
showList :: [RepoCommitFilterResult] -> ShowS
$cshowList :: [RepoCommitFilterResult] -> ShowS
show :: RepoCommitFilterResult -> String
$cshow :: RepoCommitFilterResult -> String
showsPrec :: Int -> RepoCommitFilterResult -> ShowS
$cshowsPrec :: Int -> RepoCommitFilterResult -> ShowS
Show, RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
(RepoCommitFilterResult -> RepoCommitFilterResult -> Bool)
-> (RepoCommitFilterResult -> RepoCommitFilterResult -> Bool)
-> Eq RepoCommitFilterResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
$c/= :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
== :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
$c== :: RepoCommitFilterResult -> RepoCommitFilterResult -> Bool
Eq)

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

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

instance P.Ord RepoCommitFilterResult where
    compare :: RepoCommitFilterResult -> RepoCommitFilterResult -> Ordering
compare a :: RepoCommitFilterResult
a b :: 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
showList :: [RepoCheckoutOverwriteMode] -> ShowS
$cshowList :: [RepoCheckoutOverwriteMode] -> ShowS
show :: RepoCheckoutOverwriteMode -> String
$cshow :: RepoCheckoutOverwriteMode -> String
showsPrec :: Int -> RepoCheckoutOverwriteMode -> ShowS
$cshowsPrec :: Int -> RepoCheckoutOverwriteMode -> ShowS
Show, RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
(RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool)
-> (RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool)
-> Eq RepoCheckoutOverwriteMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
$c/= :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
== :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
$c== :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Bool
Eq)

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

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

instance P.Ord RepoCheckoutOverwriteMode where
    compare :: RepoCheckoutOverwriteMode -> RepoCheckoutOverwriteMode -> Ordering
compare a :: RepoCheckoutOverwriteMode
a b :: 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
showList :: [RepoCheckoutMode] -> ShowS
$cshowList :: [RepoCheckoutMode] -> ShowS
show :: RepoCheckoutMode -> String
$cshow :: RepoCheckoutMode -> String
showsPrec :: Int -> RepoCheckoutMode -> ShowS
$cshowsPrec :: Int -> RepoCheckoutMode -> ShowS
Show, RepoCheckoutMode -> RepoCheckoutMode -> Bool
(RepoCheckoutMode -> RepoCheckoutMode -> Bool)
-> (RepoCheckoutMode -> RepoCheckoutMode -> Bool)
-> Eq RepoCheckoutMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
$c/= :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
== :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
$c== :: RepoCheckoutMode -> RepoCheckoutMode -> Bool
Eq)

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

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

instance P.Ord RepoCheckoutMode where
    compare :: RepoCheckoutMode -> RepoCheckoutMode -> Ordering
compare a :: RepoCheckoutMode
a b :: 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
showList :: [RepoCheckoutFilterResult] -> ShowS
$cshowList :: [RepoCheckoutFilterResult] -> ShowS
show :: RepoCheckoutFilterResult -> String
$cshow :: RepoCheckoutFilterResult -> String
showsPrec :: Int -> RepoCheckoutFilterResult -> ShowS
$cshowsPrec :: Int -> RepoCheckoutFilterResult -> ShowS
Show, RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
(RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool)
-> (RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool)
-> Eq RepoCheckoutFilterResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
$c/= :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
== :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
$c== :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Bool
Eq)

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

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

instance P.Ord RepoCheckoutFilterResult where
    compare :: RepoCheckoutFilterResult -> RepoCheckoutFilterResult -> Ordering
compare a :: RepoCheckoutFilterResult
a b :: 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.
    | 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
showList :: [ObjectType] -> ShowS
$cshowList :: [ObjectType] -> ShowS
show :: ObjectType -> String
$cshow :: ObjectType -> String
showsPrec :: Int -> ObjectType -> ShowS
$cshowsPrec :: Int -> ObjectType -> ShowS
Show, ObjectType -> ObjectType -> Bool
(ObjectType -> ObjectType -> Bool)
-> (ObjectType -> ObjectType -> Bool) -> Eq ObjectType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectType -> ObjectType -> Bool
$c/= :: ObjectType -> ObjectType -> Bool
== :: ObjectType -> ObjectType -> Bool
$c== :: ObjectType -> ObjectType -> Bool
Eq)

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

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

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

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

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

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

instance P.Ord GpgSignatureAttr where
    compare :: GpgSignatureAttr -> GpgSignatureAttr -> Ordering
compare a :: GpgSignatureAttr
a b :: 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.
    | 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
showList :: [GpgError] -> ShowS
$cshowList :: [GpgError] -> ShowS
show :: GpgError -> String
$cshow :: GpgError -> String
showsPrec :: Int -> GpgError -> ShowS
$cshowsPrec :: Int -> GpgError -> ShowS
Show, GpgError -> GpgError -> Bool
(GpgError -> GpgError -> Bool)
-> (GpgError -> GpgError -> Bool) -> Eq GpgError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GpgError -> GpgError -> Bool
$c/= :: GpgError -> GpgError -> Bool
== :: GpgError -> GpgError -> Bool
$c== :: GpgError -> GpgError -> Bool
Eq)

instance P.Enum GpgError where
    fromEnum :: GpgError -> Int
fromEnum GpgErrorNoSignature = 0
    fromEnum GpgErrorInvalidSignature = 1
    fromEnum GpgErrorMissingKey = 2
    fromEnum (AnotherGpgError k :: Int
k) = Int
k

    toEnum :: Int -> GpgError
toEnum 0 = GpgError
GpgErrorNoSignature
    toEnum 1 = GpgError
GpgErrorInvalidSignature
    toEnum 2 = GpgError
GpgErrorMissingKey
    toEnum k :: Int
k = Int -> GpgError
AnotherGpgError Int
k

instance P.Ord GpgError where
    compare :: GpgError -> GpgError -> Ordering
compare a :: GpgError
a b :: 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 _ = "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 :: 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 :: (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./
    | 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
showList :: [DeploymentUnlockedState] -> ShowS
$cshowList :: [DeploymentUnlockedState] -> ShowS
show :: DeploymentUnlockedState -> String
$cshow :: DeploymentUnlockedState -> String
showsPrec :: Int -> DeploymentUnlockedState -> ShowS
$cshowsPrec :: Int -> DeploymentUnlockedState -> ShowS
Show, DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
(DeploymentUnlockedState -> DeploymentUnlockedState -> Bool)
-> (DeploymentUnlockedState -> DeploymentUnlockedState -> Bool)
-> Eq DeploymentUnlockedState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
$c/= :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
== :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
$c== :: DeploymentUnlockedState -> DeploymentUnlockedState -> Bool
Eq)

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

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

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