Enums.hs


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

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

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

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

    toEnum 0 = RepoRemoteChangeAdd
    toEnum 1 = RepoRemoteChangeAddIfNotExists
    toEnum 2 = RepoRemoteChangeDelete
    toEnum 3 = RepoRemoteChangeDeleteIfExists
    toEnum 4 = RepoRemoteChangeReplace
    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
    -}
    | 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 (Show, Eq)

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

    toEnum 0 = RepoModeBare
    toEnum 1 = RepoModeArchive
    toEnum 1 = RepoModeArchiveZ2
    toEnum 2 = RepoModeBareUser
    toEnum 3 = RepoModeBareUserOnly
    toEnum k = AnotherRepoMode k

instance P.Ord RepoMode 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 (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 (Show, Eq)

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

    toEnum 0 = RepoCheckoutOverwriteModeNone
    toEnum 1 = RepoCheckoutOverwriteModeUnionFiles
    toEnum 2 = RepoCheckoutOverwriteModeAddFiles
    toEnum 3 = RepoCheckoutOverwriteModeUnionIdentical
    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 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 (Show, Eq)

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

    toEnum 0 = RepoCheckoutFilterResultAllow
    toEnum 1 = RepoCheckoutFilterResultSkip
    toEnum k = AnotherRepoCheckoutFilterResult k

instance P.Ord RepoCheckoutFilterResult 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
    -}
    | ObjectTypePayloadLink
    {- ^
    Symlink to a .file given its checksum on the payload only.
    -}
    | 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 ObjectTypePayloadLink = 7
    fromEnum (AnotherObjectType k) = k

    toEnum 1 = ObjectTypeFile
    toEnum 2 = ObjectTypeDirTree
    toEnum 3 = ObjectTypeDirMeta
    toEnum 4 = ObjectTypeCommit
    toEnum 5 = ObjectTypeTombstoneCommit
    toEnum 6 = ObjectTypeCommitMeta
    toEnum 7 = ObjectTypePayloadLink
    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
    -}
    | 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 (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 GpgSignatureAttrFingerprintPrimary = 12
    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 12 = GpgSignatureAttrFingerprintPrimary
    toEnum k = AnotherGpgSignatureAttr k

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

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

    toEnum 0 = GpgErrorNoSignature
    toEnum 1 = GpgErrorInvalidSignature
    toEnum 2 = GpgErrorMissingKey
    toEnum k = AnotherGpgError k

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

instance GErrorClass GpgError where
    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 = 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 = 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 (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)