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

     -- * Enumerations

    -- ** BlendMode #enum:BlendMode#

        BlendMode(..)                           ,

    -- ** Corner #enum:Corner#

        Corner(..)                              ,

    -- ** FillRule #enum:FillRule#

        FillRule(..)                            ,

    -- ** GLUniformType #enum:GLUniformType#

        GLUniformType(..)                       ,

    -- ** LineCap #enum:LineCap#

        LineCap(..)                             ,

    -- ** LineJoin #enum:LineJoin#

        LineJoin(..)                            ,

    -- ** MaskMode #enum:MaskMode#

        MaskMode(..)                            ,

    -- ** PathDirection #enum:PathDirection#

        PathDirection(..)                       ,

    -- ** PathIntersection #enum:PathIntersection#

        PathIntersection(..)                    ,

    -- ** PathOperation #enum:PathOperation#

        PathOperation(..)                       ,

    -- ** PorterDuff #enum:PorterDuff#

        PorterDuff(..)                          ,

    -- ** RenderNodeType #enum:RenderNodeType#

        RenderNodeType(..)                      ,

    -- ** ScalingFilter #enum:ScalingFilter#

        ScalingFilter(..)                       ,

    -- ** SerializationError #enum:SerializationError#

        SerializationError(..)                  ,
        catchSerializationError                 ,
        handleSerializationError                ,

    -- ** TransformCategory #enum:TransformCategory#

        TransformCategory(..)                   ,

        ) 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 TransformCategory
    -- | The categories of matrices relevant for GSK and GTK.
    --
    -- Note that any category includes matrices of all later categories.
    -- So if you want to for example check if a matrix is a 2D matrix,
    -- @category >= GSK_TRANSFORM_CATEGORY_2D@ is the way to do this.
    --
    -- Also keep in mind that rounding errors may cause matrices to not
    -- conform to their categories. Otherwise, matrix operations done via
    -- multiplication will not worsen categories. So for the matrix
    -- multiplication @C = A * B@, @category(C) = MIN (category(A), category(B))@.
    data TransformCategory =
          TransformCategoryUnknown
        -- ^ The category of the matrix has not been
        --   determined.
        | TransformCategoryAny
        -- ^ Analyzing the matrix concluded that it does
        --   not fit in any other category.
        | TransformCategory3d
        -- ^ The matrix is a 3D matrix. This means that
        --   the w column (the last column) has the values (0, 0, 0, 1).
        | TransformCategory2d
        -- ^ The matrix is a 2D matrix. This is equivalent
        --   to 'GI.Graphene.Structs.Matrix.matrixIs2d' returning 'P.True'. In particular, this
        --   means that Cairo can deal with the matrix.
        | TransformCategory2dAffine
        -- ^ The matrix is a combination of 2D scale
        --   and 2D translation operations. In particular, this means that any
        --   rectangle can be transformed exactly using this matrix.
        | TransformCategory2dTranslate
        -- ^ The matrix is a 2D translation.
        | TransformCategoryIdentity
        -- ^ The matrix is the identity matrix.
        | AnotherTransformCategory Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TransformCategory -> ShowS
    [TransformCategory] -> ShowS
    TransformCategory -> String
    (Int -> TransformCategory -> ShowS)
    -> (TransformCategory -> String)
    -> ([TransformCategory] -> ShowS)
    -> Show TransformCategory
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TransformCategory -> ShowS
    showsPrec :: Int -> TransformCategory -> ShowS
    $cshow :: TransformCategory -> String
    show :: TransformCategory -> String
    $cshowList :: [TransformCategory] -> ShowS
    showList :: [TransformCategory] -> ShowS
    Show, TransformCategory -> TransformCategory -> Bool
    (TransformCategory -> TransformCategory -> Bool)
    -> (TransformCategory -> TransformCategory -> Bool)
    -> Eq TransformCategory
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TransformCategory -> TransformCategory -> Bool
    == :: TransformCategory -> TransformCategory -> Bool
    $c/= :: TransformCategory -> TransformCategory -> Bool
    /= :: TransformCategory -> TransformCategory -> Bool
    Eq)

    instance P.Enum TransformCategory where
        fromEnum :: TransformCategory -> Int
    fromEnum TransformCategory
    TransformCategoryUnknown = Int
    0
        fromEnum TransformCategory
    TransformCategoryAny = Int
    1
        fromEnum TransformCategory
    TransformCategory3d = Int
    2
        fromEnum TransformCategory
    TransformCategory2d = Int
    3
        fromEnum TransformCategory
    TransformCategory2dAffine = Int
    4
        fromEnum TransformCategory
    TransformCategory2dTranslate = Int
    5
        fromEnum TransformCategory
    TransformCategoryIdentity = Int
    6
        fromEnum (AnotherTransformCategory Int
    k) = Int
    k

        toEnum :: Int -> TransformCategory
    toEnum Int
    0 = TransformCategory
    TransformCategoryUnknown
        toEnum Int
    1 = TransformCategory
    TransformCategoryAny
        toEnum Int
    2 = TransformCategory
    TransformCategory3d
        toEnum Int
    3 = TransformCategory
    TransformCategory2d
        toEnum Int
    4 = TransformCategory
    TransformCategory2dAffine
        toEnum Int
    5 = TransformCategory
    TransformCategory2dTranslate
        toEnum Int
    6 = TransformCategory
    TransformCategoryIdentity
        toEnum Int
    k = Int -> TransformCategory
    AnotherTransformCategory Int
    k

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

    type instance O.ParentTypes TransformCategory = '[]
    instance O.HasParentTypes TransformCategory

    foreign import ccall "gsk_transform_category_get_type" c_gsk_transform_category_get_type ::
        IO GType

    instance B.Types.TypedObject TransformCategory where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_transform_category_get_type

    instance B.Types.BoxedEnum TransformCategory

    -- Enum SerializationError
    -- | Errors that can happen during (de)serialization.
    data SerializationError =
          SerializationErrorUnsupportedFormat
        -- ^ The format can not be identified
        | SerializationErrorUnsupportedVersion
        -- ^ The version of the data is not
        --   understood
        | SerializationErrorInvalidData
        -- ^ The given data may not exist in
        --   a proper serialization
        | AnotherSerializationError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SerializationError -> ShowS
    [SerializationError] -> ShowS
    SerializationError -> String
    (Int -> SerializationError -> ShowS)
    -> (SerializationError -> String)
    -> ([SerializationError] -> ShowS)
    -> Show SerializationError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SerializationError -> ShowS
    showsPrec :: Int -> SerializationError -> ShowS
    $cshow :: SerializationError -> String
    show :: SerializationError -> String
    $cshowList :: [SerializationError] -> ShowS
    showList :: [SerializationError] -> ShowS
    Show, SerializationError -> SerializationError -> Bool
    (SerializationError -> SerializationError -> Bool)
    -> (SerializationError -> SerializationError -> Bool)
    -> Eq SerializationError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SerializationError -> SerializationError -> Bool
    == :: SerializationError -> SerializationError -> Bool
    $c/= :: SerializationError -> SerializationError -> Bool
    /= :: SerializationError -> SerializationError -> Bool
    Eq)

    instance P.Enum SerializationError where
        fromEnum :: SerializationError -> Int
    fromEnum SerializationError
    SerializationErrorUnsupportedFormat = Int
    0
        fromEnum SerializationError
    SerializationErrorUnsupportedVersion = Int
    1
        fromEnum SerializationError
    SerializationErrorInvalidData = Int
    2
        fromEnum (AnotherSerializationError Int
    k) = Int
    k

        toEnum :: Int -> SerializationError
    toEnum Int
    0 = SerializationError
    SerializationErrorUnsupportedFormat
        toEnum Int
    1 = SerializationError
    SerializationErrorUnsupportedVersion
        toEnum Int
    2 = SerializationError
    SerializationErrorInvalidData
        toEnum Int
    k = Int -> SerializationError
    AnotherSerializationError Int
    k

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

    instance GErrorClass SerializationError where
        gerrorClassDomain :: SerializationError -> Text
    gerrorClassDomain SerializationError
    _ = Text
    "gsk-serialization-error-quark"

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

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

    type instance O.ParentTypes SerializationError = '[]
    instance O.HasParentTypes SerializationError

    foreign import ccall "gsk_serialization_error_get_type" c_gsk_serialization_error_get_type ::
        IO GType

    instance B.Types.TypedObject SerializationError where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_serialization_error_get_type

    instance B.Types.BoxedEnum SerializationError

    -- Enum ScalingFilter
    -- | The filters used when scaling texture data.
    --
    -- The actual implementation of each filter is deferred to the
    -- rendering pipeline.
    data ScalingFilter =
          ScalingFilterLinear
        -- ^ linear interpolation filter
        | ScalingFilterNearest
        -- ^ nearest neighbor interpolation filter
        | ScalingFilterTrilinear
        -- ^ linear interpolation along each axis,
        --   plus mipmap generation, with linear interpolation along the mipmap
        --   levels
        | AnotherScalingFilter Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ScalingFilter -> ShowS
    [ScalingFilter] -> ShowS
    ScalingFilter -> String
    (Int -> ScalingFilter -> ShowS)
    -> (ScalingFilter -> String)
    -> ([ScalingFilter] -> ShowS)
    -> Show ScalingFilter
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ScalingFilter -> ShowS
    showsPrec :: Int -> ScalingFilter -> ShowS
    $cshow :: ScalingFilter -> String
    show :: ScalingFilter -> String
    $cshowList :: [ScalingFilter] -> ShowS
    showList :: [ScalingFilter] -> ShowS
    Show, ScalingFilter -> ScalingFilter -> Bool
    (ScalingFilter -> ScalingFilter -> Bool)
    -> (ScalingFilter -> ScalingFilter -> Bool) -> Eq ScalingFilter
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScalingFilter -> ScalingFilter -> Bool
    == :: ScalingFilter -> ScalingFilter -> Bool
    $c/= :: ScalingFilter -> ScalingFilter -> Bool
    /= :: ScalingFilter -> ScalingFilter -> Bool
    Eq)

    instance P.Enum ScalingFilter where
        fromEnum :: ScalingFilter -> Int
    fromEnum ScalingFilter
    ScalingFilterLinear = Int
    0
        fromEnum ScalingFilter
    ScalingFilterNearest = Int
    1
        fromEnum ScalingFilter
    ScalingFilterTrilinear = Int
    2
        fromEnum (AnotherScalingFilter Int
    k) = Int
    k

        toEnum :: Int -> ScalingFilter
    toEnum Int
    0 = ScalingFilter
    ScalingFilterLinear
        toEnum Int
    1 = ScalingFilter
    ScalingFilterNearest
        toEnum Int
    2 = ScalingFilter
    ScalingFilterTrilinear
        toEnum Int
    k = Int -> ScalingFilter
    AnotherScalingFilter Int
    k

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

    type instance O.ParentTypes ScalingFilter = '[]
    instance O.HasParentTypes ScalingFilter

    foreign import ccall "gsk_scaling_filter_get_type" c_gsk_scaling_filter_get_type ::
        IO GType

    instance B.Types.TypedObject ScalingFilter where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_scaling_filter_get_type

    instance B.Types.BoxedEnum ScalingFilter

    -- Enum RenderNodeType
    -- | The type of a node determines what the node is rendering.
    data RenderNodeType =
          RenderNodeTypeNotARenderNode
        -- ^ Error type. No node will ever have this type.
        | RenderNodeTypeContainerNode
        -- ^ A node containing a stack of children
        | RenderNodeTypeCairoNode
        -- ^ A node drawing a @cairo_surface_t@
        | RenderNodeTypeColorNode
        -- ^ A node drawing a single color rectangle
        | RenderNodeTypeLinearGradientNode
        -- ^ A node drawing a linear gradient
        | RenderNodeTypeRepeatingLinearGradientNode
        -- ^ A node drawing a repeating linear gradient
        | RenderNodeTypeRadialGradientNode
        -- ^ A node drawing a radial gradient
        | RenderNodeTypeRepeatingRadialGradientNode
        -- ^ A node drawing a repeating radial gradient
        | RenderNodeTypeConicGradientNode
        -- ^ A node drawing a conic gradient
        | RenderNodeTypeBorderNode
        -- ^ A node stroking a border around an area
        | RenderNodeTypeTextureNode
        -- ^ A node drawing a @GdkTexture@
        | RenderNodeTypeInsetShadowNode
        -- ^ A node drawing an inset shadow
        | RenderNodeTypeOutsetShadowNode
        -- ^ A node drawing an outset shadow
        | RenderNodeTypeTransformNode
        -- ^ A node that renders its child after applying a matrix transform
        | RenderNodeTypeOpacityNode
        -- ^ A node that changes the opacity of its child
        | RenderNodeTypeColorMatrixNode
        -- ^ A node that applies a color matrix to every pixel
        | RenderNodeTypeRepeatNode
        -- ^ A node that repeats the child\'s contents
        | RenderNodeTypeClipNode
        -- ^ A node that clips its child to a rectangular area
        | RenderNodeTypeRoundedClipNode
        -- ^ A node that clips its child to a rounded rectangle
        | RenderNodeTypeShadowNode
        -- ^ A node that draws a shadow below its child
        | RenderNodeTypeBlendNode
        -- ^ A node that blends two children together
        | RenderNodeTypeCrossFadeNode
        -- ^ A node that cross-fades between two children
        | RenderNodeTypeTextNode
        -- ^ A node containing a glyph string
        | RenderNodeTypeBlurNode
        -- ^ A node that applies a blur
        | RenderNodeTypeDebugNode
        -- ^ Debug information that does not affect the rendering
        | RenderNodeTypeGlShaderNode
        -- ^ A node that uses OpenGL fragment shaders to render
        | RenderNodeTypeTextureScaleNode
        -- ^ A node drawing a @GdkTexture@ scaled and filtered.
        --
        -- /Since: 4.10/
        | RenderNodeTypeMaskNode
        -- ^ A node that masks one child with another.
        --
        -- /Since: 4.10/
        | RenderNodeTypeFillNode
        -- ^ A node that fills a path.
        --
        -- /Since: 4.14/
        | RenderNodeTypeStrokeNode
        -- ^ A node that strokes a path.
        --
        -- /Since: 4.14/
        | RenderNodeTypeSubsurfaceNode
        -- ^ A node that possibly redirects part of the scene graph to a subsurface.
        --
        -- /Since: 4.14/
        | RenderNodeTypeComponentTransferNode
        -- ^ A node that applies some function to each color component.
        --
        -- /Since: 4.20/
        | RenderNodeTypeCopyNode
        -- ^ A node that copies the rendering canvas to be pasted later.
        --
        -- /Since: 4.22/
        | RenderNodeTypePasteNode
        -- ^ A node that pastes a previously copied canvas.
        --
        -- /Since: 4.22/
        | RenderNodeTypeCompositeNode
        -- ^ A node that combines a child with the background using Porter\/Duff
        -- operations.
        --
        -- /Since: 4.22/
        | RenderNodeTypeIsolationNode
        -- ^ A node that isolated content of its child from previous content.
        --
        -- /Since: 4.22/
        | RenderNodeTypeDisplacementNode
        -- ^ A node that displaces content according to some mask.
        --
        -- /Since: 4.22/
        | RenderNodeTypeArithmeticNode
        -- ^ A node that combines two child nodes in an arithmetic way.
        --
        -- /Since: 4.22/
        | AnotherRenderNodeType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RenderNodeType -> ShowS
    [RenderNodeType] -> ShowS
    RenderNodeType -> String
    (Int -> RenderNodeType -> ShowS)
    -> (RenderNodeType -> String)
    -> ([RenderNodeType] -> ShowS)
    -> Show RenderNodeType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RenderNodeType -> ShowS
    showsPrec :: Int -> RenderNodeType -> ShowS
    $cshow :: RenderNodeType -> String
    show :: RenderNodeType -> String
    $cshowList :: [RenderNodeType] -> ShowS
    showList :: [RenderNodeType] -> ShowS
    Show, RenderNodeType -> RenderNodeType -> Bool
    (RenderNodeType -> RenderNodeType -> Bool)
    -> (RenderNodeType -> RenderNodeType -> Bool) -> Eq RenderNodeType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RenderNodeType -> RenderNodeType -> Bool
    == :: RenderNodeType -> RenderNodeType -> Bool
    $c/= :: RenderNodeType -> RenderNodeType -> Bool
    /= :: RenderNodeType -> RenderNodeType -> Bool
    Eq)

    instance P.Enum RenderNodeType where
        fromEnum :: RenderNodeType -> Int
    fromEnum RenderNodeType
    RenderNodeTypeNotARenderNode = Int
    0
        fromEnum RenderNodeType
    RenderNodeTypeContainerNode = Int
    1
        fromEnum RenderNodeType
    RenderNodeTypeCairoNode = Int
    2
        fromEnum RenderNodeType
    RenderNodeTypeColorNode = Int
    3
        fromEnum RenderNodeType
    RenderNodeTypeLinearGradientNode = Int
    4
        fromEnum RenderNodeType
    RenderNodeTypeRepeatingLinearGradientNode = Int
    5
        fromEnum RenderNodeType
    RenderNodeTypeRadialGradientNode = Int
    6
        fromEnum RenderNodeType
    RenderNodeTypeRepeatingRadialGradientNode = Int
    7
        fromEnum RenderNodeType
    RenderNodeTypeConicGradientNode = Int
    8
        fromEnum RenderNodeType
    RenderNodeTypeBorderNode = Int
    9
        fromEnum RenderNodeType
    RenderNodeTypeTextureNode = Int
    10
        fromEnum RenderNodeType
    RenderNodeTypeInsetShadowNode = Int
    11
        fromEnum RenderNodeType
    RenderNodeTypeOutsetShadowNode = Int
    12
        fromEnum RenderNodeType
    RenderNodeTypeTransformNode = Int
    13
        fromEnum RenderNodeType
    RenderNodeTypeOpacityNode = Int
    14
        fromEnum RenderNodeType
    RenderNodeTypeColorMatrixNode = Int
    15
        fromEnum RenderNodeType
    RenderNodeTypeRepeatNode = Int
    16
        fromEnum RenderNodeType
    RenderNodeTypeClipNode = Int
    17
        fromEnum RenderNodeType
    RenderNodeTypeRoundedClipNode = Int
    18
        fromEnum RenderNodeType
    RenderNodeTypeShadowNode = Int
    19
        fromEnum RenderNodeType
    RenderNodeTypeBlendNode = Int
    20
        fromEnum RenderNodeType
    RenderNodeTypeCrossFadeNode = Int
    21
        fromEnum RenderNodeType
    RenderNodeTypeTextNode = Int
    22
        fromEnum RenderNodeType
    RenderNodeTypeBlurNode = Int
    23
        fromEnum RenderNodeType
    RenderNodeTypeDebugNode = Int
    24
        fromEnum RenderNodeType
    RenderNodeTypeGlShaderNode = Int
    25
        fromEnum RenderNodeType
    RenderNodeTypeTextureScaleNode = Int
    26
        fromEnum RenderNodeType
    RenderNodeTypeMaskNode = Int
    27
        fromEnum RenderNodeType
    RenderNodeTypeFillNode = Int
    28
        fromEnum RenderNodeType
    RenderNodeTypeStrokeNode = Int
    29
        fromEnum RenderNodeType
    RenderNodeTypeSubsurfaceNode = Int
    30
        fromEnum RenderNodeType
    RenderNodeTypeComponentTransferNode = Int
    31
        fromEnum RenderNodeType
    RenderNodeTypeCopyNode = Int
    32
        fromEnum RenderNodeType
    RenderNodeTypePasteNode = Int
    33
        fromEnum RenderNodeType
    RenderNodeTypeCompositeNode = Int
    34
        fromEnum RenderNodeType
    RenderNodeTypeIsolationNode = Int
    35
        fromEnum RenderNodeType
    RenderNodeTypeDisplacementNode = Int
    36
        fromEnum RenderNodeType
    RenderNodeTypeArithmeticNode = Int
    37
        fromEnum (AnotherRenderNodeType Int
    k) = Int
    k

        toEnum :: Int -> RenderNodeType
    toEnum Int
    0 = RenderNodeType
    RenderNodeTypeNotARenderNode
        toEnum Int
    1 = RenderNodeType
    RenderNodeTypeContainerNode
        toEnum Int
    2 = RenderNodeType
    RenderNodeTypeCairoNode
        toEnum Int
    3 = RenderNodeType
    RenderNodeTypeColorNode
        toEnum Int
    4 = RenderNodeType
    RenderNodeTypeLinearGradientNode
        toEnum Int
    5 = RenderNodeType
    RenderNodeTypeRepeatingLinearGradientNode
        toEnum Int
    6 = RenderNodeType
    RenderNodeTypeRadialGradientNode
        toEnum Int
    7 = RenderNodeType
    RenderNodeTypeRepeatingRadialGradientNode
        toEnum Int
    8 = RenderNodeType
    RenderNodeTypeConicGradientNode
        toEnum Int
    9 = RenderNodeType
    RenderNodeTypeBorderNode
        toEnum Int
    10 = RenderNodeType
    RenderNodeTypeTextureNode
        toEnum Int
    11 = RenderNodeType
    RenderNodeTypeInsetShadowNode
        toEnum Int
    12 = RenderNodeType
    RenderNodeTypeOutsetShadowNode
        toEnum Int
    13 = RenderNodeType
    RenderNodeTypeTransformNode
        toEnum Int
    14 = RenderNodeType
    RenderNodeTypeOpacityNode
        toEnum Int
    15 = RenderNodeType
    RenderNodeTypeColorMatrixNode
        toEnum Int
    16 = RenderNodeType
    RenderNodeTypeRepeatNode
        toEnum Int
    17 = RenderNodeType
    RenderNodeTypeClipNode
        toEnum Int
    18 = RenderNodeType
    RenderNodeTypeRoundedClipNode
        toEnum Int
    19 = RenderNodeType
    RenderNodeTypeShadowNode
        toEnum Int
    20 = RenderNodeType
    RenderNodeTypeBlendNode
        toEnum Int
    21 = RenderNodeType
    RenderNodeTypeCrossFadeNode
        toEnum Int
    22 = RenderNodeType
    RenderNodeTypeTextNode
        toEnum Int
    23 = RenderNodeType
    RenderNodeTypeBlurNode
        toEnum Int
    24 = RenderNodeType
    RenderNodeTypeDebugNode
        toEnum Int
    25 = RenderNodeType
    RenderNodeTypeGlShaderNode
        toEnum Int
    26 = RenderNodeType
    RenderNodeTypeTextureScaleNode
        toEnum Int
    27 = RenderNodeType
    RenderNodeTypeMaskNode
        toEnum Int
    28 = RenderNodeType
    RenderNodeTypeFillNode
        toEnum Int
    29 = RenderNodeType
    RenderNodeTypeStrokeNode
        toEnum Int
    30 = RenderNodeType
    RenderNodeTypeSubsurfaceNode
        toEnum Int
    31 = RenderNodeType
    RenderNodeTypeComponentTransferNode
        toEnum Int
    32 = RenderNodeType
    RenderNodeTypeCopyNode
        toEnum Int
    33 = RenderNodeType
    RenderNodeTypePasteNode
        toEnum Int
    34 = RenderNodeType
    RenderNodeTypeCompositeNode
        toEnum Int
    35 = RenderNodeType
    RenderNodeTypeIsolationNode
        toEnum Int
    36 = RenderNodeType
    RenderNodeTypeDisplacementNode
        toEnum Int
    37 = RenderNodeType
    RenderNodeTypeArithmeticNode
        toEnum Int
    k = Int -> RenderNodeType
    AnotherRenderNodeType Int
    k

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

    type instance O.ParentTypes RenderNodeType = '[]
    instance O.HasParentTypes RenderNodeType

    foreign import ccall "gsk_render_node_type_get_type" c_gsk_render_node_type_get_type ::
        IO GType

    instance B.Types.TypedObject RenderNodeType where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_render_node_type_get_type

    instance B.Types.BoxedEnum RenderNodeType

    -- Enum PorterDuff
    -- | GSK_PORTER_DUFF_SOURCE:
    -- GSK_PORTER_DUFF_DEST:
    -- GSK_PORTER_DUFF_SOURCE_OVER_DEST:
    -- GSK_PORTER_DUFF_DEST_OVER_SOURCE:
    -- GSK_PORTER_DUFF_SOURCE_IN_DEST:
    -- GSK_PORTER_DUFF_DEST_IN_SOURCE:
    -- GSK_PORTER_DUFF_SOURCE_OUT_DEST:
    -- GSK_PORTER_DUFF_DEST_OUT_SOURCE:
    -- GSK_PORTER_DUFF_SOURCE_ATOP_DEST:
    -- GSK_PORTER_DUFF_DEST_ATOP_SOURCE:
    -- GSK_PORTER_DUFF_XOR:
    -- GSK_PORTER_DUFF_CLEAR:
    -- The 12 compositing modes defined by the seminal paper
    -- by Thomas Porter and Tom Duff.
    --
    -- They are used in SVG, PDF and in Cairo with @cairo_operator_t@.
    --
    -- /Since: 4.22/
    data PorterDuff =
          PorterDuffSource
        -- ^ /No description available in the introspection data./
        | PorterDuffDest
        -- ^ /No description available in the introspection data./
        | PorterDuffSourceOverDest
        -- ^ /No description available in the introspection data./
        | PorterDuffDestOverSource
        -- ^ /No description available in the introspection data./
        | PorterDuffSourceInDest
        -- ^ /No description available in the introspection data./
        | PorterDuffDestInSource
        -- ^ /No description available in the introspection data./
        | PorterDuffSourceOutDest
        -- ^ /No description available in the introspection data./
        | PorterDuffDestOutSource
        -- ^ /No description available in the introspection data./
        | PorterDuffSourceAtopDest
        -- ^ /No description available in the introspection data./
        | PorterDuffDestAtopSource
        -- ^ /No description available in the introspection data./
        | PorterDuffXor
        -- ^ /No description available in the introspection data./
        | PorterDuffClear
        -- ^ /No description available in the introspection data./
        | AnotherPorterDuff Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PorterDuff -> ShowS
    [PorterDuff] -> ShowS
    PorterDuff -> String
    (Int -> PorterDuff -> ShowS)
    -> (PorterDuff -> String)
    -> ([PorterDuff] -> ShowS)
    -> Show PorterDuff
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PorterDuff -> ShowS
    showsPrec :: Int -> PorterDuff -> ShowS
    $cshow :: PorterDuff -> String
    show :: PorterDuff -> String
    $cshowList :: [PorterDuff] -> ShowS
    showList :: [PorterDuff] -> ShowS
    Show, PorterDuff -> PorterDuff -> Bool
    (PorterDuff -> PorterDuff -> Bool)
    -> (PorterDuff -> PorterDuff -> Bool) -> Eq PorterDuff
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PorterDuff -> PorterDuff -> Bool
    == :: PorterDuff -> PorterDuff -> Bool
    $c/= :: PorterDuff -> PorterDuff -> Bool
    /= :: PorterDuff -> PorterDuff -> Bool
    Eq)

    instance P.Enum PorterDuff where
        fromEnum :: PorterDuff -> Int
    fromEnum PorterDuff
    PorterDuffSource = Int
    0
        fromEnum PorterDuff
    PorterDuffDest = Int
    1
        fromEnum PorterDuff
    PorterDuffSourceOverDest = Int
    2
        fromEnum PorterDuff
    PorterDuffDestOverSource = Int
    3
        fromEnum PorterDuff
    PorterDuffSourceInDest = Int
    4
        fromEnum PorterDuff
    PorterDuffDestInSource = Int
    5
        fromEnum PorterDuff
    PorterDuffSourceOutDest = Int
    6
        fromEnum PorterDuff
    PorterDuffDestOutSource = Int
    7
        fromEnum PorterDuff
    PorterDuffSourceAtopDest = Int
    8
        fromEnum PorterDuff
    PorterDuffDestAtopSource = Int
    9
        fromEnum PorterDuff
    PorterDuffXor = Int
    10
        fromEnum PorterDuff
    PorterDuffClear = Int
    11
        fromEnum (AnotherPorterDuff Int
    k) = Int
    k

        toEnum :: Int -> PorterDuff
    toEnum Int
    0 = PorterDuff
    PorterDuffSource
        toEnum Int
    1 = PorterDuff
    PorterDuffDest
        toEnum Int
    2 = PorterDuff
    PorterDuffSourceOverDest
        toEnum Int
    3 = PorterDuff
    PorterDuffDestOverSource
        toEnum Int
    4 = PorterDuff
    PorterDuffSourceInDest
        toEnum Int
    5 = PorterDuff
    PorterDuffDestInSource
        toEnum Int
    6 = PorterDuff
    PorterDuffSourceOutDest
        toEnum Int
    7 = PorterDuff
    PorterDuffDestOutSource
        toEnum Int
    8 = PorterDuff
    PorterDuffSourceAtopDest
        toEnum Int
    9 = PorterDuff
    PorterDuffDestAtopSource
        toEnum Int
    10 = PorterDuff
    PorterDuffXor
        toEnum Int
    11 = PorterDuff
    PorterDuffClear
        toEnum Int
    k = Int -> PorterDuff
    AnotherPorterDuff Int
    k

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

    type instance O.ParentTypes PorterDuff = '[]
    instance O.HasParentTypes PorterDuff

    foreign import ccall "gsk_porter_duff_get_type" c_gsk_porter_duff_get_type ::
        IO GType

    instance B.Types.TypedObject PorterDuff where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_porter_duff_get_type

    instance B.Types.BoxedEnum PorterDuff

    -- Enum PathOperation
    -- | Describes the segments of a @GskPath@.
    --
    -- More values may be added in the future.
    --
    -- /Since: 4.14/
    data PathOperation =
          PathOperationMove
        -- ^ A move-to operation, with 1 point describing the target point.
        | PathOperationClose
        -- ^ A close operation ending the current contour with a line back
        --   to the starting point. Two points describe the start and end of the line.
        | PathOperationLine
        -- ^ A line-to operation, with 2 points describing the start and
        --   end point of a straight line.
        | PathOperationQuad
        -- ^ A curve-to operation describing a quadratic Bézier curve
        --   with 3 points describing the start point, the control point and the end
        --   point of the curve.
        | PathOperationCubic
        -- ^ A curve-to operation describing a cubic Bézier curve with 4
        --   points describing the start point, the two control points and the end point
        --   of the curve.
        | PathOperationConic
        -- ^ A rational quadratic Bézier curve with 3 points describing
        --   the start point, control point and end point of the curve. A weight for the
        --   curve will be passed, too.
        | AnotherPathOperation Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PathOperation -> ShowS
    [PathOperation] -> ShowS
    PathOperation -> String
    (Int -> PathOperation -> ShowS)
    -> (PathOperation -> String)
    -> ([PathOperation] -> ShowS)
    -> Show PathOperation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PathOperation -> ShowS
    showsPrec :: Int -> PathOperation -> ShowS
    $cshow :: PathOperation -> String
    show :: PathOperation -> String
    $cshowList :: [PathOperation] -> ShowS
    showList :: [PathOperation] -> ShowS
    Show, PathOperation -> PathOperation -> Bool
    (PathOperation -> PathOperation -> Bool)
    -> (PathOperation -> PathOperation -> Bool) -> Eq PathOperation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PathOperation -> PathOperation -> Bool
    == :: PathOperation -> PathOperation -> Bool
    $c/= :: PathOperation -> PathOperation -> Bool
    /= :: PathOperation -> PathOperation -> Bool
    Eq)

    instance P.Enum PathOperation where
        fromEnum :: PathOperation -> Int
    fromEnum PathOperation
    PathOperationMove = Int
    0
        fromEnum PathOperation
    PathOperationClose = Int
    1
        fromEnum PathOperation
    PathOperationLine = Int
    2
        fromEnum PathOperation
    PathOperationQuad = Int
    3
        fromEnum PathOperation
    PathOperationCubic = Int
    4
        fromEnum PathOperation
    PathOperationConic = Int
    5
        fromEnum (AnotherPathOperation Int
    k) = Int
    k

        toEnum :: Int -> PathOperation
    toEnum Int
    0 = PathOperation
    PathOperationMove
        toEnum Int
    1 = PathOperation
    PathOperationClose
        toEnum Int
    2 = PathOperation
    PathOperationLine
        toEnum Int
    3 = PathOperation
    PathOperationQuad
        toEnum Int
    4 = PathOperation
    PathOperationCubic
        toEnum Int
    5 = PathOperation
    PathOperationConic
        toEnum Int
    k = Int -> PathOperation
    AnotherPathOperation Int
    k

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

    type instance O.ParentTypes PathOperation = '[]
    instance O.HasParentTypes PathOperation

    foreign import ccall "gsk_path_operation_get_type" c_gsk_path_operation_get_type ::
        IO GType

    instance B.Types.TypedObject PathOperation where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_path_operation_get_type

    instance B.Types.BoxedEnum PathOperation

    -- Enum PathIntersection
    -- | The values of this enumeration classify intersections
    -- between paths.
    --
    -- /Since: 4.20/
    data PathIntersection =
          PathIntersectionNone
        -- ^ No intersection
        | PathIntersectionNormal
        -- ^ A normal intersection, where the two paths
        --   cross each other
        | PathIntersectionStart
        -- ^ The start of a segment where the two paths coincide
        | PathIntersectionEnd
        -- ^ The end of a segment where the two paths coincide
        | AnotherPathIntersection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PathIntersection -> ShowS
    [PathIntersection] -> ShowS
    PathIntersection -> String
    (Int -> PathIntersection -> ShowS)
    -> (PathIntersection -> String)
    -> ([PathIntersection] -> ShowS)
    -> Show PathIntersection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PathIntersection -> ShowS
    showsPrec :: Int -> PathIntersection -> ShowS
    $cshow :: PathIntersection -> String
    show :: PathIntersection -> String
    $cshowList :: [PathIntersection] -> ShowS
    showList :: [PathIntersection] -> ShowS
    Show, PathIntersection -> PathIntersection -> Bool
    (PathIntersection -> PathIntersection -> Bool)
    -> (PathIntersection -> PathIntersection -> Bool)
    -> Eq PathIntersection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PathIntersection -> PathIntersection -> Bool
    == :: PathIntersection -> PathIntersection -> Bool
    $c/= :: PathIntersection -> PathIntersection -> Bool
    /= :: PathIntersection -> PathIntersection -> Bool
    Eq)

    instance P.Enum PathIntersection where
        fromEnum :: PathIntersection -> Int
    fromEnum PathIntersection
    PathIntersectionNone = Int
    0
        fromEnum PathIntersection
    PathIntersectionNormal = Int
    1
        fromEnum PathIntersection
    PathIntersectionStart = Int
    2
        fromEnum PathIntersection
    PathIntersectionEnd = Int
    3
        fromEnum (AnotherPathIntersection Int
    k) = Int
    k

        toEnum :: Int -> PathIntersection
    toEnum Int
    0 = PathIntersection
    PathIntersectionNone
        toEnum Int
    1 = PathIntersection
    PathIntersectionNormal
        toEnum Int
    2 = PathIntersection
    PathIntersectionStart
        toEnum Int
    3 = PathIntersection
    PathIntersectionEnd
        toEnum Int
    k = Int -> PathIntersection
    AnotherPathIntersection Int
    k

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

    type instance O.ParentTypes PathIntersection = '[]
    instance O.HasParentTypes PathIntersection

    foreign import ccall "gsk_path_intersection_get_type" c_gsk_path_intersection_get_type ::
        IO GType

    instance B.Types.TypedObject PathIntersection where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_path_intersection_get_type

    instance B.Types.BoxedEnum PathIntersection

    -- Enum PathDirection
    -- | Used to pick one of the four tangents at a given point on the path.
    --
    -- Note that the directions for /@gSKPATHFROMSTART@/\//@gSKPATHTOEND@/ and
    -- /@gSKPATHTOSTART@/\//@gSKPATHFROMEND@/ will coincide for smooth points.
    -- Only sharp turns will exhibit four different directions.
    --
    -- \<picture>
    --   \<source srcset=\"directions-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --   \<img alt=\"Path Tangents\" src=\"directions-light.png\">
    -- \<\/picture>
    --
    -- /Since: 4.14/
    data PathDirection =
          PathDirectionFromStart
        -- ^ The tangent in path direction of the incoming side
        --   of the path
        | PathDirectionToStart
        -- ^ The tangent against path direction of the incoming side
        --   of the path
        | PathDirectionToEnd
        -- ^ The tangent in path direction of the outgoing side
        --   of the path
        | PathDirectionFromEnd
        -- ^ The tangent against path direction of the outgoing
        --   side of the path
        | AnotherPathDirection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> PathDirection -> ShowS
    [PathDirection] -> ShowS
    PathDirection -> String
    (Int -> PathDirection -> ShowS)
    -> (PathDirection -> String)
    -> ([PathDirection] -> ShowS)
    -> Show PathDirection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PathDirection -> ShowS
    showsPrec :: Int -> PathDirection -> ShowS
    $cshow :: PathDirection -> String
    show :: PathDirection -> String
    $cshowList :: [PathDirection] -> ShowS
    showList :: [PathDirection] -> ShowS
    Show, PathDirection -> PathDirection -> Bool
    (PathDirection -> PathDirection -> Bool)
    -> (PathDirection -> PathDirection -> Bool) -> Eq PathDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PathDirection -> PathDirection -> Bool
    == :: PathDirection -> PathDirection -> Bool
    $c/= :: PathDirection -> PathDirection -> Bool
    /= :: PathDirection -> PathDirection -> Bool
    Eq)

    instance P.Enum PathDirection where
        fromEnum :: PathDirection -> Int
    fromEnum PathDirection
    PathDirectionFromStart = Int
    0
        fromEnum PathDirection
    PathDirectionToStart = Int
    1
        fromEnum PathDirection
    PathDirectionToEnd = Int
    2
        fromEnum PathDirection
    PathDirectionFromEnd = Int
    3
        fromEnum (AnotherPathDirection Int
    k) = Int
    k

        toEnum :: Int -> PathDirection
    toEnum Int
    0 = PathDirection
    PathDirectionFromStart
        toEnum Int
    1 = PathDirection
    PathDirectionToStart
        toEnum Int
    2 = PathDirection
    PathDirectionToEnd
        toEnum Int
    3 = PathDirection
    PathDirectionFromEnd
        toEnum Int
    k = Int -> PathDirection
    AnotherPathDirection Int
    k

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

    type instance O.ParentTypes PathDirection = '[]
    instance O.HasParentTypes PathDirection

    foreign import ccall "gsk_path_direction_get_type" c_gsk_path_direction_get_type ::
        IO GType

    instance B.Types.TypedObject PathDirection where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_path_direction_get_type

    instance B.Types.BoxedEnum PathDirection

    -- Enum MaskMode
    -- | The mask modes available for mask nodes.
    --
    -- /Since: 4.10/
    data MaskMode =
          MaskModeAlpha
        -- ^ Use the alpha channel of the mask
        | MaskModeInvertedAlpha
        -- ^ Use the inverted alpha channel of the mask
        | MaskModeLuminance
        -- ^ Use the luminance of the mask,
        --     multiplied by mask alpha
        | MaskModeInvertedLuminance
        -- ^ Use the inverted luminance of the mask,
        --     multiplied by mask alpha
        | AnotherMaskMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> MaskMode -> ShowS
    [MaskMode] -> ShowS
    MaskMode -> String
    (Int -> MaskMode -> ShowS)
    -> (MaskMode -> String) -> ([MaskMode] -> ShowS) -> Show MaskMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MaskMode -> ShowS
    showsPrec :: Int -> MaskMode -> ShowS
    $cshow :: MaskMode -> String
    show :: MaskMode -> String
    $cshowList :: [MaskMode] -> ShowS
    showList :: [MaskMode] -> ShowS
    Show, MaskMode -> MaskMode -> Bool
    (MaskMode -> MaskMode -> Bool)
    -> (MaskMode -> MaskMode -> Bool) -> Eq MaskMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MaskMode -> MaskMode -> Bool
    == :: MaskMode -> MaskMode -> Bool
    $c/= :: MaskMode -> MaskMode -> Bool
    /= :: MaskMode -> MaskMode -> Bool
    Eq)

    instance P.Enum MaskMode where
        fromEnum :: MaskMode -> Int
    fromEnum MaskMode
    MaskModeAlpha = Int
    0
        fromEnum MaskMode
    MaskModeInvertedAlpha = Int
    1
        fromEnum MaskMode
    MaskModeLuminance = Int
    2
        fromEnum MaskMode
    MaskModeInvertedLuminance = Int
    3
        fromEnum (AnotherMaskMode Int
    k) = Int
    k

        toEnum :: Int -> MaskMode
    toEnum Int
    0 = MaskMode
    MaskModeAlpha
        toEnum Int
    1 = MaskMode
    MaskModeInvertedAlpha
        toEnum Int
    2 = MaskMode
    MaskModeLuminance
        toEnum Int
    3 = MaskMode
    MaskModeInvertedLuminance
        toEnum Int
    k = Int -> MaskMode
    AnotherMaskMode Int
    k

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

    type instance O.ParentTypes MaskMode = '[]
    instance O.HasParentTypes MaskMode

    foreign import ccall "gsk_mask_mode_get_type" c_gsk_mask_mode_get_type ::
        IO GType

    instance B.Types.TypedObject MaskMode where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_mask_mode_get_type

    instance B.Types.BoxedEnum MaskMode

    -- Enum LineJoin
    -- | Specifies how to render the junction of two lines when stroking.
    --
    -- The default line join style is @GSK_LINE_JOIN_MITER@.
    --
    -- New entries may be added in future versions.
    --
    -- \<figure>
    --   \<picture>
    --     \<source srcset=\"join-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --     \<img alt=\"Line Join Styles\" src=\"join-light.png\">
    --   \<\/picture>
    --   \<figcaption>GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL\<\/figcaption>
    -- \<\/figure>
    --
    -- /Since: 4.14/
    data LineJoin =
          LineJoinMiter
        -- ^ Use a sharp angled corner
        | LineJoinRound
        -- ^ Use a round join, the center of the circle is
        --   the join point
        | LineJoinBevel
        -- ^ use a cut-off join, the join is cut off at half
        --   the line width from the joint point
        | AnotherLineJoin Int
        -- ^ Catch-all for unknown values
        deriving (Int -> LineJoin -> ShowS
    [LineJoin] -> ShowS
    LineJoin -> String
    (Int -> LineJoin -> ShowS)
    -> (LineJoin -> String) -> ([LineJoin] -> ShowS) -> Show LineJoin
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LineJoin -> ShowS
    showsPrec :: Int -> LineJoin -> ShowS
    $cshow :: LineJoin -> String
    show :: LineJoin -> String
    $cshowList :: [LineJoin] -> ShowS
    showList :: [LineJoin] -> ShowS
    Show, LineJoin -> LineJoin -> Bool
    (LineJoin -> LineJoin -> Bool)
    -> (LineJoin -> LineJoin -> Bool) -> Eq LineJoin
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LineJoin -> LineJoin -> Bool
    == :: LineJoin -> LineJoin -> Bool
    $c/= :: LineJoin -> LineJoin -> Bool
    /= :: LineJoin -> LineJoin -> Bool
    Eq)

    instance P.Enum LineJoin where
        fromEnum :: LineJoin -> Int
    fromEnum LineJoin
    LineJoinMiter = Int
    0
        fromEnum LineJoin
    LineJoinRound = Int
    1
        fromEnum LineJoin
    LineJoinBevel = Int
    2
        fromEnum (AnotherLineJoin Int
    k) = Int
    k

        toEnum :: Int -> LineJoin
    toEnum Int
    0 = LineJoin
    LineJoinMiter
        toEnum Int
    1 = LineJoin
    LineJoinRound
        toEnum Int
    2 = LineJoin
    LineJoinBevel
        toEnum Int
    k = Int -> LineJoin
    AnotherLineJoin Int
    k

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

    type instance O.ParentTypes LineJoin = '[]
    instance O.HasParentTypes LineJoin

    foreign import ccall "gsk_line_join_get_type" c_gsk_line_join_get_type ::
        IO GType

    instance B.Types.TypedObject LineJoin where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_line_join_get_type

    instance B.Types.BoxedEnum LineJoin

    -- Enum LineCap
    -- | Specifies how to render the start and end points of contours or
    -- dashes when stroking.
    --
    -- The default line cap style is @GSK_LINE_CAP_BUTT@.
    --
    -- New entries may be added in future versions.
    --
    -- \<figure>
    --   \<picture>
    --     \<source srcset=\"caps-dark.png\" media=\"(prefers-color-scheme: dark)\">
    --     \<img alt=\"Line Cap Styles\" src=\"caps-light.png\">
    --   \<\/picture>
    --   \<figcaption>GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE\<\/figcaption>
    -- \<\/figure>
    --
    -- /Since: 4.14/
    data LineCap =
          LineCapButt
        -- ^ Start and stop the line exactly at the start
        --   and end point
        | LineCapRound
        -- ^ Use a round ending, the center of the circle
        --   is the start or end point
        | LineCapSquare
        -- ^ use squared ending, the center of the square
        --   is the start or end point
        | AnotherLineCap Int
        -- ^ Catch-all for unknown values
        deriving (Int -> LineCap -> ShowS
    [LineCap] -> ShowS
    LineCap -> String
    (Int -> LineCap -> ShowS)
    -> (LineCap -> String) -> ([LineCap] -> ShowS) -> Show LineCap
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LineCap -> ShowS
    showsPrec :: Int -> LineCap -> ShowS
    $cshow :: LineCap -> String
    show :: LineCap -> String
    $cshowList :: [LineCap] -> ShowS
    showList :: [LineCap] -> ShowS
    Show, LineCap -> LineCap -> Bool
    (LineCap -> LineCap -> Bool)
    -> (LineCap -> LineCap -> Bool) -> Eq LineCap
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LineCap -> LineCap -> Bool
    == :: LineCap -> LineCap -> Bool
    $c/= :: LineCap -> LineCap -> Bool
    /= :: LineCap -> LineCap -> Bool
    Eq)

    instance P.Enum LineCap where
        fromEnum :: LineCap -> Int
    fromEnum LineCap
    LineCapButt = Int
    0
        fromEnum LineCap
    LineCapRound = Int
    1
        fromEnum LineCap
    LineCapSquare = Int
    2
        fromEnum (AnotherLineCap Int
    k) = Int
    k

        toEnum :: Int -> LineCap
    toEnum Int
    0 = LineCap
    LineCapButt
        toEnum Int
    1 = LineCap
    LineCapRound
        toEnum Int
    2 = LineCap
    LineCapSquare
        toEnum Int
    k = Int -> LineCap
    AnotherLineCap Int
    k

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

    type instance O.ParentTypes LineCap = '[]
    instance O.HasParentTypes LineCap

    foreign import ccall "gsk_line_cap_get_type" c_gsk_line_cap_get_type ::
        IO GType

    instance B.Types.TypedObject LineCap where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_line_cap_get_type

    instance B.Types.BoxedEnum LineCap

    -- Enum GLUniformType
    {-# DEPRECATED GLUniformType ["(Since version 4.16)"] #-}
    -- | Defines the types of the uniforms that @GskGLShaders@ declare.
    --
    -- It defines both what the type is called in the GLSL shader
    -- code, and what the corresponding C type is on the Gtk side.
    data GLUniformType =
          GLUniformTypeNone
        -- ^ No type, used for uninitialized or unspecified values.
        | GLUniformTypeFloat
        -- ^ A float uniform
        | GLUniformTypeInt
        -- ^ A GLSL int \/ gint32 uniform
        | GLUniformTypeUint
        -- ^ A GLSL uint \/ guint32 uniform
        | GLUniformTypeBool
        -- ^ A GLSL bool \/ gboolean uniform
        | GLUniformTypeVec2
        -- ^ A GLSL vec2 \/ graphene_vec2_t uniform
        | GLUniformTypeVec3
        -- ^ A GLSL vec3 \/ graphene_vec3_t uniform
        | GLUniformTypeVec4
        -- ^ A GLSL vec4 \/ graphene_vec4_t uniform
        | AnotherGLUniformType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> GLUniformType -> ShowS
    [GLUniformType] -> ShowS
    GLUniformType -> String
    (Int -> GLUniformType -> ShowS)
    -> (GLUniformType -> String)
    -> ([GLUniformType] -> ShowS)
    -> Show GLUniformType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> GLUniformType -> ShowS
    showsPrec :: Int -> GLUniformType -> ShowS
    $cshow :: GLUniformType -> String
    show :: GLUniformType -> String
    $cshowList :: [GLUniformType] -> ShowS
    showList :: [GLUniformType] -> ShowS
    Show, GLUniformType -> GLUniformType -> Bool
    (GLUniformType -> GLUniformType -> Bool)
    -> (GLUniformType -> GLUniformType -> Bool) -> Eq GLUniformType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GLUniformType -> GLUniformType -> Bool
    == :: GLUniformType -> GLUniformType -> Bool
    $c/= :: GLUniformType -> GLUniformType -> Bool
    /= :: GLUniformType -> GLUniformType -> Bool
    Eq)

    instance P.Enum GLUniformType where
        fromEnum :: GLUniformType -> Int
    fromEnum GLUniformType
    GLUniformTypeNone = Int
    0
        fromEnum GLUniformType
    GLUniformTypeFloat = Int
    1
        fromEnum GLUniformType
    GLUniformTypeInt = Int
    2
        fromEnum GLUniformType
    GLUniformTypeUint = Int
    3
        fromEnum GLUniformType
    GLUniformTypeBool = Int
    4
        fromEnum GLUniformType
    GLUniformTypeVec2 = Int
    5
        fromEnum GLUniformType
    GLUniformTypeVec3 = Int
    6
        fromEnum GLUniformType
    GLUniformTypeVec4 = Int
    7
        fromEnum (AnotherGLUniformType Int
    k) = Int
    k

        toEnum :: Int -> GLUniformType
    toEnum Int
    0 = GLUniformType
    GLUniformTypeNone
        toEnum Int
    1 = GLUniformType
    GLUniformTypeFloat
        toEnum Int
    2 = GLUniformType
    GLUniformTypeInt
        toEnum Int
    3 = GLUniformType
    GLUniformTypeUint
        toEnum Int
    4 = GLUniformType
    GLUniformTypeBool
        toEnum Int
    5 = GLUniformType
    GLUniformTypeVec2
        toEnum Int
    6 = GLUniformType
    GLUniformTypeVec3
        toEnum Int
    7 = GLUniformType
    GLUniformTypeVec4
        toEnum Int
    k = Int -> GLUniformType
    AnotherGLUniformType Int
    k

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

    type instance O.ParentTypes GLUniformType = '[]
    instance O.HasParentTypes GLUniformType

    foreign import ccall "gsk_gl_uniform_type_get_type" c_gsk_gl_uniform_type_get_type ::
        IO GType

    instance B.Types.TypedObject GLUniformType where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_gl_uniform_type_get_type

    instance B.Types.BoxedEnum GLUniformType

    -- Enum FillRule
    -- | Specifies how paths are filled.
    --
    -- Whether or not a point is included in the fill is determined by taking
    -- a ray from that point to infinity and looking at intersections with the
    -- path. The ray can be in any direction, as long as it doesn\'t pass through
    -- the end point of a segment or have a tricky intersection such as
    -- intersecting tangent to the path.
    --
    -- (Note that filling is not actually implemented in this way. This
    -- is just a description of the rule that is applied.)
    --
    -- New entries may be added in future versions.
    --
    -- /Since: 4.14/
    data FillRule =
          FillRuleWinding
        -- ^ If the path crosses the ray from
        --   left-to-right, counts +1. If the path crosses the ray
        --   from right to left, counts -1. (Left and right are determined
        --   from the perspective of looking along the ray from the starting
        --   point.) If the total count is non-zero, the point will be filled.
        | FillRuleEvenOdd
        -- ^ Counts the total number of
        --   intersections, without regard to the orientation of the contour. If
        --   the total number of intersections is odd, the point will be
        --   filled.
        | AnotherFillRule Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FillRule -> ShowS
    [FillRule] -> ShowS
    FillRule -> String
    (Int -> FillRule -> ShowS)
    -> (FillRule -> String) -> ([FillRule] -> ShowS) -> Show FillRule
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FillRule -> ShowS
    showsPrec :: Int -> FillRule -> ShowS
    $cshow :: FillRule -> String
    show :: FillRule -> String
    $cshowList :: [FillRule] -> ShowS
    showList :: [FillRule] -> ShowS
    Show, FillRule -> FillRule -> Bool
    (FillRule -> FillRule -> Bool)
    -> (FillRule -> FillRule -> Bool) -> Eq FillRule
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FillRule -> FillRule -> Bool
    == :: FillRule -> FillRule -> Bool
    $c/= :: FillRule -> FillRule -> Bool
    /= :: FillRule -> FillRule -> Bool
    Eq)

    instance P.Enum FillRule where
        fromEnum :: FillRule -> Int
    fromEnum FillRule
    FillRuleWinding = Int
    0
        fromEnum FillRule
    FillRuleEvenOdd = Int
    1
        fromEnum (AnotherFillRule Int
    k) = Int
    k

        toEnum :: Int -> FillRule
    toEnum Int
    0 = FillRule
    FillRuleWinding
        toEnum Int
    1 = FillRule
    FillRuleEvenOdd
        toEnum Int
    k = Int -> FillRule
    AnotherFillRule Int
    k

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

    type instance O.ParentTypes FillRule = '[]
    instance O.HasParentTypes FillRule

    foreign import ccall "gsk_fill_rule_get_type" c_gsk_fill_rule_get_type ::
        IO GType

    instance B.Types.TypedObject FillRule where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_fill_rule_get_type

    instance B.Types.BoxedEnum FillRule

    -- Enum Corner
    -- | The corner indices used by @GskRoundedRect@.
    data Corner =
          CornerTopLeft
        -- ^ The top left corner
        | CornerTopRight
        -- ^ The top right corner
        | CornerBottomRight
        -- ^ The bottom right corner
        | CornerBottomLeft
        -- ^ The bottom left corner
        | AnotherCorner Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Corner -> ShowS
    [Corner] -> ShowS
    Corner -> String
    (Int -> Corner -> ShowS)
    -> (Corner -> String) -> ([Corner] -> ShowS) -> Show Corner
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Corner -> ShowS
    showsPrec :: Int -> Corner -> ShowS
    $cshow :: Corner -> String
    show :: Corner -> String
    $cshowList :: [Corner] -> ShowS
    showList :: [Corner] -> ShowS
    Show, Corner -> Corner -> Bool
    (Corner -> Corner -> Bool)
    -> (Corner -> Corner -> Bool) -> Eq Corner
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Corner -> Corner -> Bool
    == :: Corner -> Corner -> Bool
    $c/= :: Corner -> Corner -> Bool
    /= :: Corner -> Corner -> Bool
    Eq)

    instance P.Enum Corner where
        fromEnum :: Corner -> Int
    fromEnum Corner
    CornerTopLeft = Int
    0
        fromEnum Corner
    CornerTopRight = Int
    1
        fromEnum Corner
    CornerBottomRight = Int
    2
        fromEnum Corner
    CornerBottomLeft = Int
    3
        fromEnum (AnotherCorner Int
    k) = Int
    k

        toEnum :: Int -> Corner
    toEnum Int
    0 = Corner
    CornerTopLeft
        toEnum Int
    1 = Corner
    CornerTopRight
        toEnum Int
    2 = Corner
    CornerBottomRight
        toEnum Int
    3 = Corner
    CornerBottomLeft
        toEnum Int
    k = Int -> Corner
    AnotherCorner Int
    k

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

    type instance O.ParentTypes Corner = '[]
    instance O.HasParentTypes Corner

    foreign import ccall "gsk_corner_get_type" c_gsk_corner_get_type ::
        IO GType

    instance B.Types.TypedObject Corner where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_corner_get_type

    instance B.Types.BoxedEnum Corner

    -- Enum BlendMode
    -- | The blend modes available for render nodes.
    --
    -- The implementation of each blend mode is deferred to the
    -- rendering pipeline.
    --
    -- See \<https:\/\/www.w3.org\/TR\/compositing-1\/@/blending/@> for more information
    -- on blending and blend modes.
    data BlendMode =
          BlendModeDefault
        -- ^ The default blend mode, which specifies no blending
        | BlendModeMultiply
        -- ^ The source color is multiplied by the destination
        --   and replaces the destination
        | BlendModeScreen
        -- ^ Multiplies the complements of the destination and source
        --   color values, then complements the result.
        | BlendModeOverlay
        -- ^ Multiplies or screens the colors, depending on the
        --   destination color value. This is the inverse of hard-list
        | BlendModeDarken
        -- ^ Selects the darker of the destination and source colors
        | BlendModeLighten
        -- ^ Selects the lighter of the destination and source colors
        | BlendModeColorDodge
        -- ^ Brightens the destination color to reflect the source color
        | BlendModeColorBurn
        -- ^ Darkens the destination color to reflect the source color
        | BlendModeHardLight
        -- ^ Multiplies or screens the colors, depending on the source color value
        | BlendModeSoftLight
        -- ^ Darkens or lightens the colors, depending on the source color value
        | BlendModeDifference
        -- ^ Subtracts the darker of the two constituent colors from the lighter color
        | BlendModeExclusion
        -- ^ Produces an effect similar to that of the difference mode but lower in contrast
        | BlendModeColor
        -- ^ Creates a color with the hue and saturation of the source color and the luminosity of the destination color
        | BlendModeHue
        -- ^ Creates a color with the hue of the source color and the saturation and luminosity of the destination color
        | BlendModeSaturation
        -- ^ Creates a color with the saturation of the source color and the hue and luminosity of the destination color
        | BlendModeLuminosity
        -- ^ Creates a color with the luminosity of the source color and the hue and saturation of the destination color
        | AnotherBlendMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BlendMode -> ShowS
    [BlendMode] -> ShowS
    BlendMode -> String
    (Int -> BlendMode -> ShowS)
    -> (BlendMode -> String)
    -> ([BlendMode] -> ShowS)
    -> Show BlendMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BlendMode -> ShowS
    showsPrec :: Int -> BlendMode -> ShowS
    $cshow :: BlendMode -> String
    show :: BlendMode -> String
    $cshowList :: [BlendMode] -> ShowS
    showList :: [BlendMode] -> ShowS
    Show, BlendMode -> BlendMode -> Bool
    (BlendMode -> BlendMode -> Bool)
    -> (BlendMode -> BlendMode -> Bool) -> Eq BlendMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BlendMode -> BlendMode -> Bool
    == :: BlendMode -> BlendMode -> Bool
    $c/= :: BlendMode -> BlendMode -> Bool
    /= :: BlendMode -> BlendMode -> Bool
    Eq)

    instance P.Enum BlendMode where
        fromEnum :: BlendMode -> Int
    fromEnum BlendMode
    BlendModeDefault = Int
    0
        fromEnum BlendMode
    BlendModeMultiply = Int
    1
        fromEnum BlendMode
    BlendModeScreen = Int
    2
        fromEnum BlendMode
    BlendModeOverlay = Int
    3
        fromEnum BlendMode
    BlendModeDarken = Int
    4
        fromEnum BlendMode
    BlendModeLighten = Int
    5
        fromEnum BlendMode
    BlendModeColorDodge = Int
    6
        fromEnum BlendMode
    BlendModeColorBurn = Int
    7
        fromEnum BlendMode
    BlendModeHardLight = Int
    8
        fromEnum BlendMode
    BlendModeSoftLight = Int
    9
        fromEnum BlendMode
    BlendModeDifference = Int
    10
        fromEnum BlendMode
    BlendModeExclusion = Int
    11
        fromEnum BlendMode
    BlendModeColor = Int
    12
        fromEnum BlendMode
    BlendModeHue = Int
    13
        fromEnum BlendMode
    BlendModeSaturation = Int
    14
        fromEnum BlendMode
    BlendModeLuminosity = Int
    15
        fromEnum (AnotherBlendMode Int
    k) = Int
    k

        toEnum :: Int -> BlendMode
    toEnum Int
    0 = BlendMode
    BlendModeDefault
        toEnum Int
    1 = BlendMode
    BlendModeMultiply
        toEnum Int
    2 = BlendMode
    BlendModeScreen
        toEnum Int
    3 = BlendMode
    BlendModeOverlay
        toEnum Int
    4 = BlendMode
    BlendModeDarken
        toEnum Int
    5 = BlendMode
    BlendModeLighten
        toEnum Int
    6 = BlendMode
    BlendModeColorDodge
        toEnum Int
    7 = BlendMode
    BlendModeColorBurn
        toEnum Int
    8 = BlendMode
    BlendModeHardLight
        toEnum Int
    9 = BlendMode
    BlendModeSoftLight
        toEnum Int
    10 = BlendMode
    BlendModeDifference
        toEnum Int
    11 = BlendMode
    BlendModeExclusion
        toEnum Int
    12 = BlendMode
    BlendModeColor
        toEnum Int
    13 = BlendMode
    BlendModeHue
        toEnum Int
    14 = BlendMode
    BlendModeSaturation
        toEnum Int
    15 = BlendMode
    BlendModeLuminosity
        toEnum Int
    k = Int -> BlendMode
    AnotherBlendMode Int
    k

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

    type instance O.ParentTypes BlendMode = '[]
    instance O.HasParentTypes BlendMode

    foreign import ccall "gsk_blend_mode_get_type" c_gsk_blend_mode_get_type ::
        IO GType

    instance B.Types.TypedObject BlendMode where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_blend_mode_get_type

    instance B.Types.BoxedEnum BlendMode