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

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

    module GI.HarfBuzz.Flags
        (

     -- * Flags
    -- ** BufferDiffFlagsT #flag:BufferDiffFlagsT#

        BufferDiffFlagsT(..)                    ,

    -- ** BufferFlagsT #flag:BufferFlagsT#

        BufferFlagsT(..)                        ,

    -- ** BufferSerializeFlagsT #flag:BufferSerializeFlagsT#

        BufferSerializeFlagsT(..)               ,

    -- ** GlyphFlagsT #flag:GlyphFlagsT#

        GlyphFlagsT(..)                         ,

    -- ** OtColorPaletteFlagsT #flag:OtColorPaletteFlagsT#

        OtColorPaletteFlagsT(..)                ,

    -- ** OtMathGlyphPartFlagsT #flag:OtMathGlyphPartFlagsT#

        OtMathGlyphPartFlagsT(..)               ,

    -- ** OtVarAxisFlagsT #flag:OtVarAxisFlagsT#

        OtVarAxisFlagsT(..)                     ,

        ) 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.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.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

    -- Flags ot_var_axis_flags_t
    -- | /No description available in the introspection data./
    --
    -- /Since: 2.2.0/
    data OtVarAxisFlagsT =
          OtVarAxisFlagsTHidden
        -- ^ The axis should not be exposed directly in user interfaces.
        | AnotherOtVarAxisFlagsT Int
        -- ^ Catch-all for unknown values
        deriving (Int -> OtVarAxisFlagsT -> ShowS
    [OtVarAxisFlagsT] -> ShowS
    OtVarAxisFlagsT -> String
    (Int -> OtVarAxisFlagsT -> ShowS)
    -> (OtVarAxisFlagsT -> String)
    -> ([OtVarAxisFlagsT] -> ShowS)
    -> Show OtVarAxisFlagsT
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [OtVarAxisFlagsT] -> ShowS
    $cshowList :: [OtVarAxisFlagsT] -> ShowS
    show :: OtVarAxisFlagsT -> String
    $cshow :: OtVarAxisFlagsT -> String
    showsPrec :: Int -> OtVarAxisFlagsT -> ShowS
    $cshowsPrec :: Int -> OtVarAxisFlagsT -> ShowS
    Show, OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    (OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
    -> (OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
    -> Eq OtVarAxisFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    $c/= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    == :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    $c== :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    Eq)

    instance P.Enum OtVarAxisFlagsT where
        fromEnum :: OtVarAxisFlagsT -> Int
    fromEnum OtVarAxisFlagsTHidden = 1
        fromEnum (AnotherOtVarAxisFlagsT k :: Int
    k) = Int
    k

        toEnum :: Int -> OtVarAxisFlagsT
    toEnum 1 = OtVarAxisFlagsT
    OtVarAxisFlagsTHidden
        toEnum k :: Int
    k = Int -> OtVarAxisFlagsT
    AnotherOtVarAxisFlagsT Int
    k

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

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

    foreign import ccall "hb_gobject_ot_var_axis_flags_get_type" c_hb_gobject_ot_var_axis_flags_get_type ::
        IO GType

    instance B.Types.TypedObject OtVarAxisFlagsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_ot_var_axis_flags_get_type

    instance B.Types.BoxedFlags OtVarAxisFlagsT

    instance IsGFlag OtVarAxisFlagsT

    -- Flags ot_math_glyph_part_flags_t
    -- | Flags for math glyph parts.
    --
    -- /Since: 1.3.3/
    data OtMathGlyphPartFlagsT =
          OtMathGlyphPartFlagsTExtender
        -- ^ /No description available in the introspection data./
        | AnotherOtMathGlyphPartFlagsT Int
        -- ^ Catch-all for unknown values
        deriving (Int -> OtMathGlyphPartFlagsT -> ShowS
    [OtMathGlyphPartFlagsT] -> ShowS
    OtMathGlyphPartFlagsT -> String
    (Int -> OtMathGlyphPartFlagsT -> ShowS)
    -> (OtMathGlyphPartFlagsT -> String)
    -> ([OtMathGlyphPartFlagsT] -> ShowS)
    -> Show OtMathGlyphPartFlagsT
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [OtMathGlyphPartFlagsT] -> ShowS
    $cshowList :: [OtMathGlyphPartFlagsT] -> ShowS
    show :: OtMathGlyphPartFlagsT -> String
    $cshow :: OtMathGlyphPartFlagsT -> String
    showsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
    $cshowsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
    Show, OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    (OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
    -> (OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
    -> Eq OtMathGlyphPartFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    $c/= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    == :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    $c== :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    Eq)

    instance P.Enum OtMathGlyphPartFlagsT where
        fromEnum :: OtMathGlyphPartFlagsT -> Int
    fromEnum OtMathGlyphPartFlagsTExtender = 1
        fromEnum (AnotherOtMathGlyphPartFlagsT k :: Int
    k) = Int
    k

        toEnum :: Int -> OtMathGlyphPartFlagsT
    toEnum 1 = OtMathGlyphPartFlagsT
    OtMathGlyphPartFlagsTExtender
        toEnum k :: Int
    k = Int -> OtMathGlyphPartFlagsT
    AnotherOtMathGlyphPartFlagsT Int
    k

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

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

    foreign import ccall "hb_gobject_ot_math_glyph_part_flags_get_type" c_hb_gobject_ot_math_glyph_part_flags_get_type ::
        IO GType

    instance B.Types.TypedObject OtMathGlyphPartFlagsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_ot_math_glyph_part_flags_get_type

    instance B.Types.BoxedFlags OtMathGlyphPartFlagsT

    instance IsGFlag OtMathGlyphPartFlagsT

    -- Flags ot_color_palette_flags_t
    -- | /No description available in the introspection data./
    --
    -- /Since: 2.1.0/
    data OtColorPaletteFlagsT =
          OtColorPaletteFlagsTDefault
        -- ^ Default indicating that there is nothing special
        --   to note about a color palette.
        | OtColorPaletteFlagsTUsableWithLightBackground
        -- ^ Flag indicating that the color
        --   palette is appropriate to use when displaying the font on a light background such as white.
        | OtColorPaletteFlagsTUsableWithDarkBackground
        -- ^ Flag indicating that the color
        --   palette is appropriate to use when displaying the font on a dark background such as black.
        | AnotherOtColorPaletteFlagsT Int
        -- ^ Catch-all for unknown values
        deriving (Int -> OtColorPaletteFlagsT -> ShowS
    [OtColorPaletteFlagsT] -> ShowS
    OtColorPaletteFlagsT -> String
    (Int -> OtColorPaletteFlagsT -> ShowS)
    -> (OtColorPaletteFlagsT -> String)
    -> ([OtColorPaletteFlagsT] -> ShowS)
    -> Show OtColorPaletteFlagsT
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [OtColorPaletteFlagsT] -> ShowS
    $cshowList :: [OtColorPaletteFlagsT] -> ShowS
    show :: OtColorPaletteFlagsT -> String
    $cshow :: OtColorPaletteFlagsT -> String
    showsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
    $cshowsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
    Show, OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    (OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
    -> (OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
    -> Eq OtColorPaletteFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    $c/= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    == :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    $c== :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    Eq)

    instance P.Enum OtColorPaletteFlagsT where
        fromEnum :: OtColorPaletteFlagsT -> Int
    fromEnum OtColorPaletteFlagsTDefault = 0
        fromEnum OtColorPaletteFlagsTUsableWithLightBackground = 1
        fromEnum OtColorPaletteFlagsTUsableWithDarkBackground = 2
        fromEnum (AnotherOtColorPaletteFlagsT k :: Int
    k) = Int
    k

        toEnum :: Int -> OtColorPaletteFlagsT
    toEnum 0 = OtColorPaletteFlagsT
    OtColorPaletteFlagsTDefault
        toEnum 1 = OtColorPaletteFlagsT
    OtColorPaletteFlagsTUsableWithLightBackground
        toEnum 2 = OtColorPaletteFlagsT
    OtColorPaletteFlagsTUsableWithDarkBackground
        toEnum k :: Int
    k = Int -> OtColorPaletteFlagsT
    AnotherOtColorPaletteFlagsT Int
    k

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

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

    foreign import ccall "hb_gobject_ot_color_palette_flags_get_type" c_hb_gobject_ot_color_palette_flags_get_type ::
        IO GType

    instance B.Types.TypedObject OtColorPaletteFlagsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_ot_color_palette_flags_get_type

    instance B.Types.BoxedFlags OtColorPaletteFlagsT

    instance IsGFlag OtColorPaletteFlagsT

    -- Flags glyph_flags_t
    -- | /No description available in the introspection data./
    --
    -- /Since: 1.5.0/
    data GlyphFlagsT =
          GlyphFlagsTUnsafeToBreak
        -- ^ Indicates that if input text is broken at the
        -- 				   beginning of the cluster this glyph is part of,
        -- 				   then both sides need to be re-shaped, as the
        -- 				   result might be different.  On the flip side,
        -- 				   it means that when this flag is not present,
        -- 				   then it\'s safe to break the glyph-run at the
        -- 				   beginning of this cluster, and the two sides
        -- 				   represent the exact same result one would get
        -- 				   if breaking input text at the beginning of
        -- 				   this cluster and shaping the two sides
        -- 				   separately.  This can be used to optimize
        -- 				   paragraph layout, by avoiding re-shaping
        -- 				   of each line after line-breaking, or limiting
        -- 				   the reshaping to a small piece around the
        -- 				   breaking point only.
        | GlyphFlagsTDefined
        -- ^ All the currently defined flags.
        | AnotherGlyphFlagsT Int
        -- ^ Catch-all for unknown values
        deriving (Int -> GlyphFlagsT -> ShowS
    [GlyphFlagsT] -> ShowS
    GlyphFlagsT -> String
    (Int -> GlyphFlagsT -> ShowS)
    -> (GlyphFlagsT -> String)
    -> ([GlyphFlagsT] -> ShowS)
    -> Show GlyphFlagsT
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [GlyphFlagsT] -> ShowS
    $cshowList :: [GlyphFlagsT] -> ShowS
    show :: GlyphFlagsT -> String
    $cshow :: GlyphFlagsT -> String
    showsPrec :: Int -> GlyphFlagsT -> ShowS
    $cshowsPrec :: Int -> GlyphFlagsT -> ShowS
    Show, GlyphFlagsT -> GlyphFlagsT -> Bool
    (GlyphFlagsT -> GlyphFlagsT -> Bool)
    -> (GlyphFlagsT -> GlyphFlagsT -> Bool) -> Eq GlyphFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: GlyphFlagsT -> GlyphFlagsT -> Bool
    $c/= :: GlyphFlagsT -> GlyphFlagsT -> Bool
    == :: GlyphFlagsT -> GlyphFlagsT -> Bool
    $c== :: GlyphFlagsT -> GlyphFlagsT -> Bool
    Eq)

    instance P.Enum GlyphFlagsT where
        fromEnum :: GlyphFlagsT -> Int
    fromEnum GlyphFlagsTUnsafeToBreak = 1
        fromEnum GlyphFlagsTDefined = 1
        fromEnum (AnotherGlyphFlagsT k :: Int
    k) = Int
    k

        toEnum :: Int -> GlyphFlagsT
    toEnum 1 = GlyphFlagsT
    GlyphFlagsTUnsafeToBreak
        toEnum k :: Int
    k = Int -> GlyphFlagsT
    AnotherGlyphFlagsT Int
    k

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

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

    foreign import ccall "hb_gobject_glyph_flags_get_type" c_hb_gobject_glyph_flags_get_type ::
        IO GType

    instance B.Types.TypedObject GlyphFlagsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_glyph_flags_get_type

    instance B.Types.BoxedFlags GlyphFlagsT

    instance IsGFlag GlyphFlagsT

    -- Flags buffer_serialize_flags_t
    -- | Flags that control what glyph information are serialized in 'GI.HarfBuzz.Functions.bufferSerializeGlyphs'.
    --
    -- /Since: 0.9.20/
    data BufferSerializeFlagsT =
          BufferSerializeFlagsTDefault
        -- ^ serialize glyph names, clusters and positions.
        | BufferSerializeFlagsTNoClusters
        -- ^ do not serialize glyph cluster.
        | BufferSerializeFlagsTNoPositions
        -- ^ do not serialize glyph position information.
        | BufferSerializeFlagsTNoGlyphNames
        -- ^ do no serialize glyph name.
        | BufferSerializeFlagsTGlyphExtents
        -- ^ serialize glyph extents.
        | BufferSerializeFlagsTGlyphFlags
        -- ^ serialize glyph flags. Since: 1.5.0
        | BufferSerializeFlagsTNoAdvances
        -- ^ do not serialize glyph advances,
        --  glyph offsets will reflect absolute glyph positions. Since: 1.8.0
        | AnotherBufferSerializeFlagsT Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BufferSerializeFlagsT -> ShowS
    [BufferSerializeFlagsT] -> ShowS
    BufferSerializeFlagsT -> String
    (Int -> BufferSerializeFlagsT -> ShowS)
    -> (BufferSerializeFlagsT -> String)
    -> ([BufferSerializeFlagsT] -> ShowS)
    -> Show BufferSerializeFlagsT
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [BufferSerializeFlagsT] -> ShowS
    $cshowList :: [BufferSerializeFlagsT] -> ShowS
    show :: BufferSerializeFlagsT -> String
    $cshow :: BufferSerializeFlagsT -> String
    showsPrec :: Int -> BufferSerializeFlagsT -> ShowS
    $cshowsPrec :: Int -> BufferSerializeFlagsT -> ShowS
    Show, BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    (BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
    -> (BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
    -> Eq BufferSerializeFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    $c/= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    == :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    $c== :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    Eq)

    instance P.Enum BufferSerializeFlagsT where
        fromEnum :: BufferSerializeFlagsT -> Int
    fromEnum BufferSerializeFlagsTDefault = 0
        fromEnum BufferSerializeFlagsTNoClusters = 1
        fromEnum BufferSerializeFlagsTNoPositions = 2
        fromEnum BufferSerializeFlagsTNoGlyphNames = 4
        fromEnum BufferSerializeFlagsTGlyphExtents = 8
        fromEnum BufferSerializeFlagsTGlyphFlags = 16
        fromEnum BufferSerializeFlagsTNoAdvances = 32
        fromEnum (AnotherBufferSerializeFlagsT k :: Int
    k) = Int
    k

        toEnum :: Int -> BufferSerializeFlagsT
    toEnum 0 = BufferSerializeFlagsT
    BufferSerializeFlagsTDefault
        toEnum 1 = BufferSerializeFlagsT
    BufferSerializeFlagsTNoClusters
        toEnum 2 = BufferSerializeFlagsT
    BufferSerializeFlagsTNoPositions
        toEnum 4 = BufferSerializeFlagsT
    BufferSerializeFlagsTNoGlyphNames
        toEnum 8 = BufferSerializeFlagsT
    BufferSerializeFlagsTGlyphExtents
        toEnum 16 = BufferSerializeFlagsT
    BufferSerializeFlagsTGlyphFlags
        toEnum 32 = BufferSerializeFlagsT
    BufferSerializeFlagsTNoAdvances
        toEnum k :: Int
    k = Int -> BufferSerializeFlagsT
    AnotherBufferSerializeFlagsT Int
    k

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

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

    foreign import ccall "hb_gobject_buffer_serialize_flags_get_type" c_hb_gobject_buffer_serialize_flags_get_type ::
        IO GType

    instance B.Types.TypedObject BufferSerializeFlagsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_buffer_serialize_flags_get_type

    instance B.Types.BoxedFlags BufferSerializeFlagsT

    instance IsGFlag BufferSerializeFlagsT

    -- Flags buffer_flags_t
    -- | /No description available in the introspection data./
    --
    -- /Since: 0.9.20/
    data BufferFlagsT =
          BufferFlagsTDefault
        -- ^ the default buffer flag.
        | BufferFlagsTBot
        -- ^ flag indicating that special handling of the beginning
        --                      of text paragraph can be applied to this buffer. Should usually
        --                      be set, unless you are passing to the buffer only part
        --                      of the text without the full context.
        | BufferFlagsTEot
        -- ^ flag indicating that special handling of the end of text
        --                      paragraph can be applied to this buffer, similar to
        --                      /@hBBUFFERFLAGBOT@/.
        | BufferFlagsTPreserveDefaultIgnorables
        -- ^ flag indication that character with Default_Ignorable
        --                      Unicode property should use the corresponding glyph
        --                      from the font, instead of hiding them (done by
        --                      replacing them with the space glyph and zeroing the
        --                      advance width.)  This flag takes precedence over
        --                      /@hBBUFFERFLAGREMOVEDEFAULTIGNORABLES@/.
        | BufferFlagsTRemoveDefaultIgnorables
        -- ^ flag indication that character with Default_Ignorable
        --                      Unicode property should be removed from glyph string
        --                      instead of hiding them (done by replacing them with the
        --                      space glyph and zeroing the advance width.)
        --                      /@hBBUFFERFLAGPRESERVEDEFAULTIGNORABLES@/ takes
        --                      precedence over this flag. Since: 1.8.0
        | BufferFlagsTDoNotInsertDottedCircle
        -- ^ flag indicating that a dotted circle should
        --                      not be inserted in the rendering of incorrect
        --                      character sequences (such at \<0905 093E>). Since: 2.4
        | AnotherBufferFlagsT Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BufferFlagsT -> ShowS
    [BufferFlagsT] -> ShowS
    BufferFlagsT -> String
    (Int -> BufferFlagsT -> ShowS)
    -> (BufferFlagsT -> String)
    -> ([BufferFlagsT] -> ShowS)
    -> Show BufferFlagsT
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [BufferFlagsT] -> ShowS
    $cshowList :: [BufferFlagsT] -> ShowS
    show :: BufferFlagsT -> String
    $cshow :: BufferFlagsT -> String
    showsPrec :: Int -> BufferFlagsT -> ShowS
    $cshowsPrec :: Int -> BufferFlagsT -> ShowS
    Show, BufferFlagsT -> BufferFlagsT -> Bool
    (BufferFlagsT -> BufferFlagsT -> Bool)
    -> (BufferFlagsT -> BufferFlagsT -> Bool) -> Eq BufferFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: BufferFlagsT -> BufferFlagsT -> Bool
    $c/= :: BufferFlagsT -> BufferFlagsT -> Bool
    == :: BufferFlagsT -> BufferFlagsT -> Bool
    $c== :: BufferFlagsT -> BufferFlagsT -> Bool
    Eq)

    instance P.Enum BufferFlagsT where
        fromEnum :: BufferFlagsT -> Int
    fromEnum BufferFlagsTDefault = 0
        fromEnum BufferFlagsTBot = 1
        fromEnum BufferFlagsTEot = 2
        fromEnum BufferFlagsTPreserveDefaultIgnorables = 4
        fromEnum BufferFlagsTRemoveDefaultIgnorables = 8
        fromEnum BufferFlagsTDoNotInsertDottedCircle = 16
        fromEnum (AnotherBufferFlagsT k :: Int
    k) = Int
    k

        toEnum :: Int -> BufferFlagsT
    toEnum 0 = BufferFlagsT
    BufferFlagsTDefault
        toEnum 1 = BufferFlagsT
    BufferFlagsTBot
        toEnum 2 = BufferFlagsT
    BufferFlagsTEot
        toEnum 4 = BufferFlagsT
    BufferFlagsTPreserveDefaultIgnorables
        toEnum 8 = BufferFlagsT
    BufferFlagsTRemoveDefaultIgnorables
        toEnum 16 = BufferFlagsT
    BufferFlagsTDoNotInsertDottedCircle
        toEnum k :: Int
    k = Int -> BufferFlagsT
    AnotherBufferFlagsT Int
    k

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

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

    foreign import ccall "hb_gobject_buffer_flags_get_type" c_hb_gobject_buffer_flags_get_type ::
        IO GType

    instance B.Types.TypedObject BufferFlagsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_buffer_flags_get_type

    instance B.Types.BoxedFlags BufferFlagsT

    instance IsGFlag BufferFlagsT

    -- Flags buffer_diff_flags_t
    -- | /No description available in the introspection data./
    data BufferDiffFlagsT =
          BufferDiffFlagsTEqual
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTContentTypeMismatch
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTLengthMismatch
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTNotdefPresent
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTDottedCirclePresent
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTCodepointMismatch
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTClusterMismatch
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTGlyphFlagsMismatch
        -- ^ /No description available in the introspection data./
        | BufferDiffFlagsTPositionMismatch
        -- ^ /No description available in the introspection data./
        | AnotherBufferDiffFlagsT Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BufferDiffFlagsT -> ShowS
    [BufferDiffFlagsT] -> ShowS
    BufferDiffFlagsT -> String
    (Int -> BufferDiffFlagsT -> ShowS)
    -> (BufferDiffFlagsT -> String)
    -> ([BufferDiffFlagsT] -> ShowS)
    -> Show BufferDiffFlagsT
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [BufferDiffFlagsT] -> ShowS
    $cshowList :: [BufferDiffFlagsT] -> ShowS
    show :: BufferDiffFlagsT -> String
    $cshow :: BufferDiffFlagsT -> String
    showsPrec :: Int -> BufferDiffFlagsT -> ShowS
    $cshowsPrec :: Int -> BufferDiffFlagsT -> ShowS
    Show, BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    (BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
    -> (BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
    -> Eq BufferDiffFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    $c/= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    == :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    $c== :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    Eq)

    instance P.Enum BufferDiffFlagsT where
        fromEnum :: BufferDiffFlagsT -> Int
    fromEnum BufferDiffFlagsTEqual = 0
        fromEnum BufferDiffFlagsTContentTypeMismatch = 1
        fromEnum BufferDiffFlagsTLengthMismatch = 2
        fromEnum BufferDiffFlagsTNotdefPresent = 4
        fromEnum BufferDiffFlagsTDottedCirclePresent = 8
        fromEnum BufferDiffFlagsTCodepointMismatch = 16
        fromEnum BufferDiffFlagsTClusterMismatch = 32
        fromEnum BufferDiffFlagsTGlyphFlagsMismatch = 64
        fromEnum BufferDiffFlagsTPositionMismatch = 128
        fromEnum (AnotherBufferDiffFlagsT k :: Int
    k) = Int
    k

        toEnum :: Int -> BufferDiffFlagsT
    toEnum 0 = BufferDiffFlagsT
    BufferDiffFlagsTEqual
        toEnum 1 = BufferDiffFlagsT
    BufferDiffFlagsTContentTypeMismatch
        toEnum 2 = BufferDiffFlagsT
    BufferDiffFlagsTLengthMismatch
        toEnum 4 = BufferDiffFlagsT
    BufferDiffFlagsTNotdefPresent
        toEnum 8 = BufferDiffFlagsT
    BufferDiffFlagsTDottedCirclePresent
        toEnum 16 = BufferDiffFlagsT
    BufferDiffFlagsTCodepointMismatch
        toEnum 32 = BufferDiffFlagsT
    BufferDiffFlagsTClusterMismatch
        toEnum 64 = BufferDiffFlagsT
    BufferDiffFlagsTGlyphFlagsMismatch
        toEnum 128 = BufferDiffFlagsT
    BufferDiffFlagsTPositionMismatch
        toEnum k :: Int
    k = Int -> BufferDiffFlagsT
    AnotherBufferDiffFlagsT Int
    k

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

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

    foreign import ccall "hb_gobject_buffer_diff_flags_get_type" c_hb_gobject_buffer_diff_flags_get_type ::
        IO GType

    instance B.Types.TypedObject BufferDiffFlagsT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_buffer_diff_flags_get_type

    instance B.Types.BoxedFlags BufferDiffFlagsT

    instance IsGFlag BufferDiffFlagsT