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

    -- Flags ot_var_axis_flags_t
    -- | Flags for t'GI.HarfBuzz.Structs.OtVarAxisInfoT.OtVarAxisInfoT'.
    --
    -- /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
    $cshowsPrec :: Int -> OtVarAxisFlagsT -> ShowS
    showsPrec :: Int -> OtVarAxisFlagsT -> ShowS
    $cshow :: OtVarAxisFlagsT -> String
    show :: OtVarAxisFlagsT -> String
    $cshowList :: [OtVarAxisFlagsT] -> ShowS
    showList :: [OtVarAxisFlagsT] -> ShowS
    Show, OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    (OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
    -> (OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool)
    -> Eq OtVarAxisFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    == :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    $c/= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    /= :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Bool
    Eq)

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

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

    instance P.Ord OtVarAxisFlagsT where
        compare :: OtVarAxisFlagsT -> OtVarAxisFlagsT -> Ordering
    compare OtVarAxisFlagsT
    a 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
        -- ^ This is an extender glyph part that
        -- can be repeated to reach the desired length.
        | 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
    $cshowsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
    showsPrec :: Int -> OtMathGlyphPartFlagsT -> ShowS
    $cshow :: OtMathGlyphPartFlagsT -> String
    show :: OtMathGlyphPartFlagsT -> String
    $cshowList :: [OtMathGlyphPartFlagsT] -> ShowS
    showList :: [OtMathGlyphPartFlagsT] -> ShowS
    Show, OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    (OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
    -> (OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool)
    -> Eq OtMathGlyphPartFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    == :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    $c/= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    /= :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Bool
    Eq)

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

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

    instance P.Ord OtMathGlyphPartFlagsT where
        compare :: OtMathGlyphPartFlagsT -> OtMathGlyphPartFlagsT -> Ordering
    compare OtMathGlyphPartFlagsT
    a 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
    -- | Flags that describe the properties of color palette.
    --
    -- /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
    $cshowsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
    showsPrec :: Int -> OtColorPaletteFlagsT -> ShowS
    $cshow :: OtColorPaletteFlagsT -> String
    show :: OtColorPaletteFlagsT -> String
    $cshowList :: [OtColorPaletteFlagsT] -> ShowS
    showList :: [OtColorPaletteFlagsT] -> ShowS
    Show, OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    (OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
    -> (OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool)
    -> Eq OtColorPaletteFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    == :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    $c/= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    /= :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Bool
    Eq)

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

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

    instance P.Ord OtColorPaletteFlagsT where
        compare :: OtColorPaletteFlagsT -> OtColorPaletteFlagsT -> Ordering
    compare OtColorPaletteFlagsT
    a 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
    -- | Flags for t'GI.HarfBuzz.Structs.GlyphInfoT.GlyphInfoT'.
    --
    -- /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 is safe to break
        -- 				   the glyph-run at the beginning of this
        -- 				   cluster, and the two sides will 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.
        | GlyphFlagsTUnsafeToConcat
        -- ^ Indicates that if input text is changed on one
        -- 				   side of the beginning of the cluster this glyph
        -- 				   is part of, then the shaping results for the
        -- 				   other side might change.
        -- 				   Note that the absence of this flag will NOT by
        -- 				   itself mean that it IS safe to concat text.
        -- 				   Only two pieces of text both of which clear of
        -- 				   this flag can be concatenated safely.
        -- 				   This can be used to optimize paragraph
        -- 				   layout, by avoiding re-shaping of each line
        -- 				   after line-breaking, by limiting the
        -- 				   reshaping to a small piece around the
        -- 				   breaking position only, even if the breaking
        -- 				   position carries the
        -- 				   @/HB_GLYPH_FLAG_UNSAFE_TO_BREAK/@ or when
        -- 				   hyphenation or other text transformation
        -- 				   happens at line-break position, in the following
        -- 				   way:
        -- 				   1. Iterate back from the line-break position
        -- 				   until the first cluster start position that is
        -- 				   NOT unsafe-to-concat, 2. shape the segment from
        -- 				   there till the end of line, 3. check whether the
        -- 				   resulting glyph-run also is clear of the
        -- 				   unsafe-to-concat at its start-of-text position;
        -- 				   if it is, just splice it into place and the line
        -- 				   is shaped; If not, move on to a position further
        -- 				   back that is clear of unsafe-to-concat and retry
        -- 				   from there, and repeat.
        -- 				   At the start of next line a similar algorithm can
        -- 				   be implemented. That is: 1. Iterate forward from
        -- 				   the line-break position until the first cluster
        -- 				   start position that is NOT unsafe-to-concat, 2.
        -- 				   shape the segment from beginning of the line to
        -- 				   that position, 3. check whether the resulting
        -- 				   glyph-run also is clear of the unsafe-to-concat
        -- 				   at its end-of-text position; if it is, just splice
        -- 				   it into place and the beginning is shaped; If not,
        -- 				   move on to a position further forward that is clear
        -- 				   of unsafe-to-concat and retry up to there, and repeat.
        -- 				   A slight complication will arise in the
        -- 				   implementation of the algorithm above,
        -- 				   because while our buffer API has a way to
        -- 				   return flags for position corresponding to
        -- 				   start-of-text, there is currently no position
        -- 				   corresponding to end-of-text.  This limitation
        -- 				   can be alleviated by shaping more text than needed
        -- 				   and looking for unsafe-to-concat flag within text
        -- 				   clusters.
        -- 				   The @/HB_GLYPH_FLAG_UNSAFE_TO_BREAK/@ flag will
        -- 				   always imply this flag.
        -- 			   To use this flag, you must enable the buffer flag
        -- 			   /@hBBUFFERFLAGPRODUCEUNSAFETOCONCAT@/ during
        -- 			   shaping, otherwise the buffer flag will not be
        -- 			   reliably produced.
        -- 				   Since: 4.0.0
        | GlyphFlagsTSafeToInsertTatweel
        -- ^ In scripts that use elongation (Arabic,
        -- 				   Mongolian, Syriac, etc.), this flag signifies
        -- 				   that it is safe to insert a U+0640 TATWEEL
        -- 				   character before this cluster for elongation.
        -- 				   This flag does not determine the
        -- 				   script-specific elongation places, but only
        -- 				   when it is safe to do the elongation without
        -- 				   interrupting text shaping.
        -- 				   Since: 5.1.0
        | 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
    $cshowsPrec :: Int -> GlyphFlagsT -> ShowS
    showsPrec :: Int -> GlyphFlagsT -> ShowS
    $cshow :: GlyphFlagsT -> String
    show :: GlyphFlagsT -> String
    $cshowList :: [GlyphFlagsT] -> ShowS
    showList :: [GlyphFlagsT] -> ShowS
    Show, GlyphFlagsT -> GlyphFlagsT -> Bool
    (GlyphFlagsT -> GlyphFlagsT -> Bool)
    -> (GlyphFlagsT -> GlyphFlagsT -> Bool) -> Eq GlyphFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GlyphFlagsT -> GlyphFlagsT -> Bool
    == :: GlyphFlagsT -> GlyphFlagsT -> Bool
    $c/= :: GlyphFlagsT -> GlyphFlagsT -> Bool
    /= :: GlyphFlagsT -> GlyphFlagsT -> Bool
    Eq)

    instance P.Enum GlyphFlagsT where
        fromEnum :: GlyphFlagsT -> Int
    fromEnum GlyphFlagsT
    GlyphFlagsTUnsafeToBreak = Int
    1
        fromEnum GlyphFlagsT
    GlyphFlagsTUnsafeToConcat = Int
    2
        fromEnum GlyphFlagsT
    GlyphFlagsTSafeToInsertTatweel = Int
    4
        fromEnum GlyphFlagsT
    GlyphFlagsTDefined = Int
    7
        fromEnum (AnotherGlyphFlagsT Int
    k) = Int
    k

        toEnum :: Int -> GlyphFlagsT
    toEnum Int
    1 = GlyphFlagsT
    GlyphFlagsTUnsafeToBreak
        toEnum Int
    2 = GlyphFlagsT
    GlyphFlagsTUnsafeToConcat
        toEnum Int
    4 = GlyphFlagsT
    GlyphFlagsTSafeToInsertTatweel
        toEnum Int
    7 = GlyphFlagsT
    GlyphFlagsTDefined
        toEnum Int
    k = Int -> GlyphFlagsT
    AnotherGlyphFlagsT Int
    k

    instance P.Ord GlyphFlagsT where
        compare :: GlyphFlagsT -> GlyphFlagsT -> Ordering
    compare GlyphFlagsT
    a 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
        | BufferSerializeFlagsTDefined
        -- ^ All currently defined flags. Since: 4.4.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
    $cshowsPrec :: Int -> BufferSerializeFlagsT -> ShowS
    showsPrec :: Int -> BufferSerializeFlagsT -> ShowS
    $cshow :: BufferSerializeFlagsT -> String
    show :: BufferSerializeFlagsT -> String
    $cshowList :: [BufferSerializeFlagsT] -> ShowS
    showList :: [BufferSerializeFlagsT] -> ShowS
    Show, BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    (BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
    -> (BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool)
    -> Eq BufferSerializeFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    == :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    $c/= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    /= :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Bool
    Eq)

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

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

    instance P.Ord BufferSerializeFlagsT where
        compare :: BufferSerializeFlagsT -> BufferSerializeFlagsT -> Ordering
    compare BufferSerializeFlagsT
    a 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
    -- | Flags for t'GI.HarfBuzz.Structs.BufferT.BufferT'.
    --
    -- /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.0
        | BufferFlagsTVerify
        -- ^ flag indicating that the 'GI.HarfBuzz.Functions.shape' call and its variants
        --                      should perform various verification processes on the results
        --                      of the shaping operation on the buffer.  If the verification
        --                      fails, then either a buffer message is sent, if a message
        --                      handler is installed on the buffer, or a message is written
        --                      to standard error.  In either case, the shaping result might
        --                      be modified to show the failed output. Since: 3.4.0
        | BufferFlagsTProduceUnsafeToConcat
        -- ^ flag indicating that the /@hBGLYPHFLAGUNSAFETOCONCAT@/
        --                      glyph-flag should be produced by the shaper. By default
        --                      it will not be produced since it incurs a cost. Since: 4.0.0
        | BufferFlagsTProduceSafeToInsertTatweel
        -- ^ flag indicating that the /@hBGLYPHFLAGSAFETOINSERTTATWEEL@/
        --                      glyph-flag should be produced by the shaper. By default
        --                      it will not be produced. Since: 5.1.0
        | BufferFlagsTDefined
        -- ^ All currently defined flags: Since: 4.4.0
        | 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
    $cshowsPrec :: Int -> BufferFlagsT -> ShowS
    showsPrec :: Int -> BufferFlagsT -> ShowS
    $cshow :: BufferFlagsT -> String
    show :: BufferFlagsT -> String
    $cshowList :: [BufferFlagsT] -> ShowS
    showList :: [BufferFlagsT] -> ShowS
    Show, BufferFlagsT -> BufferFlagsT -> Bool
    (BufferFlagsT -> BufferFlagsT -> Bool)
    -> (BufferFlagsT -> BufferFlagsT -> Bool) -> Eq BufferFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BufferFlagsT -> BufferFlagsT -> Bool
    == :: BufferFlagsT -> BufferFlagsT -> Bool
    $c/= :: BufferFlagsT -> BufferFlagsT -> Bool
    /= :: BufferFlagsT -> BufferFlagsT -> Bool
    Eq)

    instance P.Enum BufferFlagsT where
        fromEnum :: BufferFlagsT -> Int
    fromEnum BufferFlagsT
    BufferFlagsTDefault = Int
    0
        fromEnum BufferFlagsT
    BufferFlagsTBot = Int
    1
        fromEnum BufferFlagsT
    BufferFlagsTEot = Int
    2
        fromEnum BufferFlagsT
    BufferFlagsTPreserveDefaultIgnorables = Int
    4
        fromEnum BufferFlagsT
    BufferFlagsTRemoveDefaultIgnorables = Int
    8
        fromEnum BufferFlagsT
    BufferFlagsTDoNotInsertDottedCircle = Int
    16
        fromEnum BufferFlagsT
    BufferFlagsTVerify = Int
    32
        fromEnum BufferFlagsT
    BufferFlagsTProduceUnsafeToConcat = Int
    64
        fromEnum BufferFlagsT
    BufferFlagsTProduceSafeToInsertTatweel = Int
    128
        fromEnum BufferFlagsT
    BufferFlagsTDefined = Int
    255
        fromEnum (AnotherBufferFlagsT Int
    k) = Int
    k

        toEnum :: Int -> BufferFlagsT
    toEnum Int
    0 = BufferFlagsT
    BufferFlagsTDefault
        toEnum Int
    1 = BufferFlagsT
    BufferFlagsTBot
        toEnum Int
    2 = BufferFlagsT
    BufferFlagsTEot
        toEnum Int
    4 = BufferFlagsT
    BufferFlagsTPreserveDefaultIgnorables
        toEnum Int
    8 = BufferFlagsT
    BufferFlagsTRemoveDefaultIgnorables
        toEnum Int
    16 = BufferFlagsT
    BufferFlagsTDoNotInsertDottedCircle
        toEnum Int
    32 = BufferFlagsT
    BufferFlagsTVerify
        toEnum Int
    64 = BufferFlagsT
    BufferFlagsTProduceUnsafeToConcat
        toEnum Int
    128 = BufferFlagsT
    BufferFlagsTProduceSafeToInsertTatweel
        toEnum Int
    255 = BufferFlagsT
    BufferFlagsTDefined
        toEnum Int
    k = Int -> BufferFlagsT
    AnotherBufferFlagsT Int
    k

    instance P.Ord BufferFlagsT where
        compare :: BufferFlagsT -> BufferFlagsT -> Ordering
    compare BufferFlagsT
    a 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
    -- | Flags from comparing two t'GI.HarfBuzz.Structs.BufferT.BufferT'\'s.
    --
    -- Buffer with different t'GI.HarfBuzz.Enums.BufferContentTypeT' cannot be meaningfully
    -- compared in any further detail.
    --
    -- For buffers with differing length, the per-glyph comparison is not
    -- attempted, though we do still scan reference buffer for dotted circle and
    -- @.notdef@ glyphs.
    --
    -- If the buffers have the same length, we compare them glyph-by-glyph and
    -- report which aspect(s) of the glyph info\/position are different.
    --
    -- /Since: 1.5.0/
    data BufferDiffFlagsT =
          BufferDiffFlagsTEqual
        -- ^ equal buffers.
        | BufferDiffFlagsTContentTypeMismatch
        -- ^ buffers with different
        --     t'GI.HarfBuzz.Enums.BufferContentTypeT'.
        | BufferDiffFlagsTLengthMismatch
        -- ^ buffers with differing length.
        | BufferDiffFlagsTNotdefPresent
        -- ^ @.notdef@ glyph is present in the
        --     reference buffer.
        | BufferDiffFlagsTDottedCirclePresent
        -- ^ dotted circle glyph is present
        --     in the reference buffer.
        | BufferDiffFlagsTCodepointMismatch
        -- ^ difference in t'GI.HarfBuzz.Structs.GlyphInfoT.GlyphInfoT'.@/codepoint/@
        | BufferDiffFlagsTClusterMismatch
        -- ^ difference in t'GI.HarfBuzz.Structs.GlyphInfoT.GlyphInfoT'.@/cluster/@
        | BufferDiffFlagsTGlyphFlagsMismatch
        -- ^ difference in t'GI.HarfBuzz.Flags.GlyphFlagsT'.
        | BufferDiffFlagsTPositionMismatch
        -- ^ difference in t'GI.HarfBuzz.Structs.GlyphPositionT.GlyphPositionT'.
        | 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
    $cshowsPrec :: Int -> BufferDiffFlagsT -> ShowS
    showsPrec :: Int -> BufferDiffFlagsT -> ShowS
    $cshow :: BufferDiffFlagsT -> String
    show :: BufferDiffFlagsT -> String
    $cshowList :: [BufferDiffFlagsT] -> ShowS
    showList :: [BufferDiffFlagsT] -> ShowS
    Show, BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    (BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
    -> (BufferDiffFlagsT -> BufferDiffFlagsT -> Bool)
    -> Eq BufferDiffFlagsT
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    == :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    $c/= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    /= :: BufferDiffFlagsT -> BufferDiffFlagsT -> Bool
    Eq)

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

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

    instance P.Ord BufferDiffFlagsT where
        compare :: BufferDiffFlagsT -> BufferDiffFlagsT -> Ordering
    compare BufferDiffFlagsT
    a 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