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

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Graphene.Enums
        (

     -- * Enumerations

    -- ** EulerOrder #enum:EulerOrder#

        EulerOrder(..)                          ,

    -- ** RayIntersectionKind #enum:RayIntersectionKind#

        RayIntersectionKind(..)                 ,

        ) 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.Kind as DK
    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
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- Enum RayIntersectionKind
    -- | The type of intersection.
    --
    -- /Since: 1.10/
    data RayIntersectionKind =
          RayIntersectionKindNone
        -- ^ No intersection
        | RayIntersectionKindEnter
        -- ^ The ray is entering the intersected
        --   object
        | RayIntersectionKindLeave
        -- ^ The ray is leaving the intersected
        --   object
        | AnotherRayIntersectionKind Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RayIntersectionKind -> ShowS
    [RayIntersectionKind] -> ShowS
    RayIntersectionKind -> String
    (Int -> RayIntersectionKind -> ShowS)
    -> (RayIntersectionKind -> String)
    -> ([RayIntersectionKind] -> ShowS)
    -> Show RayIntersectionKind
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RayIntersectionKind -> ShowS
    showsPrec :: Int -> RayIntersectionKind -> ShowS
    $cshow :: RayIntersectionKind -> String
    show :: RayIntersectionKind -> String
    $cshowList :: [RayIntersectionKind] -> ShowS
    showList :: [RayIntersectionKind] -> ShowS
    Show, RayIntersectionKind -> RayIntersectionKind -> Bool
    (RayIntersectionKind -> RayIntersectionKind -> Bool)
    -> (RayIntersectionKind -> RayIntersectionKind -> Bool)
    -> Eq RayIntersectionKind
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RayIntersectionKind -> RayIntersectionKind -> Bool
    == :: RayIntersectionKind -> RayIntersectionKind -> Bool
    $c/= :: RayIntersectionKind -> RayIntersectionKind -> Bool
    /= :: RayIntersectionKind -> RayIntersectionKind -> Bool
    Eq)

    instance P.Enum RayIntersectionKind where
        fromEnum :: RayIntersectionKind -> Int
    fromEnum RayIntersectionKind
    RayIntersectionKindNone = Int
    0
        fromEnum RayIntersectionKind
    RayIntersectionKindEnter = Int
    1
        fromEnum RayIntersectionKind
    RayIntersectionKindLeave = Int
    2
        fromEnum (AnotherRayIntersectionKind Int
    k) = Int
    k

        toEnum :: Int -> RayIntersectionKind
    toEnum Int
    0 = RayIntersectionKind
    RayIntersectionKindNone
        toEnum Int
    1 = RayIntersectionKind
    RayIntersectionKindEnter
        toEnum Int
    2 = RayIntersectionKind
    RayIntersectionKindLeave
        toEnum Int
    k = Int -> RayIntersectionKind
    AnotherRayIntersectionKind Int
    k

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

    -- Enum EulerOrder
    -- | Specify the order of the rotations on each axis.
    --
    -- The 'GI.Graphene.Enums.EulerOrderDefault' value is special, and is used
    -- as an alias for one of the other orders.
    --
    -- /Since: 1.2/
    data EulerOrder =
          EulerOrderDefault
        -- ^ Rotate in the default order; the
        --   default order is one of the following enumeration values
        | EulerOrderXyz
        -- ^ Rotate in the X, Y, and Z order. Deprecated in
        --   Graphene 1.10, it\'s an alias for 'GI.Graphene.Enums.EulerOrderSxyz'
        | EulerOrderYzx
        -- ^ Rotate in the Y, Z, and X order. Deprecated in
        --   Graphene 1.10, it\'s an alias for 'GI.Graphene.Enums.EulerOrderSyzx'
        | EulerOrderZxy
        -- ^ Rotate in the Z, X, and Y order. Deprecated in
        --   Graphene 1.10, it\'s an alias for 'GI.Graphene.Enums.EulerOrderSzxy'
        | EulerOrderXzy
        -- ^ Rotate in the X, Z, and Y order. Deprecated in
        --   Graphene 1.10, it\'s an alias for 'GI.Graphene.Enums.EulerOrderSxzy'
        | EulerOrderYxz
        -- ^ Rotate in the Y, X, and Z order. Deprecated in
        --   Graphene 1.10, it\'s an alias for 'GI.Graphene.Enums.EulerOrderSyxz'
        | EulerOrderZyx
        -- ^ Rotate in the Z, Y, and X order. Deprecated in
        --   Graphene 1.10, it\'s an alias for 'GI.Graphene.Enums.EulerOrderSzyx'
        | EulerOrderSxyz
        -- ^ Defines a static rotation along the X, Y, and Z axes (Since: 1.10)
        | EulerOrderSxyx
        -- ^ Defines a static rotation along the X, Y, and X axes (Since: 1.10)
        | EulerOrderSxzy
        -- ^ Defines a static rotation along the X, Z, and Y axes (Since: 1.10)
        | EulerOrderSxzx
        -- ^ Defines a static rotation along the X, Z, and X axes (Since: 1.10)
        | EulerOrderSyzx
        -- ^ Defines a static rotation along the Y, Z, and X axes (Since: 1.10)
        | EulerOrderSyzy
        -- ^ Defines a static rotation along the Y, Z, and Y axes (Since: 1.10)
        | EulerOrderSyxz
        -- ^ Defines a static rotation along the Y, X, and Z axes (Since: 1.10)
        | EulerOrderSyxy
        -- ^ Defines a static rotation along the Y, X, and Y axes (Since: 1.10)
        | EulerOrderSzxy
        -- ^ Defines a static rotation along the Z, X, and Y axes (Since: 1.10)
        | EulerOrderSzxz
        -- ^ Defines a static rotation along the Z, X, and Z axes (Since: 1.10)
        | EulerOrderSzyx
        -- ^ Defines a static rotation along the Z, Y, and X axes (Since: 1.10)
        | EulerOrderSzyz
        -- ^ Defines a static rotation along the Z, Y, and Z axes (Since: 1.10)
        | EulerOrderRzyx
        -- ^ Defines a relative rotation along the Z, Y, and X axes (Since: 1.10)
        | EulerOrderRxyx
        -- ^ Defines a relative rotation along the X, Y, and X axes (Since: 1.10)
        | EulerOrderRyzx
        -- ^ Defines a relative rotation along the Y, Z, and X axes (Since: 1.10)
        | EulerOrderRxzx
        -- ^ Defines a relative rotation along the X, Z, and X axes (Since: 1.10)
        | EulerOrderRxzy
        -- ^ Defines a relative rotation along the X, Z, and Y axes (Since: 1.10)
        | EulerOrderRyzy
        -- ^ Defines a relative rotation along the Y, Z, and Y axes (Since: 1.10)
        | EulerOrderRzxy
        -- ^ Defines a relative rotation along the Z, X, and Y axes (Since: 1.10)
        | EulerOrderRyxy
        -- ^ Defines a relative rotation along the Y, X, and Y axes (Since: 1.10)
        | EulerOrderRyxz
        -- ^ Defines a relative rotation along the Y, X, and Z axes (Since: 1.10)
        | EulerOrderRzxz
        -- ^ Defines a relative rotation along the Z, X, and Z axes (Since: 1.10)
        | EulerOrderRxyz
        -- ^ Defines a relative rotation along the X, Y, and Z axes (Since: 1.10)
        | EulerOrderRzyz
        -- ^ Defines a relative rotation along the Z, Y, and Z axes (Since: 1.10)
        | AnotherEulerOrder Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EulerOrder -> ShowS
    [EulerOrder] -> ShowS
    EulerOrder -> String
    (Int -> EulerOrder -> ShowS)
    -> (EulerOrder -> String)
    -> ([EulerOrder] -> ShowS)
    -> Show EulerOrder
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EulerOrder -> ShowS
    showsPrec :: Int -> EulerOrder -> ShowS
    $cshow :: EulerOrder -> String
    show :: EulerOrder -> String
    $cshowList :: [EulerOrder] -> ShowS
    showList :: [EulerOrder] -> ShowS
    Show, EulerOrder -> EulerOrder -> Bool
    (EulerOrder -> EulerOrder -> Bool)
    -> (EulerOrder -> EulerOrder -> Bool) -> Eq EulerOrder
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EulerOrder -> EulerOrder -> Bool
    == :: EulerOrder -> EulerOrder -> Bool
    $c/= :: EulerOrder -> EulerOrder -> Bool
    /= :: EulerOrder -> EulerOrder -> Bool
    Eq)

    instance P.Enum EulerOrder where
        fromEnum :: EulerOrder -> Int
    fromEnum EulerOrder
    EulerOrderDefault = Int
    -1
        fromEnum EulerOrder
    EulerOrderXyz = Int
    0
        fromEnum EulerOrder
    EulerOrderYzx = Int
    1
        fromEnum EulerOrder
    EulerOrderZxy = Int
    2
        fromEnum EulerOrder
    EulerOrderXzy = Int
    3
        fromEnum EulerOrder
    EulerOrderYxz = Int
    4
        fromEnum EulerOrder
    EulerOrderZyx = Int
    5
        fromEnum EulerOrder
    EulerOrderSxyz = Int
    6
        fromEnum EulerOrder
    EulerOrderSxyx = Int
    7
        fromEnum EulerOrder
    EulerOrderSxzy = Int
    8
        fromEnum EulerOrder
    EulerOrderSxzx = Int
    9
        fromEnum EulerOrder
    EulerOrderSyzx = Int
    10
        fromEnum EulerOrder
    EulerOrderSyzy = Int
    11
        fromEnum EulerOrder
    EulerOrderSyxz = Int
    12
        fromEnum EulerOrder
    EulerOrderSyxy = Int
    13
        fromEnum EulerOrder
    EulerOrderSzxy = Int
    14
        fromEnum EulerOrder
    EulerOrderSzxz = Int
    15
        fromEnum EulerOrder
    EulerOrderSzyx = Int
    16
        fromEnum EulerOrder
    EulerOrderSzyz = Int
    17
        fromEnum EulerOrder
    EulerOrderRzyx = Int
    18
        fromEnum EulerOrder
    EulerOrderRxyx = Int
    19
        fromEnum EulerOrder
    EulerOrderRyzx = Int
    20
        fromEnum EulerOrder
    EulerOrderRxzx = Int
    21
        fromEnum EulerOrder
    EulerOrderRxzy = Int
    22
        fromEnum EulerOrder
    EulerOrderRyzy = Int
    23
        fromEnum EulerOrder
    EulerOrderRzxy = Int
    24
        fromEnum EulerOrder
    EulerOrderRyxy = Int
    25
        fromEnum EulerOrder
    EulerOrderRyxz = Int
    26
        fromEnum EulerOrder
    EulerOrderRzxz = Int
    27
        fromEnum EulerOrder
    EulerOrderRxyz = Int
    28
        fromEnum EulerOrder
    EulerOrderRzyz = Int
    29
        fromEnum (AnotherEulerOrder Int
    k) = Int
    k

        toEnum :: Int -> EulerOrder
    toEnum Int
    -1 = EulerOrder
    EulerOrderDefault
        toEnum Int
    0 = EulerOrder
    EulerOrderXyz
        toEnum Int
    1 = EulerOrder
    EulerOrderYzx
        toEnum Int
    2 = EulerOrder
    EulerOrderZxy
        toEnum Int
    3 = EulerOrder
    EulerOrderXzy
        toEnum Int
    4 = EulerOrder
    EulerOrderYxz
        toEnum Int
    5 = EulerOrder
    EulerOrderZyx
        toEnum Int
    6 = EulerOrder
    EulerOrderSxyz
        toEnum Int
    7 = EulerOrder
    EulerOrderSxyx
        toEnum Int
    8 = EulerOrder
    EulerOrderSxzy
        toEnum Int
    9 = EulerOrder
    EulerOrderSxzx
        toEnum Int
    10 = EulerOrder
    EulerOrderSyzx
        toEnum Int
    11 = EulerOrder
    EulerOrderSyzy
        toEnum Int
    12 = EulerOrder
    EulerOrderSyxz
        toEnum Int
    13 = EulerOrder
    EulerOrderSyxy
        toEnum Int
    14 = EulerOrder
    EulerOrderSzxy
        toEnum Int
    15 = EulerOrder
    EulerOrderSzxz
        toEnum Int
    16 = EulerOrder
    EulerOrderSzyx
        toEnum Int
    17 = EulerOrder
    EulerOrderSzyz
        toEnum Int
    18 = EulerOrder
    EulerOrderRzyx
        toEnum Int
    19 = EulerOrder
    EulerOrderRxyx
        toEnum Int
    20 = EulerOrder
    EulerOrderRyzx
        toEnum Int
    21 = EulerOrder
    EulerOrderRxzx
        toEnum Int
    22 = EulerOrder
    EulerOrderRxzy
        toEnum Int
    23 = EulerOrder
    EulerOrderRyzy
        toEnum Int
    24 = EulerOrder
    EulerOrderRzxy
        toEnum Int
    25 = EulerOrder
    EulerOrderRyxy
        toEnum Int
    26 = EulerOrder
    EulerOrderRyxz
        toEnum Int
    27 = EulerOrder
    EulerOrderRzxz
        toEnum Int
    28 = EulerOrder
    EulerOrderRxyz
        toEnum Int
    29 = EulerOrder
    EulerOrderRzyz
        toEnum Int
    k = Int -> EulerOrder
    AnotherEulerOrder Int
    k

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