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

module GI.OSTree.Enums
    ( 

-- * Exported types
    StaticDeltaGenerateOpt(..)              ,
    RepoResolveRevExtFlags(..)              ,
    RepoRemoteChange(..)                    ,
    RepoPruneFlags(..)                      ,
    RepoMode(..)                            ,
    RepoListRefsExtFlags(..)                ,
    RepoCommitIterResult(..)                ,
    RepoCommitFilterResult(..)              ,
    RepoCheckoutOverwriteMode(..)           ,
    RepoCheckoutMode(..)                    ,
    ObjectType(..)                          ,
    GpgSignatureFormatFlags(..)             ,
    GpgSignatureAttr(..)                    ,
    DeploymentUnlockedState(..)             ,


    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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


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

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

    toEnum 0 = StaticDeltaGenerateOptLowlatency
    toEnum 1 = StaticDeltaGenerateOptMajor
    toEnum k = AnotherStaticDeltaGenerateOpt k

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

-- Enum RepoResolveRevExtFlags
{- |
/No description available in the introspection data./
-}
data RepoResolveRevExtFlags = 
      RepoResolveRevExtFlagsRepoResolveRevExtNone
    {- ^
    No flags.
    -}
    | AnotherRepoResolveRevExtFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RepoResolveRevExtFlags where
    fromEnum RepoResolveRevExtFlagsRepoResolveRevExtNone = 0
    fromEnum (AnotherRepoResolveRevExtFlags k) = k

    toEnum 0 = RepoResolveRevExtFlagsRepoResolveRevExtNone
    toEnum k = AnotherRepoResolveRevExtFlags k

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

-- Enum RepoRemoteChange
{- |
The remote change operation.
-}
data RepoRemoteChange = 
      RepoRemoteChangeAdd
    {- ^
    /No description available in the introspection data./
    -}
    | RepoRemoteChangeAddIfNotExists
    {- ^
    /No description available in the introspection data./
    -}
    | RepoRemoteChangeDelete
    {- ^
    /No description available in the introspection data./
    -}
    | RepoRemoteChangeDeleteIfExists
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherRepoRemoteChange Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RepoRemoteChange where
    fromEnum RepoRemoteChangeAdd = 0
    fromEnum RepoRemoteChangeAddIfNotExists = 1
    fromEnum RepoRemoteChangeDelete = 2
    fromEnum RepoRemoteChangeDeleteIfExists = 3
    fromEnum (AnotherRepoRemoteChange k) = k

    toEnum 0 = RepoRemoteChangeAdd
    toEnum 1 = RepoRemoteChangeAddIfNotExists
    toEnum 2 = RepoRemoteChangeDelete
    toEnum 3 = RepoRemoteChangeDeleteIfExists
    toEnum k = AnotherRepoRemoteChange k

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

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

    toEnum 0 = RepoPruneFlagsNone
    toEnum 1 = RepoPruneFlagsNoPrune
    toEnum 2 = RepoPruneFlagsRefsOnly
    toEnum k = AnotherRepoPruneFlags k

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

-- Enum RepoMode
{- |
See the documentation of '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
    -}
    | RepoModeArchiveZ2
    {- ^
    Files are compressed, should be owned by non-root.  Can be served via HTTP
    -}
    | RepoModeBareUser
    {- ^
    Files are stored as themselves, except ownership; can be written by user. Hardlinks work only in user checkouts.
    -}
    | AnotherRepoMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RepoMode where
    fromEnum RepoModeBare = 0
    fromEnum RepoModeArchiveZ2 = 1
    fromEnum RepoModeBareUser = 2
    fromEnum (AnotherRepoMode k) = k

    toEnum 0 = RepoModeBare
    toEnum 1 = RepoModeArchiveZ2
    toEnum 2 = RepoModeBareUser
    toEnum k = AnotherRepoMode k

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

-- Enum RepoListRefsExtFlags
{- |
/No description available in the introspection data./
-}
data RepoListRefsExtFlags = 
      RepoListRefsExtFlagsRepoListRefsExtNone
    {- ^
    No flags.
    -}
    | AnotherRepoListRefsExtFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RepoListRefsExtFlags where
    fromEnum RepoListRefsExtFlagsRepoListRefsExtNone = 0
    fromEnum (AnotherRepoListRefsExtFlags k) = k

    toEnum 0 = RepoListRefsExtFlagsRepoListRefsExtNone
    toEnum k = AnotherRepoListRefsExtFlags k

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

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

    toEnum 0 = RepoCommitIterResultError
    toEnum 1 = RepoCommitIterResultEnd
    toEnum 2 = RepoCommitIterResultFile
    toEnum 3 = RepoCommitIterResultDir
    toEnum k = AnotherRepoCommitIterResult k

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

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

    toEnum 0 = RepoCommitFilterResultAllow
    toEnum 1 = RepoCommitFilterResultSkip
    toEnum k = AnotherRepoCommitFilterResult k

instance P.Ord RepoCommitFilterResult where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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
    -}
    | RepoCheckoutOverwriteModeAddFiles
    {- ^
    Only add new files\/directories
    -}
    | AnotherRepoCheckoutOverwriteMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RepoCheckoutOverwriteMode where
    fromEnum RepoCheckoutOverwriteModeNone = 0
    fromEnum RepoCheckoutOverwriteModeUnionFiles = 1
    fromEnum RepoCheckoutOverwriteModeAddFiles = 2
    fromEnum (AnotherRepoCheckoutOverwriteMode k) = k

    toEnum 0 = RepoCheckoutOverwriteModeNone
    toEnum 1 = RepoCheckoutOverwriteModeUnionFiles
    toEnum 2 = RepoCheckoutOverwriteModeAddFiles
    toEnum k = AnotherRepoCheckoutOverwriteMode k

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

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

    toEnum 0 = RepoCheckoutModeNone
    toEnum 1 = RepoCheckoutModeUser
    toEnum k = AnotherRepoCheckoutMode k

instance P.Ord RepoCheckoutMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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
    -}
    | AnotherObjectType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 1 = ObjectTypeFile
    toEnum 2 = ObjectTypeDirTree
    toEnum 3 = ObjectTypeDirMeta
    toEnum 4 = ObjectTypeCommit
    toEnum 5 = ObjectTypeTombstoneCommit
    toEnum 6 = ObjectTypeCommitMeta
    toEnum k = AnotherObjectType k

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

instance P.Enum GpgSignatureFormatFlags where
    fromEnum GpgSignatureFormatFlagsGpgSignatureFormatDefault = 0
    fromEnum (AnotherGpgSignatureFormatFlags k) = k

    toEnum 0 = GpgSignatureFormatFlagsGpgSignatureFormatDefault
    toEnum k = AnotherGpgSignatureFormatFlags k

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

-- Enum GpgSignatureAttr
{- |
Signature attributes available from an 'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult'.
The attribute\'s '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
    -}
    | AnotherGpgSignatureAttr Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

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

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

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

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

    toEnum 0 = DeploymentUnlockedStateNone
    toEnum 1 = DeploymentUnlockedStateDevelopment
    toEnum 2 = DeploymentUnlockedStateHotfix
    toEnum k = AnotherDeploymentUnlockedState k

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