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

     -- * Enumerations

    -- ** Alignment #enum:Alignment#

        Alignment(..)                           ,

    -- ** AttrType #enum:AttrType#

        AttrType(..)                            ,

    -- ** BaselineShift #enum:BaselineShift#

        BaselineShift(..)                       ,

    -- ** BidiType #enum:BidiType#

        BidiType(..)                            ,

    -- ** CoverageLevel #enum:CoverageLevel#

        CoverageLevel(..)                       ,

    -- ** Direction #enum:Direction#

        Direction(..)                           ,

    -- ** EllipsizeMode #enum:EllipsizeMode#

        EllipsizeMode(..)                       ,

    -- ** FontScale #enum:FontScale#

        FontScale(..)                           ,

    -- ** Gravity #enum:Gravity#

        Gravity(..)                             ,

    -- ** GravityHint #enum:GravityHint#

        GravityHint(..)                         ,

    -- ** LayoutDeserializeError #enum:LayoutDeserializeError#

        LayoutDeserializeError(..)              ,
        catchLayoutDeserializeError             ,
        handleLayoutDeserializeError            ,

    -- ** Overline #enum:Overline#

        Overline(..)                            ,

    -- ** RenderPart #enum:RenderPart#

        RenderPart(..)                          ,

    -- ** Script #enum:Script#

        Script(..)                              ,

    -- ** Stretch #enum:Stretch#

        Stretch(..)                             ,

    -- ** Style #enum:Style#

        Style(..)                               ,

    -- ** TabAlign #enum:TabAlign#

        TabAlign(..)                            ,

    -- ** TextTransform #enum:TextTransform#

        TextTransform(..)                       ,

    -- ** Underline #enum:Underline#

        Underline(..)                           ,

    -- ** Variant #enum:Variant#

        Variant(..)                             ,

    -- ** Weight #enum:Weight#

        Weight(..)                              ,

    -- ** WrapMode #enum:WrapMode#

        WrapMode(..)                            ,

        ) 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

    -- Enum WrapMode
    -- | @PangoWrapMode@ describes how to wrap the lines of a @PangoLayout@
    -- to the desired width.
    --
    -- For /@pANGOWRAPWORD@/, Pango uses break opportunities that are determined
    -- by the Unicode line breaking algorithm. For /@pANGOWRAPCHAR@/, Pango allows
    -- breaking at grapheme boundaries that are determined by the Unicode text
    -- segmentation algorithm.
    data WrapMode =
          WrapModeWord
        -- ^ wrap lines at word boundaries.
        | WrapModeChar
        -- ^ wrap lines at character boundaries.
        | WrapModeWordChar
        -- ^ wrap lines at word boundaries, but fall back to
        --   character boundaries if there is not enough space for a full word.
        | AnotherWrapMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> WrapMode -> ShowS
    [WrapMode] -> ShowS
    WrapMode -> String
    (Int -> WrapMode -> ShowS)
    -> (WrapMode -> String) -> ([WrapMode] -> ShowS) -> Show WrapMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WrapMode -> ShowS
    showsPrec :: Int -> WrapMode -> ShowS
    $cshow :: WrapMode -> String
    show :: WrapMode -> String
    $cshowList :: [WrapMode] -> ShowS
    showList :: [WrapMode] -> ShowS
    Show, WrapMode -> WrapMode -> Bool
    (WrapMode -> WrapMode -> Bool)
    -> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WrapMode -> WrapMode -> Bool
    == :: WrapMode -> WrapMode -> Bool
    $c/= :: WrapMode -> WrapMode -> Bool
    /= :: WrapMode -> WrapMode -> Bool
    Eq)

    instance P.Enum WrapMode where
        fromEnum :: WrapMode -> Int
    fromEnum WrapMode
    WrapModeWord = Int
    0
        fromEnum WrapMode
    WrapModeChar = Int
    1
        fromEnum WrapMode
    WrapModeWordChar = Int
    2
        fromEnum (AnotherWrapMode Int
    k) = Int
    k

        toEnum :: Int -> WrapMode
    toEnum Int
    0 = WrapMode
    WrapModeWord
        toEnum Int
    1 = WrapMode
    WrapModeChar
        toEnum Int
    2 = WrapMode
    WrapModeWordChar
        toEnum Int
    k = Int -> WrapMode
    AnotherWrapMode Int
    k

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

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

    foreign import ccall "pango_wrap_mode_get_type" c_pango_wrap_mode_get_type ::
        IO GType

    instance B.Types.TypedObject WrapMode where
        glibType :: IO GType
    glibType = IO GType
    c_pango_wrap_mode_get_type

    instance B.Types.BoxedEnum WrapMode

    -- Enum Weight
    -- | An enumeration specifying the weight (boldness) of a font.
    --
    -- Weight is specified as a numeric value ranging from 100 to 1000.
    -- This enumeration simply provides some common, predefined values.
    data Weight =
          WeightThin
        -- ^ the thin weight (= 100) Since: 1.24
        | WeightUltralight
        -- ^ the ultralight weight (= 200)
        | WeightLight
        -- ^ the light weight (= 300)
        | WeightSemilight
        -- ^ the semilight weight (= 350) Since: 1.36.7
        | WeightBook
        -- ^ the book weight (= 380) Since: 1.24)
        | WeightNormal
        -- ^ the default weight (= 400)
        | WeightMedium
        -- ^ the medium weight (= 500) Since: 1.24
        | WeightSemibold
        -- ^ the semibold weight (= 600)
        | WeightBold
        -- ^ the bold weight (= 700)
        | WeightUltrabold
        -- ^ the ultrabold weight (= 800)
        | WeightHeavy
        -- ^ the heavy weight (= 900)
        | WeightUltraheavy
        -- ^ the ultraheavy weight (= 1000) Since: 1.24
        | AnotherWeight Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Weight -> ShowS
    [Weight] -> ShowS
    Weight -> String
    (Int -> Weight -> ShowS)
    -> (Weight -> String) -> ([Weight] -> ShowS) -> Show Weight
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Weight -> ShowS
    showsPrec :: Int -> Weight -> ShowS
    $cshow :: Weight -> String
    show :: Weight -> String
    $cshowList :: [Weight] -> ShowS
    showList :: [Weight] -> ShowS
    Show, Weight -> Weight -> Bool
    (Weight -> Weight -> Bool)
    -> (Weight -> Weight -> Bool) -> Eq Weight
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Weight -> Weight -> Bool
    == :: Weight -> Weight -> Bool
    $c/= :: Weight -> Weight -> Bool
    /= :: Weight -> Weight -> Bool
    Eq)

    instance P.Enum Weight where
        fromEnum :: Weight -> Int
    fromEnum Weight
    WeightThin = Int
    100
        fromEnum Weight
    WeightUltralight = Int
    200
        fromEnum Weight
    WeightLight = Int
    300
        fromEnum Weight
    WeightSemilight = Int
    350
        fromEnum Weight
    WeightBook = Int
    380
        fromEnum Weight
    WeightNormal = Int
    400
        fromEnum Weight
    WeightMedium = Int
    500
        fromEnum Weight
    WeightSemibold = Int
    600
        fromEnum Weight
    WeightBold = Int
    700
        fromEnum Weight
    WeightUltrabold = Int
    800
        fromEnum Weight
    WeightHeavy = Int
    900
        fromEnum Weight
    WeightUltraheavy = Int
    1000
        fromEnum (AnotherWeight Int
    k) = Int
    k

        toEnum :: Int -> Weight
    toEnum Int
    100 = Weight
    WeightThin
        toEnum Int
    200 = Weight
    WeightUltralight
        toEnum Int
    300 = Weight
    WeightLight
        toEnum Int
    350 = Weight
    WeightSemilight
        toEnum Int
    380 = Weight
    WeightBook
        toEnum Int
    400 = Weight
    WeightNormal
        toEnum Int
    500 = Weight
    WeightMedium
        toEnum Int
    600 = Weight
    WeightSemibold
        toEnum Int
    700 = Weight
    WeightBold
        toEnum Int
    800 = Weight
    WeightUltrabold
        toEnum Int
    900 = Weight
    WeightHeavy
        toEnum Int
    1000 = Weight
    WeightUltraheavy
        toEnum Int
    k = Int -> Weight
    AnotherWeight Int
    k

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

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

    foreign import ccall "pango_weight_get_type" c_pango_weight_get_type ::
        IO GType

    instance B.Types.TypedObject Weight where
        glibType :: IO GType
    glibType = IO GType
    c_pango_weight_get_type

    instance B.Types.BoxedEnum Weight

    -- Enum Variant
    -- | An enumeration specifying capitalization variant of the font.
    data Variant =
          VariantNormal
        -- ^ A normal font.
        | VariantSmallCaps
        -- ^ A font with the lower case characters
        --   replaced by smaller variants of the capital characters.
        | VariantAllSmallCaps
        -- ^ A font with all characters
        --   replaced by smaller variants of the capital characters. Since: 1.50
        | VariantPetiteCaps
        -- ^ A font with the lower case characters
        --   replaced by smaller variants of the capital characters.
        --   Petite Caps can be even smaller than Small Caps. Since: 1.50
        | VariantAllPetiteCaps
        -- ^ A font with all characters
        --   replaced by smaller variants of the capital characters.
        --   Petite Caps can be even smaller than Small Caps. Since: 1.50
        | VariantUnicase
        -- ^ A font with the upper case characters
        --   replaced by smaller variants of the capital letters. Since: 1.50
        | VariantTitleCaps
        -- ^ A font with capital letters that
        --   are more suitable for all-uppercase titles. Since: 1.50
        | AnotherVariant Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Variant -> ShowS
    [Variant] -> ShowS
    Variant -> String
    (Int -> Variant -> ShowS)
    -> (Variant -> String) -> ([Variant] -> ShowS) -> Show Variant
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Variant -> ShowS
    showsPrec :: Int -> Variant -> ShowS
    $cshow :: Variant -> String
    show :: Variant -> String
    $cshowList :: [Variant] -> ShowS
    showList :: [Variant] -> ShowS
    Show, Variant -> Variant -> Bool
    (Variant -> Variant -> Bool)
    -> (Variant -> Variant -> Bool) -> Eq Variant
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Variant -> Variant -> Bool
    == :: Variant -> Variant -> Bool
    $c/= :: Variant -> Variant -> Bool
    /= :: Variant -> Variant -> Bool
    Eq)

    instance P.Enum Variant where
        fromEnum :: Variant -> Int
    fromEnum Variant
    VariantNormal = Int
    0
        fromEnum Variant
    VariantSmallCaps = Int
    1
        fromEnum Variant
    VariantAllSmallCaps = Int
    2
        fromEnum Variant
    VariantPetiteCaps = Int
    3
        fromEnum Variant
    VariantAllPetiteCaps = Int
    4
        fromEnum Variant
    VariantUnicase = Int
    5
        fromEnum Variant
    VariantTitleCaps = Int
    6
        fromEnum (AnotherVariant Int
    k) = Int
    k

        toEnum :: Int -> Variant
    toEnum Int
    0 = Variant
    VariantNormal
        toEnum Int
    1 = Variant
    VariantSmallCaps
        toEnum Int
    2 = Variant
    VariantAllSmallCaps
        toEnum Int
    3 = Variant
    VariantPetiteCaps
        toEnum Int
    4 = Variant
    VariantAllPetiteCaps
        toEnum Int
    5 = Variant
    VariantUnicase
        toEnum Int
    6 = Variant
    VariantTitleCaps
        toEnum Int
    k = Int -> Variant
    AnotherVariant Int
    k

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

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

    foreign import ccall "pango_variant_get_type" c_pango_variant_get_type ::
        IO GType

    instance B.Types.TypedObject Variant where
        glibType :: IO GType
    glibType = IO GType
    c_pango_variant_get_type

    instance B.Types.BoxedEnum Variant

    -- Enum Underline
    -- | The @PangoUnderline@ enumeration is used to specify whether text
    -- should be underlined, and if so, the type of underlining.
    data Underline =
          UnderlineNone
        -- ^ no underline should be drawn
        | UnderlineSingle
        -- ^ a single underline should be drawn
        | UnderlineDouble
        -- ^ a double underline should be drawn
        | UnderlineLow
        -- ^ a single underline should be drawn at a
        --   position beneath the ink extents of the text being
        --   underlined. This should be used only for underlining
        --   single characters, such as for keyboard accelerators.
        --   'GI.Pango.Enums.UnderlineSingle' should be used for extended
        --   portions of text.
        | UnderlineError
        -- ^ an underline indicating an error should
        --   be drawn below. The exact style of rendering is up to the
        --   @PangoRenderer@ in use, but typical styles include wavy
        --   or dotted lines.
        --   This underline is typically used to indicate an error such
        --   as a possible mispelling; in some cases a contrasting color
        --   may automatically be used. This type of underlining is
        --   available since Pango 1.4.
        | UnderlineSingleLine
        -- ^ Like /@pANGOUNDERLINESINGLE@/, but
        --   drawn continuously across multiple runs. This type
        --   of underlining is available since Pango 1.46.
        | UnderlineDoubleLine
        -- ^ Like /@pANGOUNDERLINEDOUBLE@/, but
        --   drawn continuously across multiple runs. This type
        --   of underlining is available since Pango 1.46.
        | UnderlineErrorLine
        -- ^ Like /@pANGOUNDERLINEERROR@/, but
        --   drawn continuously across multiple runs. This type
        --   of underlining is available since Pango 1.46.
        | AnotherUnderline Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Underline -> ShowS
    [Underline] -> ShowS
    Underline -> String
    (Int -> Underline -> ShowS)
    -> (Underline -> String)
    -> ([Underline] -> ShowS)
    -> Show Underline
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Underline -> ShowS
    showsPrec :: Int -> Underline -> ShowS
    $cshow :: Underline -> String
    show :: Underline -> String
    $cshowList :: [Underline] -> ShowS
    showList :: [Underline] -> ShowS
    Show, Underline -> Underline -> Bool
    (Underline -> Underline -> Bool)
    -> (Underline -> Underline -> Bool) -> Eq Underline
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Underline -> Underline -> Bool
    == :: Underline -> Underline -> Bool
    $c/= :: Underline -> Underline -> Bool
    /= :: Underline -> Underline -> Bool
    Eq)

    instance P.Enum Underline where
        fromEnum :: Underline -> Int
    fromEnum Underline
    UnderlineNone = Int
    0
        fromEnum Underline
    UnderlineSingle = Int
    1
        fromEnum Underline
    UnderlineDouble = Int
    2
        fromEnum Underline
    UnderlineLow = Int
    3
        fromEnum Underline
    UnderlineError = Int
    4
        fromEnum Underline
    UnderlineSingleLine = Int
    5
        fromEnum Underline
    UnderlineDoubleLine = Int
    6
        fromEnum Underline
    UnderlineErrorLine = Int
    7
        fromEnum (AnotherUnderline Int
    k) = Int
    k

        toEnum :: Int -> Underline
    toEnum Int
    0 = Underline
    UnderlineNone
        toEnum Int
    1 = Underline
    UnderlineSingle
        toEnum Int
    2 = Underline
    UnderlineDouble
        toEnum Int
    3 = Underline
    UnderlineLow
        toEnum Int
    4 = Underline
    UnderlineError
        toEnum Int
    5 = Underline
    UnderlineSingleLine
        toEnum Int
    6 = Underline
    UnderlineDoubleLine
        toEnum Int
    7 = Underline
    UnderlineErrorLine
        toEnum Int
    k = Int -> Underline
    AnotherUnderline Int
    k

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

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

    foreign import ccall "pango_underline_get_type" c_pango_underline_get_type ::
        IO GType

    instance B.Types.TypedObject Underline where
        glibType :: IO GType
    glibType = IO GType
    c_pango_underline_get_type

    instance B.Types.BoxedEnum Underline

    -- Enum TextTransform
    -- | An enumeration that affects how Pango treats characters during shaping.
    --
    -- /Since: 1.50/
    data TextTransform =
          TextTransformNone
        -- ^ Leave text unchanged
        | TextTransformLowercase
        -- ^ Display letters and numbers as lowercase
        | TextTransformUppercase
        -- ^ Display letters and numbers as uppercase
        | TextTransformCapitalize
        -- ^ Display the first character of a word
        --   in titlecase
        | AnotherTextTransform Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextTransform -> ShowS
    [TextTransform] -> ShowS
    TextTransform -> String
    (Int -> TextTransform -> ShowS)
    -> (TextTransform -> String)
    -> ([TextTransform] -> ShowS)
    -> Show TextTransform
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextTransform -> ShowS
    showsPrec :: Int -> TextTransform -> ShowS
    $cshow :: TextTransform -> String
    show :: TextTransform -> String
    $cshowList :: [TextTransform] -> ShowS
    showList :: [TextTransform] -> ShowS
    Show, TextTransform -> TextTransform -> Bool
    (TextTransform -> TextTransform -> Bool)
    -> (TextTransform -> TextTransform -> Bool) -> Eq TextTransform
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextTransform -> TextTransform -> Bool
    == :: TextTransform -> TextTransform -> Bool
    $c/= :: TextTransform -> TextTransform -> Bool
    /= :: TextTransform -> TextTransform -> Bool
    Eq)

    instance P.Enum TextTransform where
        fromEnum :: TextTransform -> Int
    fromEnum TextTransform
    TextTransformNone = Int
    0
        fromEnum TextTransform
    TextTransformLowercase = Int
    1
        fromEnum TextTransform
    TextTransformUppercase = Int
    2
        fromEnum TextTransform
    TextTransformCapitalize = Int
    3
        fromEnum (AnotherTextTransform Int
    k) = Int
    k

        toEnum :: Int -> TextTransform
    toEnum Int
    0 = TextTransform
    TextTransformNone
        toEnum Int
    1 = TextTransform
    TextTransformLowercase
        toEnum Int
    2 = TextTransform
    TextTransformUppercase
        toEnum Int
    3 = TextTransform
    TextTransformCapitalize
        toEnum Int
    k = Int -> TextTransform
    AnotherTextTransform Int
    k

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

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

    foreign import ccall "pango_text_transform_get_type" c_pango_text_transform_get_type ::
        IO GType

    instance B.Types.TypedObject TextTransform where
        glibType :: IO GType
    glibType = IO GType
    c_pango_text_transform_get_type

    instance B.Types.BoxedEnum TextTransform

    -- Enum TabAlign
    -- | @PangoTabAlign@ specifies where the text appears relative to the tab stop
    -- position.
    data TabAlign =
          TabAlignLeft
        -- ^ the text appears to the right of the tab stop position
        | TabAlignRight
        -- ^ the text appears to the left of the tab stop position
        --   until the available space is filled. Since: 1.50
        | TabAlignCenter
        -- ^ the text is centered at the tab stop position
        --   until the available space is filled. Since: 1.50
        | TabAlignDecimal
        -- ^ text before the first occurrence of the decimal point
        --   character appears to the left of the tab stop position (until the available
        --   space is filled), the rest to the right. Since: 1.50
        | AnotherTabAlign Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TabAlign -> ShowS
    [TabAlign] -> ShowS
    TabAlign -> String
    (Int -> TabAlign -> ShowS)
    -> (TabAlign -> String) -> ([TabAlign] -> ShowS) -> Show TabAlign
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TabAlign -> ShowS
    showsPrec :: Int -> TabAlign -> ShowS
    $cshow :: TabAlign -> String
    show :: TabAlign -> String
    $cshowList :: [TabAlign] -> ShowS
    showList :: [TabAlign] -> ShowS
    Show, TabAlign -> TabAlign -> Bool
    (TabAlign -> TabAlign -> Bool)
    -> (TabAlign -> TabAlign -> Bool) -> Eq TabAlign
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TabAlign -> TabAlign -> Bool
    == :: TabAlign -> TabAlign -> Bool
    $c/= :: TabAlign -> TabAlign -> Bool
    /= :: TabAlign -> TabAlign -> Bool
    Eq)

    instance P.Enum TabAlign where
        fromEnum :: TabAlign -> Int
    fromEnum TabAlign
    TabAlignLeft = Int
    0
        fromEnum TabAlign
    TabAlignRight = Int
    1
        fromEnum TabAlign
    TabAlignCenter = Int
    2
        fromEnum TabAlign
    TabAlignDecimal = Int
    3
        fromEnum (AnotherTabAlign Int
    k) = Int
    k

        toEnum :: Int -> TabAlign
    toEnum Int
    0 = TabAlign
    TabAlignLeft
        toEnum Int
    1 = TabAlign
    TabAlignRight
        toEnum Int
    2 = TabAlign
    TabAlignCenter
        toEnum Int
    3 = TabAlign
    TabAlignDecimal
        toEnum Int
    k = Int -> TabAlign
    AnotherTabAlign Int
    k

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

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

    foreign import ccall "pango_tab_align_get_type" c_pango_tab_align_get_type ::
        IO GType

    instance B.Types.TypedObject TabAlign where
        glibType :: IO GType
    glibType = IO GType
    c_pango_tab_align_get_type

    instance B.Types.BoxedEnum TabAlign

    -- Enum Style
    -- | An enumeration specifying the various slant styles possible for a font.
    data Style =
          StyleNormal
        -- ^ the font is upright.
        | StyleOblique
        -- ^ the font is slanted, but in a roman style.
        | StyleItalic
        -- ^ the font is slanted in an italic style.
        | AnotherStyle Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Style -> ShowS
    [Style] -> ShowS
    Style -> String
    (Int -> Style -> ShowS)
    -> (Style -> String) -> ([Style] -> ShowS) -> Show Style
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Style -> ShowS
    showsPrec :: Int -> Style -> ShowS
    $cshow :: Style -> String
    show :: Style -> String
    $cshowList :: [Style] -> ShowS
    showList :: [Style] -> ShowS
    Show, Style -> Style -> Bool
    (Style -> Style -> Bool) -> (Style -> Style -> Bool) -> Eq Style
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Style -> Style -> Bool
    == :: Style -> Style -> Bool
    $c/= :: Style -> Style -> Bool
    /= :: Style -> Style -> Bool
    Eq)

    instance P.Enum Style where
        fromEnum :: Style -> Int
    fromEnum Style
    StyleNormal = Int
    0
        fromEnum Style
    StyleOblique = Int
    1
        fromEnum Style
    StyleItalic = Int
    2
        fromEnum (AnotherStyle Int
    k) = Int
    k

        toEnum :: Int -> Style
    toEnum Int
    0 = Style
    StyleNormal
        toEnum Int
    1 = Style
    StyleOblique
        toEnum Int
    2 = Style
    StyleItalic
        toEnum Int
    k = Int -> Style
    AnotherStyle Int
    k

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

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

    foreign import ccall "pango_style_get_type" c_pango_style_get_type ::
        IO GType

    instance B.Types.TypedObject Style where
        glibType :: IO GType
    glibType = IO GType
    c_pango_style_get_type

    instance B.Types.BoxedEnum Style

    -- Enum Stretch
    -- | An enumeration specifying the width of the font relative to other designs
    -- within a family.
    data Stretch =
          StretchUltraCondensed
        -- ^ ultra condensed width
        | StretchExtraCondensed
        -- ^ extra condensed width
        | StretchCondensed
        -- ^ condensed width
        | StretchSemiCondensed
        -- ^ semi condensed width
        | StretchNormal
        -- ^ the normal width
        | StretchSemiExpanded
        -- ^ semi expanded width
        | StretchExpanded
        -- ^ expanded width
        | StretchExtraExpanded
        -- ^ extra expanded width
        | StretchUltraExpanded
        -- ^ ultra expanded width
        | AnotherStretch Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Stretch -> ShowS
    [Stretch] -> ShowS
    Stretch -> String
    (Int -> Stretch -> ShowS)
    -> (Stretch -> String) -> ([Stretch] -> ShowS) -> Show Stretch
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Stretch -> ShowS
    showsPrec :: Int -> Stretch -> ShowS
    $cshow :: Stretch -> String
    show :: Stretch -> String
    $cshowList :: [Stretch] -> ShowS
    showList :: [Stretch] -> ShowS
    Show, Stretch -> Stretch -> Bool
    (Stretch -> Stretch -> Bool)
    -> (Stretch -> Stretch -> Bool) -> Eq Stretch
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Stretch -> Stretch -> Bool
    == :: Stretch -> Stretch -> Bool
    $c/= :: Stretch -> Stretch -> Bool
    /= :: Stretch -> Stretch -> Bool
    Eq)

    instance P.Enum Stretch where
        fromEnum :: Stretch -> Int
    fromEnum Stretch
    StretchUltraCondensed = Int
    0
        fromEnum Stretch
    StretchExtraCondensed = Int
    1
        fromEnum Stretch
    StretchCondensed = Int
    2
        fromEnum Stretch
    StretchSemiCondensed = Int
    3
        fromEnum Stretch
    StretchNormal = Int
    4
        fromEnum Stretch
    StretchSemiExpanded = Int
    5
        fromEnum Stretch
    StretchExpanded = Int
    6
        fromEnum Stretch
    StretchExtraExpanded = Int
    7
        fromEnum Stretch
    StretchUltraExpanded = Int
    8
        fromEnum (AnotherStretch Int
    k) = Int
    k

        toEnum :: Int -> Stretch
    toEnum Int
    0 = Stretch
    StretchUltraCondensed
        toEnum Int
    1 = Stretch
    StretchExtraCondensed
        toEnum Int
    2 = Stretch
    StretchCondensed
        toEnum Int
    3 = Stretch
    StretchSemiCondensed
        toEnum Int
    4 = Stretch
    StretchNormal
        toEnum Int
    5 = Stretch
    StretchSemiExpanded
        toEnum Int
    6 = Stretch
    StretchExpanded
        toEnum Int
    7 = Stretch
    StretchExtraExpanded
        toEnum Int
    8 = Stretch
    StretchUltraExpanded
        toEnum Int
    k = Int -> Stretch
    AnotherStretch Int
    k

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

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

    foreign import ccall "pango_stretch_get_type" c_pango_stretch_get_type ::
        IO GType

    instance B.Types.TypedObject Stretch where
        glibType :: IO GType
    glibType = IO GType
    c_pango_stretch_get_type

    instance B.Types.BoxedEnum Stretch

    -- Enum Script
    -- | The @PangoScript@ enumeration identifies different writing
    -- systems.
    --
    -- The values correspond to the names as defined in the Unicode standard. See
    -- <http://www.unicode.org/reports/tr24/ Unicode Standard Annex 24: Script names>
    --
    -- Note that this enumeration is deprecated and will not be updated to include values
    -- in newer versions of the Unicode standard. Applications should use the
    -- t'GI.GLib.Enums.UnicodeScript' enumeration instead,
    -- whose values are interchangeable with @PangoScript@.
    data Script =
          ScriptInvalidCode
        -- ^ a value never returned from 'GI.Pango.Functions.scriptForUnichar'
        | ScriptCommon
        -- ^ a character used by multiple different scripts
        | ScriptInherited
        -- ^ a mark glyph that takes its script from the
        -- base glyph to which it is attached
        | ScriptArabic
        -- ^ Arabic
        | ScriptArmenian
        -- ^ Armenian
        | ScriptBengali
        -- ^ Bengali
        | ScriptBopomofo
        -- ^ Bopomofo
        | ScriptCherokee
        -- ^ Cherokee
        | ScriptCoptic
        -- ^ Coptic
        | ScriptCyrillic
        -- ^ Cyrillic
        | ScriptDeseret
        -- ^ Deseret
        | ScriptDevanagari
        -- ^ Devanagari
        | ScriptEthiopic
        -- ^ Ethiopic
        | ScriptGeorgian
        -- ^ Georgian
        | ScriptGothic
        -- ^ Gothic
        | ScriptGreek
        -- ^ Greek
        | ScriptGujarati
        -- ^ Gujarati
        | ScriptGurmukhi
        -- ^ Gurmukhi
        | ScriptHan
        -- ^ Han
        | ScriptHangul
        -- ^ Hangul
        | ScriptHebrew
        -- ^ Hebrew
        | ScriptHiragana
        -- ^ Hiragana
        | ScriptKannada
        -- ^ Kannada
        | ScriptKatakana
        -- ^ Katakana
        | ScriptKhmer
        -- ^ Khmer
        | ScriptLao
        -- ^ Lao
        | ScriptLatin
        -- ^ Latin
        | ScriptMalayalam
        -- ^ Malayalam
        | ScriptMongolian
        -- ^ Mongolian
        | ScriptMyanmar
        -- ^ Myanmar
        | ScriptOgham
        -- ^ Ogham
        | ScriptOldItalic
        -- ^ Old Italic
        | ScriptOriya
        -- ^ Oriya
        | ScriptRunic
        -- ^ Runic
        | ScriptSinhala
        -- ^ Sinhala
        | ScriptSyriac
        -- ^ Syriac
        | ScriptTamil
        -- ^ Tamil
        | ScriptTelugu
        -- ^ Telugu
        | ScriptThaana
        -- ^ Thaana
        | ScriptThai
        -- ^ Thai
        | ScriptTibetan
        -- ^ Tibetan
        | ScriptCanadianAboriginal
        -- ^ Canadian Aboriginal
        | ScriptYi
        -- ^ Yi
        | ScriptTagalog
        -- ^ Tagalog
        | ScriptHanunoo
        -- ^ Hanunoo
        | ScriptBuhid
        -- ^ Buhid
        | ScriptTagbanwa
        -- ^ Tagbanwa
        | ScriptBraille
        -- ^ Braille
        | ScriptCypriot
        -- ^ Cypriot
        | ScriptLimbu
        -- ^ Limbu
        | ScriptOsmanya
        -- ^ Osmanya
        | ScriptShavian
        -- ^ Shavian
        | ScriptLinearB
        -- ^ Linear B
        | ScriptTaiLe
        -- ^ Tai Le
        | ScriptUgaritic
        -- ^ Ugaritic
        | ScriptNewTaiLue
        -- ^ New Tai Lue. Since 1.10
        | ScriptBuginese
        -- ^ Buginese. Since 1.10
        | ScriptGlagolitic
        -- ^ Glagolitic. Since 1.10
        | ScriptTifinagh
        -- ^ Tifinagh. Since 1.10
        | ScriptSylotiNagri
        -- ^ Syloti Nagri. Since 1.10
        | ScriptOldPersian
        -- ^ Old Persian. Since 1.10
        | ScriptKharoshthi
        -- ^ Kharoshthi. Since 1.10
        | ScriptUnknown
        -- ^ an unassigned code point. Since 1.14
        | ScriptBalinese
        -- ^ Balinese. Since 1.14
        | ScriptCuneiform
        -- ^ Cuneiform. Since 1.14
        | ScriptPhoenician
        -- ^ Phoenician. Since 1.14
        | ScriptPhagsPa
        -- ^ Phags-pa. Since 1.14
        | ScriptNko
        -- ^ N\'Ko. Since 1.14
        | ScriptKayahLi
        -- ^ Kayah Li. Since 1.20.1
        | ScriptLepcha
        -- ^ Lepcha. Since 1.20.1
        | ScriptRejang
        -- ^ Rejang. Since 1.20.1
        | ScriptSundanese
        -- ^ Sundanese. Since 1.20.1
        | ScriptSaurashtra
        -- ^ Saurashtra. Since 1.20.1
        | ScriptCham
        -- ^ Cham. Since 1.20.1
        | ScriptOlChiki
        -- ^ Ol Chiki. Since 1.20.1
        | ScriptVai
        -- ^ Vai. Since 1.20.1
        | ScriptCarian
        -- ^ Carian. Since 1.20.1
        | ScriptLycian
        -- ^ Lycian. Since 1.20.1
        | ScriptLydian
        -- ^ Lydian. Since 1.20.1
        | ScriptBatak
        -- ^ Batak. Since 1.32
        | ScriptBrahmi
        -- ^ Brahmi. Since 1.32
        | ScriptMandaic
        -- ^ Mandaic. Since 1.32
        | ScriptChakma
        -- ^ Chakma. Since: 1.32
        | ScriptMeroiticCursive
        -- ^ Meroitic Cursive. Since: 1.32
        | ScriptMeroiticHieroglyphs
        -- ^ Meroitic Hieroglyphs. Since: 1.32
        | ScriptMiao
        -- ^ Miao. Since: 1.32
        | ScriptSharada
        -- ^ Sharada. Since: 1.32
        | ScriptSoraSompeng
        -- ^ Sora Sompeng. Since: 1.32
        | ScriptTakri
        -- ^ Takri. Since: 1.32
        | ScriptBassaVah
        -- ^ Bassa. Since: 1.40
        | ScriptCaucasianAlbanian
        -- ^ Caucasian Albanian. Since: 1.40
        | ScriptDuployan
        -- ^ Duployan. Since: 1.40
        | ScriptElbasan
        -- ^ Elbasan. Since: 1.40
        | ScriptGrantha
        -- ^ Grantha. Since: 1.40
        | ScriptKhojki
        -- ^ Kjohki. Since: 1.40
        | ScriptKhudawadi
        -- ^ Khudawadi, Sindhi. Since: 1.40
        | ScriptLinearA
        -- ^ Linear A. Since: 1.40
        | ScriptMahajani
        -- ^ Mahajani. Since: 1.40
        | ScriptManichaean
        -- ^ Manichaean. Since: 1.40
        | ScriptMendeKikakui
        -- ^ Mende Kikakui. Since: 1.40
        | ScriptModi
        -- ^ Modi. Since: 1.40
        | ScriptMro
        -- ^ Mro. Since: 1.40
        | ScriptNabataean
        -- ^ Nabataean. Since: 1.40
        | ScriptOldNorthArabian
        -- ^ Old North Arabian. Since: 1.40
        | ScriptOldPermic
        -- ^ Old Permic. Since: 1.40
        | ScriptPahawhHmong
        -- ^ Pahawh Hmong. Since: 1.40
        | ScriptPalmyrene
        -- ^ Palmyrene. Since: 1.40
        | ScriptPauCinHau
        -- ^ Pau Cin Hau. Since: 1.40
        | ScriptPsalterPahlavi
        -- ^ Psalter Pahlavi. Since: 1.40
        | ScriptSiddham
        -- ^ Siddham. Since: 1.40
        | ScriptTirhuta
        -- ^ Tirhuta. Since: 1.40
        | ScriptWarangCiti
        -- ^ Warang Citi. Since: 1.40
        | ScriptAhom
        -- ^ Ahom. Since: 1.40
        | ScriptAnatolianHieroglyphs
        -- ^ Anatolian Hieroglyphs. Since: 1.40
        | ScriptHatran
        -- ^ Hatran. Since: 1.40
        | ScriptMultani
        -- ^ Multani. Since: 1.40
        | ScriptOldHungarian
        -- ^ Old Hungarian. Since: 1.40
        | ScriptSignwriting
        -- ^ Signwriting. Since: 1.40
        | AnotherScript Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Script -> ShowS
    [Script] -> ShowS
    Script -> String
    (Int -> Script -> ShowS)
    -> (Script -> String) -> ([Script] -> ShowS) -> Show Script
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Script -> ShowS
    showsPrec :: Int -> Script -> ShowS
    $cshow :: Script -> String
    show :: Script -> String
    $cshowList :: [Script] -> ShowS
    showList :: [Script] -> ShowS
    Show, Script -> Script -> Bool
    (Script -> Script -> Bool)
    -> (Script -> Script -> Bool) -> Eq Script
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Script -> Script -> Bool
    == :: Script -> Script -> Bool
    $c/= :: Script -> Script -> Bool
    /= :: Script -> Script -> Bool
    Eq)

    instance P.Enum Script where
        fromEnum :: Script -> Int
    fromEnum Script
    ScriptInvalidCode = Int
    -1
        fromEnum Script
    ScriptCommon = Int
    0
        fromEnum Script
    ScriptInherited = Int
    1
        fromEnum Script
    ScriptArabic = Int
    2
        fromEnum Script
    ScriptArmenian = Int
    3
        fromEnum Script
    ScriptBengali = Int
    4
        fromEnum Script
    ScriptBopomofo = Int
    5
        fromEnum Script
    ScriptCherokee = Int
    6
        fromEnum Script
    ScriptCoptic = Int
    7
        fromEnum Script
    ScriptCyrillic = Int
    8
        fromEnum Script
    ScriptDeseret = Int
    9
        fromEnum Script
    ScriptDevanagari = Int
    10
        fromEnum Script
    ScriptEthiopic = Int
    11
        fromEnum Script
    ScriptGeorgian = Int
    12
        fromEnum Script
    ScriptGothic = Int
    13
        fromEnum Script
    ScriptGreek = Int
    14
        fromEnum Script
    ScriptGujarati = Int
    15
        fromEnum Script
    ScriptGurmukhi = Int
    16
        fromEnum Script
    ScriptHan = Int
    17
        fromEnum Script
    ScriptHangul = Int
    18
        fromEnum Script
    ScriptHebrew = Int
    19
        fromEnum Script
    ScriptHiragana = Int
    20
        fromEnum Script
    ScriptKannada = Int
    21
        fromEnum Script
    ScriptKatakana = Int
    22
        fromEnum Script
    ScriptKhmer = Int
    23
        fromEnum Script
    ScriptLao = Int
    24
        fromEnum Script
    ScriptLatin = Int
    25
        fromEnum Script
    ScriptMalayalam = Int
    26
        fromEnum Script
    ScriptMongolian = Int
    27
        fromEnum Script
    ScriptMyanmar = Int
    28
        fromEnum Script
    ScriptOgham = Int
    29
        fromEnum Script
    ScriptOldItalic = Int
    30
        fromEnum Script
    ScriptOriya = Int
    31
        fromEnum Script
    ScriptRunic = Int
    32
        fromEnum Script
    ScriptSinhala = Int
    33
        fromEnum Script
    ScriptSyriac = Int
    34
        fromEnum Script
    ScriptTamil = Int
    35
        fromEnum Script
    ScriptTelugu = Int
    36
        fromEnum Script
    ScriptThaana = Int
    37
        fromEnum Script
    ScriptThai = Int
    38
        fromEnum Script
    ScriptTibetan = Int
    39
        fromEnum Script
    ScriptCanadianAboriginal = Int
    40
        fromEnum Script
    ScriptYi = Int
    41
        fromEnum Script
    ScriptTagalog = Int
    42
        fromEnum Script
    ScriptHanunoo = Int
    43
        fromEnum Script
    ScriptBuhid = Int
    44
        fromEnum Script
    ScriptTagbanwa = Int
    45
        fromEnum Script
    ScriptBraille = Int
    46
        fromEnum Script
    ScriptCypriot = Int
    47
        fromEnum Script
    ScriptLimbu = Int
    48
        fromEnum Script
    ScriptOsmanya = Int
    49
        fromEnum Script
    ScriptShavian = Int
    50
        fromEnum Script
    ScriptLinearB = Int
    51
        fromEnum Script
    ScriptTaiLe = Int
    52
        fromEnum Script
    ScriptUgaritic = Int
    53
        fromEnum Script
    ScriptNewTaiLue = Int
    54
        fromEnum Script
    ScriptBuginese = Int
    55
        fromEnum Script
    ScriptGlagolitic = Int
    56
        fromEnum Script
    ScriptTifinagh = Int
    57
        fromEnum Script
    ScriptSylotiNagri = Int
    58
        fromEnum Script
    ScriptOldPersian = Int
    59
        fromEnum Script
    ScriptKharoshthi = Int
    60
        fromEnum Script
    ScriptUnknown = Int
    61
        fromEnum Script
    ScriptBalinese = Int
    62
        fromEnum Script
    ScriptCuneiform = Int
    63
        fromEnum Script
    ScriptPhoenician = Int
    64
        fromEnum Script
    ScriptPhagsPa = Int
    65
        fromEnum Script
    ScriptNko = Int
    66
        fromEnum Script
    ScriptKayahLi = Int
    67
        fromEnum Script
    ScriptLepcha = Int
    68
        fromEnum Script
    ScriptRejang = Int
    69
        fromEnum Script
    ScriptSundanese = Int
    70
        fromEnum Script
    ScriptSaurashtra = Int
    71
        fromEnum Script
    ScriptCham = Int
    72
        fromEnum Script
    ScriptOlChiki = Int
    73
        fromEnum Script
    ScriptVai = Int
    74
        fromEnum Script
    ScriptCarian = Int
    75
        fromEnum Script
    ScriptLycian = Int
    76
        fromEnum Script
    ScriptLydian = Int
    77
        fromEnum Script
    ScriptBatak = Int
    78
        fromEnum Script
    ScriptBrahmi = Int
    79
        fromEnum Script
    ScriptMandaic = Int
    80
        fromEnum Script
    ScriptChakma = Int
    81
        fromEnum Script
    ScriptMeroiticCursive = Int
    82
        fromEnum Script
    ScriptMeroiticHieroglyphs = Int
    83
        fromEnum Script
    ScriptMiao = Int
    84
        fromEnum Script
    ScriptSharada = Int
    85
        fromEnum Script
    ScriptSoraSompeng = Int
    86
        fromEnum Script
    ScriptTakri = Int
    87
        fromEnum Script
    ScriptBassaVah = Int
    88
        fromEnum Script
    ScriptCaucasianAlbanian = Int
    89
        fromEnum Script
    ScriptDuployan = Int
    90
        fromEnum Script
    ScriptElbasan = Int
    91
        fromEnum Script
    ScriptGrantha = Int
    92
        fromEnum Script
    ScriptKhojki = Int
    93
        fromEnum Script
    ScriptKhudawadi = Int
    94
        fromEnum Script
    ScriptLinearA = Int
    95
        fromEnum Script
    ScriptMahajani = Int
    96
        fromEnum Script
    ScriptManichaean = Int
    97
        fromEnum Script
    ScriptMendeKikakui = Int
    98
        fromEnum Script
    ScriptModi = Int
    99
        fromEnum Script
    ScriptMro = Int
    100
        fromEnum Script
    ScriptNabataean = Int
    101
        fromEnum Script
    ScriptOldNorthArabian = Int
    102
        fromEnum Script
    ScriptOldPermic = Int
    103
        fromEnum Script
    ScriptPahawhHmong = Int
    104
        fromEnum Script
    ScriptPalmyrene = Int
    105
        fromEnum Script
    ScriptPauCinHau = Int
    106
        fromEnum Script
    ScriptPsalterPahlavi = Int
    107
        fromEnum Script
    ScriptSiddham = Int
    108
        fromEnum Script
    ScriptTirhuta = Int
    109
        fromEnum Script
    ScriptWarangCiti = Int
    110
        fromEnum Script
    ScriptAhom = Int
    111
        fromEnum Script
    ScriptAnatolianHieroglyphs = Int
    112
        fromEnum Script
    ScriptHatran = Int
    113
        fromEnum Script
    ScriptMultani = Int
    114
        fromEnum Script
    ScriptOldHungarian = Int
    115
        fromEnum Script
    ScriptSignwriting = Int
    116
        fromEnum (AnotherScript Int
    k) = Int
    k

        toEnum :: Int -> Script
    toEnum Int
    -1 = Script
    ScriptInvalidCode
        toEnum Int
    0 = Script
    ScriptCommon
        toEnum Int
    1 = Script
    ScriptInherited
        toEnum Int
    2 = Script
    ScriptArabic
        toEnum Int
    3 = Script
    ScriptArmenian
        toEnum Int
    4 = Script
    ScriptBengali
        toEnum Int
    5 = Script
    ScriptBopomofo
        toEnum Int
    6 = Script
    ScriptCherokee
        toEnum Int
    7 = Script
    ScriptCoptic
        toEnum Int
    8 = Script
    ScriptCyrillic
        toEnum Int
    9 = Script
    ScriptDeseret
        toEnum Int
    10 = Script
    ScriptDevanagari
        toEnum Int
    11 = Script
    ScriptEthiopic
        toEnum Int
    12 = Script
    ScriptGeorgian
        toEnum Int
    13 = Script
    ScriptGothic
        toEnum Int
    14 = Script
    ScriptGreek
        toEnum Int
    15 = Script
    ScriptGujarati
        toEnum Int
    16 = Script
    ScriptGurmukhi
        toEnum Int
    17 = Script
    ScriptHan
        toEnum Int
    18 = Script
    ScriptHangul
        toEnum Int
    19 = Script
    ScriptHebrew
        toEnum Int
    20 = Script
    ScriptHiragana
        toEnum Int
    21 = Script
    ScriptKannada
        toEnum Int
    22 = Script
    ScriptKatakana
        toEnum Int
    23 = Script
    ScriptKhmer
        toEnum Int
    24 = Script
    ScriptLao
        toEnum Int
    25 = Script
    ScriptLatin
        toEnum Int
    26 = Script
    ScriptMalayalam
        toEnum Int
    27 = Script
    ScriptMongolian
        toEnum Int
    28 = Script
    ScriptMyanmar
        toEnum Int
    29 = Script
    ScriptOgham
        toEnum Int
    30 = Script
    ScriptOldItalic
        toEnum Int
    31 = Script
    ScriptOriya
        toEnum Int
    32 = Script
    ScriptRunic
        toEnum Int
    33 = Script
    ScriptSinhala
        toEnum Int
    34 = Script
    ScriptSyriac
        toEnum Int
    35 = Script
    ScriptTamil
        toEnum Int
    36 = Script
    ScriptTelugu
        toEnum Int
    37 = Script
    ScriptThaana
        toEnum Int
    38 = Script
    ScriptThai
        toEnum Int
    39 = Script
    ScriptTibetan
        toEnum Int
    40 = Script
    ScriptCanadianAboriginal
        toEnum Int
    41 = Script
    ScriptYi
        toEnum Int
    42 = Script
    ScriptTagalog
        toEnum Int
    43 = Script
    ScriptHanunoo
        toEnum Int
    44 = Script
    ScriptBuhid
        toEnum Int
    45 = Script
    ScriptTagbanwa
        toEnum Int
    46 = Script
    ScriptBraille
        toEnum Int
    47 = Script
    ScriptCypriot
        toEnum Int
    48 = Script
    ScriptLimbu
        toEnum Int
    49 = Script
    ScriptOsmanya
        toEnum Int
    50 = Script
    ScriptShavian
        toEnum Int
    51 = Script
    ScriptLinearB
        toEnum Int
    52 = Script
    ScriptTaiLe
        toEnum Int
    53 = Script
    ScriptUgaritic
        toEnum Int
    54 = Script
    ScriptNewTaiLue
        toEnum Int
    55 = Script
    ScriptBuginese
        toEnum Int
    56 = Script
    ScriptGlagolitic
        toEnum Int
    57 = Script
    ScriptTifinagh
        toEnum Int
    58 = Script
    ScriptSylotiNagri
        toEnum Int
    59 = Script
    ScriptOldPersian
        toEnum Int
    60 = Script
    ScriptKharoshthi
        toEnum Int
    61 = Script
    ScriptUnknown
        toEnum Int
    62 = Script
    ScriptBalinese
        toEnum Int
    63 = Script
    ScriptCuneiform
        toEnum Int
    64 = Script
    ScriptPhoenician
        toEnum Int
    65 = Script
    ScriptPhagsPa
        toEnum Int
    66 = Script
    ScriptNko
        toEnum Int
    67 = Script
    ScriptKayahLi
        toEnum Int
    68 = Script
    ScriptLepcha
        toEnum Int
    69 = Script
    ScriptRejang
        toEnum Int
    70 = Script
    ScriptSundanese
        toEnum Int
    71 = Script
    ScriptSaurashtra
        toEnum Int
    72 = Script
    ScriptCham
        toEnum Int
    73 = Script
    ScriptOlChiki
        toEnum Int
    74 = Script
    ScriptVai
        toEnum Int
    75 = Script
    ScriptCarian
        toEnum Int
    76 = Script
    ScriptLycian
        toEnum Int
    77 = Script
    ScriptLydian
        toEnum Int
    78 = Script
    ScriptBatak
        toEnum Int
    79 = Script
    ScriptBrahmi
        toEnum Int
    80 = Script
    ScriptMandaic
        toEnum Int
    81 = Script
    ScriptChakma
        toEnum Int
    82 = Script
    ScriptMeroiticCursive
        toEnum Int
    83 = Script
    ScriptMeroiticHieroglyphs
        toEnum Int
    84 = Script
    ScriptMiao
        toEnum Int
    85 = Script
    ScriptSharada
        toEnum Int
    86 = Script
    ScriptSoraSompeng
        toEnum Int
    87 = Script
    ScriptTakri
        toEnum Int
    88 = Script
    ScriptBassaVah
        toEnum Int
    89 = Script
    ScriptCaucasianAlbanian
        toEnum Int
    90 = Script
    ScriptDuployan
        toEnum Int
    91 = Script
    ScriptElbasan
        toEnum Int
    92 = Script
    ScriptGrantha
        toEnum Int
    93 = Script
    ScriptKhojki
        toEnum Int
    94 = Script
    ScriptKhudawadi
        toEnum Int
    95 = Script
    ScriptLinearA
        toEnum Int
    96 = Script
    ScriptMahajani
        toEnum Int
    97 = Script
    ScriptManichaean
        toEnum Int
    98 = Script
    ScriptMendeKikakui
        toEnum Int
    99 = Script
    ScriptModi
        toEnum Int
    100 = Script
    ScriptMro
        toEnum Int
    101 = Script
    ScriptNabataean
        toEnum Int
    102 = Script
    ScriptOldNorthArabian
        toEnum Int
    103 = Script
    ScriptOldPermic
        toEnum Int
    104 = Script
    ScriptPahawhHmong
        toEnum Int
    105 = Script
    ScriptPalmyrene
        toEnum Int
    106 = Script
    ScriptPauCinHau
        toEnum Int
    107 = Script
    ScriptPsalterPahlavi
        toEnum Int
    108 = Script
    ScriptSiddham
        toEnum Int
    109 = Script
    ScriptTirhuta
        toEnum Int
    110 = Script
    ScriptWarangCiti
        toEnum Int
    111 = Script
    ScriptAhom
        toEnum Int
    112 = Script
    ScriptAnatolianHieroglyphs
        toEnum Int
    113 = Script
    ScriptHatran
        toEnum Int
    114 = Script
    ScriptMultani
        toEnum Int
    115 = Script
    ScriptOldHungarian
        toEnum Int
    116 = Script
    ScriptSignwriting
        toEnum Int
    k = Int -> Script
    AnotherScript Int
    k

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

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

    foreign import ccall "pango_script_get_type" c_pango_script_get_type ::
        IO GType

    instance B.Types.TypedObject Script where
        glibType :: IO GType
    glibType = IO GType
    c_pango_script_get_type

    instance B.Types.BoxedEnum Script

    -- Enum RenderPart
    -- | @PangoRenderPart@ defines different items to render for such
    -- purposes as setting colors.
    --
    -- /Since: 1.8/
    data RenderPart =
          RenderPartForeground
        -- ^ the text itself
        | RenderPartBackground
        -- ^ the area behind the text
        | RenderPartUnderline
        -- ^ underlines
        | RenderPartStrikethrough
        -- ^ strikethrough lines
        | RenderPartOverline
        -- ^ overlines
        | AnotherRenderPart Int
        -- ^ Catch-all for unknown values
        deriving (Int -> RenderPart -> ShowS
    [RenderPart] -> ShowS
    RenderPart -> String
    (Int -> RenderPart -> ShowS)
    -> (RenderPart -> String)
    -> ([RenderPart] -> ShowS)
    -> Show RenderPart
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> RenderPart -> ShowS
    showsPrec :: Int -> RenderPart -> ShowS
    $cshow :: RenderPart -> String
    show :: RenderPart -> String
    $cshowList :: [RenderPart] -> ShowS
    showList :: [RenderPart] -> ShowS
    Show, RenderPart -> RenderPart -> Bool
    (RenderPart -> RenderPart -> Bool)
    -> (RenderPart -> RenderPart -> Bool) -> Eq RenderPart
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RenderPart -> RenderPart -> Bool
    == :: RenderPart -> RenderPart -> Bool
    $c/= :: RenderPart -> RenderPart -> Bool
    /= :: RenderPart -> RenderPart -> Bool
    Eq)

    instance P.Enum RenderPart where
        fromEnum :: RenderPart -> Int
    fromEnum RenderPart
    RenderPartForeground = Int
    0
        fromEnum RenderPart
    RenderPartBackground = Int
    1
        fromEnum RenderPart
    RenderPartUnderline = Int
    2
        fromEnum RenderPart
    RenderPartStrikethrough = Int
    3
        fromEnum RenderPart
    RenderPartOverline = Int
    4
        fromEnum (AnotherRenderPart Int
    k) = Int
    k

        toEnum :: Int -> RenderPart
    toEnum Int
    0 = RenderPart
    RenderPartForeground
        toEnum Int
    1 = RenderPart
    RenderPartBackground
        toEnum Int
    2 = RenderPart
    RenderPartUnderline
        toEnum Int
    3 = RenderPart
    RenderPartStrikethrough
        toEnum Int
    4 = RenderPart
    RenderPartOverline
        toEnum Int
    k = Int -> RenderPart
    AnotherRenderPart Int
    k

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

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

    foreign import ccall "pango_render_part_get_type" c_pango_render_part_get_type ::
        IO GType

    instance B.Types.TypedObject RenderPart where
        glibType :: IO GType
    glibType = IO GType
    c_pango_render_part_get_type

    instance B.Types.BoxedEnum RenderPart

    -- Enum Overline
    -- | The @PangoOverline@ enumeration is used to specify whether text
    -- should be overlined, and if so, the type of line.
    --
    -- /Since: 1.46/
    data Overline =
          OverlineNone
        -- ^ no overline should be drawn
        | OverlineSingle
        -- ^ Draw a single line above the ink
        --   extents of the text being underlined.
        | AnotherOverline Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Overline -> ShowS
    [Overline] -> ShowS
    Overline -> String
    (Int -> Overline -> ShowS)
    -> (Overline -> String) -> ([Overline] -> ShowS) -> Show Overline
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Overline -> ShowS
    showsPrec :: Int -> Overline -> ShowS
    $cshow :: Overline -> String
    show :: Overline -> String
    $cshowList :: [Overline] -> ShowS
    showList :: [Overline] -> ShowS
    Show, Overline -> Overline -> Bool
    (Overline -> Overline -> Bool)
    -> (Overline -> Overline -> Bool) -> Eq Overline
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Overline -> Overline -> Bool
    == :: Overline -> Overline -> Bool
    $c/= :: Overline -> Overline -> Bool
    /= :: Overline -> Overline -> Bool
    Eq)

    instance P.Enum Overline where
        fromEnum :: Overline -> Int
    fromEnum Overline
    OverlineNone = Int
    0
        fromEnum Overline
    OverlineSingle = Int
    1
        fromEnum (AnotherOverline Int
    k) = Int
    k

        toEnum :: Int -> Overline
    toEnum Int
    0 = Overline
    OverlineNone
        toEnum Int
    1 = Overline
    OverlineSingle
        toEnum Int
    k = Int -> Overline
    AnotherOverline Int
    k

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

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

    foreign import ccall "pango_overline_get_type" c_pango_overline_get_type ::
        IO GType

    instance B.Types.TypedObject Overline where
        glibType :: IO GType
    glibType = IO GType
    c_pango_overline_get_type

    instance B.Types.BoxedEnum Overline

    -- Enum LayoutDeserializeError
    -- | Errors that can be returned by [func/@pango@/.Layout.deserialize].
    --
    -- /Since: 1.50/
    data LayoutDeserializeError =
          LayoutDeserializeErrorInvalid
        -- ^ Unspecified error
        | LayoutDeserializeErrorInvalidValue
        -- ^ A JSon value could not be
        --   interpreted
        | LayoutDeserializeErrorMissingValue
        -- ^ A required JSon member was
        --   not found
        | AnotherLayoutDeserializeError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> LayoutDeserializeError -> ShowS
    [LayoutDeserializeError] -> ShowS
    LayoutDeserializeError -> String
    (Int -> LayoutDeserializeError -> ShowS)
    -> (LayoutDeserializeError -> String)
    -> ([LayoutDeserializeError] -> ShowS)
    -> Show LayoutDeserializeError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LayoutDeserializeError -> ShowS
    showsPrec :: Int -> LayoutDeserializeError -> ShowS
    $cshow :: LayoutDeserializeError -> String
    show :: LayoutDeserializeError -> String
    $cshowList :: [LayoutDeserializeError] -> ShowS
    showList :: [LayoutDeserializeError] -> ShowS
    Show, LayoutDeserializeError -> LayoutDeserializeError -> Bool
    (LayoutDeserializeError -> LayoutDeserializeError -> Bool)
    -> (LayoutDeserializeError -> LayoutDeserializeError -> Bool)
    -> Eq LayoutDeserializeError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
    == :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
    $c/= :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
    /= :: LayoutDeserializeError -> LayoutDeserializeError -> Bool
    Eq)

    instance P.Enum LayoutDeserializeError where
        fromEnum :: LayoutDeserializeError -> Int
    fromEnum LayoutDeserializeError
    LayoutDeserializeErrorInvalid = Int
    0
        fromEnum LayoutDeserializeError
    LayoutDeserializeErrorInvalidValue = Int
    1
        fromEnum LayoutDeserializeError
    LayoutDeserializeErrorMissingValue = Int
    2
        fromEnum (AnotherLayoutDeserializeError Int
    k) = Int
    k

        toEnum :: Int -> LayoutDeserializeError
    toEnum Int
    0 = LayoutDeserializeError
    LayoutDeserializeErrorInvalid
        toEnum Int
    1 = LayoutDeserializeError
    LayoutDeserializeErrorInvalidValue
        toEnum Int
    2 = LayoutDeserializeError
    LayoutDeserializeErrorMissingValue
        toEnum Int
    k = Int -> LayoutDeserializeError
    AnotherLayoutDeserializeError Int
    k

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

    instance GErrorClass LayoutDeserializeError where
        gerrorClassDomain :: LayoutDeserializeError -> Text
    gerrorClassDomain LayoutDeserializeError
    _ = Text
    "pango-layout-deserialize-error-quark"

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

    -- | Handle exceptions of type `LayoutDeserializeError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleLayoutDeserializeError ::
        (LayoutDeserializeError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleLayoutDeserializeError :: forall a. (LayoutDeserializeError -> Text -> IO a) -> IO a -> IO a
    handleLayoutDeserializeError = (LayoutDeserializeError -> 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 LayoutDeserializeError = '[]
    instance O.HasParentTypes LayoutDeserializeError

    foreign import ccall "pango_layout_deserialize_error_get_type" c_pango_layout_deserialize_error_get_type ::
        IO GType

    instance B.Types.TypedObject LayoutDeserializeError where
        glibType :: IO GType
    glibType = IO GType
    c_pango_layout_deserialize_error_get_type

    instance B.Types.BoxedEnum LayoutDeserializeError

    -- Enum GravityHint
    -- | @PangoGravityHint@ defines how horizontal scripts should behave in a
    -- vertical context.
    --
    -- That is, English excerpts in a vertical paragraph for example.
    --
    -- See also t'GI.Pango.Enums.Gravity'
    --
    -- /Since: 1.16/
    data GravityHint =
          GravityHintNatural
        -- ^ scripts will take their natural gravity based
        --   on the base gravity and the script.  This is the default.
        | GravityHintStrong
        -- ^ always use the base gravity set, regardless of
        --   the script.
        | GravityHintLine
        -- ^ for scripts not in their natural direction (eg.
        --   Latin in East gravity), choose per-script gravity such that every script
        --   respects the line progression. This means, Latin and Arabic will take
        --   opposite gravities and both flow top-to-bottom for example.
        | AnotherGravityHint Int
        -- ^ Catch-all for unknown values
        deriving (Int -> GravityHint -> ShowS
    [GravityHint] -> ShowS
    GravityHint -> String
    (Int -> GravityHint -> ShowS)
    -> (GravityHint -> String)
    -> ([GravityHint] -> ShowS)
    -> Show GravityHint
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> GravityHint -> ShowS
    showsPrec :: Int -> GravityHint -> ShowS
    $cshow :: GravityHint -> String
    show :: GravityHint -> String
    $cshowList :: [GravityHint] -> ShowS
    showList :: [GravityHint] -> ShowS
    Show, GravityHint -> GravityHint -> Bool
    (GravityHint -> GravityHint -> Bool)
    -> (GravityHint -> GravityHint -> Bool) -> Eq GravityHint
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GravityHint -> GravityHint -> Bool
    == :: GravityHint -> GravityHint -> Bool
    $c/= :: GravityHint -> GravityHint -> Bool
    /= :: GravityHint -> GravityHint -> Bool
    Eq)

    instance P.Enum GravityHint where
        fromEnum :: GravityHint -> Int
    fromEnum GravityHint
    GravityHintNatural = Int
    0
        fromEnum GravityHint
    GravityHintStrong = Int
    1
        fromEnum GravityHint
    GravityHintLine = Int
    2
        fromEnum (AnotherGravityHint Int
    k) = Int
    k

        toEnum :: Int -> GravityHint
    toEnum Int
    0 = GravityHint
    GravityHintNatural
        toEnum Int
    1 = GravityHint
    GravityHintStrong
        toEnum Int
    2 = GravityHint
    GravityHintLine
        toEnum Int
    k = Int -> GravityHint
    AnotherGravityHint Int
    k

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

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

    foreign import ccall "pango_gravity_hint_get_type" c_pango_gravity_hint_get_type ::
        IO GType

    instance B.Types.TypedObject GravityHint where
        glibType :: IO GType
    glibType = IO GType
    c_pango_gravity_hint_get_type

    instance B.Types.BoxedEnum GravityHint

    -- Enum Gravity
    -- | @PangoGravity@ represents the orientation of glyphs in a segment
    -- of text.
    --
    -- This is useful when rendering vertical text layouts. In those situations,
    -- the layout is rotated using a non-identity [struct/@pango@/.Matrix], and then
    -- glyph orientation is controlled using @PangoGravity@.
    --
    -- Not every value in this enumeration makes sense for every usage of
    -- @PangoGravity@; for example, 'GI.Pango.Enums.GravityAuto' only can be passed to
    -- 'GI.Pango.Objects.Context.contextSetBaseGravity' and can only be returned by
    -- 'GI.Pango.Objects.Context.contextGetBaseGravity'.
    --
    -- See also: t'GI.Pango.Enums.GravityHint'
    --
    -- /Since: 1.16/
    data Gravity =
          GravitySouth
        -- ^ Glyphs stand upright (default) \<img align=\"right\" valign=\"center\" src=\"m-south.png\">
        | GravityEast
        -- ^ Glyphs are rotated 90 degrees counter-clockwise. \<img align=\"right\" valign=\"center\" src=\"m-east.png\">
        | GravityNorth
        -- ^ Glyphs are upside-down. \<img align=\"right\" valign=\"cener\" src=\"m-north.png\">
        | GravityWest
        -- ^ Glyphs are rotated 90 degrees clockwise. \<img align=\"right\" valign=\"center\" src=\"m-west.png\">
        | GravityAuto
        -- ^ Gravity is resolved from the context matrix
        | AnotherGravity Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Gravity -> ShowS
    [Gravity] -> ShowS
    Gravity -> String
    (Int -> Gravity -> ShowS)
    -> (Gravity -> String) -> ([Gravity] -> ShowS) -> Show Gravity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Gravity -> ShowS
    showsPrec :: Int -> Gravity -> ShowS
    $cshow :: Gravity -> String
    show :: Gravity -> String
    $cshowList :: [Gravity] -> ShowS
    showList :: [Gravity] -> ShowS
    Show, Gravity -> Gravity -> Bool
    (Gravity -> Gravity -> Bool)
    -> (Gravity -> Gravity -> Bool) -> Eq Gravity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Gravity -> Gravity -> Bool
    == :: Gravity -> Gravity -> Bool
    $c/= :: Gravity -> Gravity -> Bool
    /= :: Gravity -> Gravity -> Bool
    Eq)

    instance P.Enum Gravity where
        fromEnum :: Gravity -> Int
    fromEnum Gravity
    GravitySouth = Int
    0
        fromEnum Gravity
    GravityEast = Int
    1
        fromEnum Gravity
    GravityNorth = Int
    2
        fromEnum Gravity
    GravityWest = Int
    3
        fromEnum Gravity
    GravityAuto = Int
    4
        fromEnum (AnotherGravity Int
    k) = Int
    k

        toEnum :: Int -> Gravity
    toEnum Int
    0 = Gravity
    GravitySouth
        toEnum Int
    1 = Gravity
    GravityEast
        toEnum Int
    2 = Gravity
    GravityNorth
        toEnum Int
    3 = Gravity
    GravityWest
        toEnum Int
    4 = Gravity
    GravityAuto
        toEnum Int
    k = Int -> Gravity
    AnotherGravity Int
    k

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

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

    foreign import ccall "pango_gravity_get_type" c_pango_gravity_get_type ::
        IO GType

    instance B.Types.TypedObject Gravity where
        glibType :: IO GType
    glibType = IO GType
    c_pango_gravity_get_type

    instance B.Types.BoxedEnum Gravity

    -- Enum FontScale
    -- | An enumeration that affects font sizes for superscript
    -- and subscript positioning and for (emulated) Small Caps.
    --
    -- /Since: 1.50/
    data FontScale =
          FontScaleNone
        -- ^ Leave the font size unchanged
        | FontScaleSuperscript
        -- ^ Change the font to a size suitable for superscripts
        | FontScaleSubscript
        -- ^ Change the font to a size suitable for subscripts
        | FontScaleSmallCaps
        -- ^ Change the font to a size suitable for Small Caps
        | AnotherFontScale Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FontScale -> ShowS
    [FontScale] -> ShowS
    FontScale -> String
    (Int -> FontScale -> ShowS)
    -> (FontScale -> String)
    -> ([FontScale] -> ShowS)
    -> Show FontScale
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FontScale -> ShowS
    showsPrec :: Int -> FontScale -> ShowS
    $cshow :: FontScale -> String
    show :: FontScale -> String
    $cshowList :: [FontScale] -> ShowS
    showList :: [FontScale] -> ShowS
    Show, FontScale -> FontScale -> Bool
    (FontScale -> FontScale -> Bool)
    -> (FontScale -> FontScale -> Bool) -> Eq FontScale
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FontScale -> FontScale -> Bool
    == :: FontScale -> FontScale -> Bool
    $c/= :: FontScale -> FontScale -> Bool
    /= :: FontScale -> FontScale -> Bool
    Eq)

    instance P.Enum FontScale where
        fromEnum :: FontScale -> Int
    fromEnum FontScale
    FontScaleNone = Int
    0
        fromEnum FontScale
    FontScaleSuperscript = Int
    1
        fromEnum FontScale
    FontScaleSubscript = Int
    2
        fromEnum FontScale
    FontScaleSmallCaps = Int
    3
        fromEnum (AnotherFontScale Int
    k) = Int
    k

        toEnum :: Int -> FontScale
    toEnum Int
    0 = FontScale
    FontScaleNone
        toEnum Int
    1 = FontScale
    FontScaleSuperscript
        toEnum Int
    2 = FontScale
    FontScaleSubscript
        toEnum Int
    3 = FontScale
    FontScaleSmallCaps
        toEnum Int
    k = Int -> FontScale
    AnotherFontScale Int
    k

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

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

    foreign import ccall "pango_font_scale_get_type" c_pango_font_scale_get_type ::
        IO GType

    instance B.Types.TypedObject FontScale where
        glibType :: IO GType
    glibType = IO GType
    c_pango_font_scale_get_type

    instance B.Types.BoxedEnum FontScale

    -- Enum EllipsizeMode
    -- | @PangoEllipsizeMode@ describes what sort of ellipsization
    -- should be applied to text.
    --
    -- In the ellipsization process characters are removed from the
    -- text in order to make it fit to a given width and replaced
    -- with an ellipsis.
    data EllipsizeMode =
          EllipsizeModeNone
        -- ^ No ellipsization
        | EllipsizeModeStart
        -- ^ Omit characters at the start of the text
        | EllipsizeModeMiddle
        -- ^ Omit characters in the middle of the text
        | EllipsizeModeEnd
        -- ^ Omit characters at the end of the text
        | AnotherEllipsizeMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EllipsizeMode -> ShowS
    [EllipsizeMode] -> ShowS
    EllipsizeMode -> String
    (Int -> EllipsizeMode -> ShowS)
    -> (EllipsizeMode -> String)
    -> ([EllipsizeMode] -> ShowS)
    -> Show EllipsizeMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EllipsizeMode -> ShowS
    showsPrec :: Int -> EllipsizeMode -> ShowS
    $cshow :: EllipsizeMode -> String
    show :: EllipsizeMode -> String
    $cshowList :: [EllipsizeMode] -> ShowS
    showList :: [EllipsizeMode] -> ShowS
    Show, EllipsizeMode -> EllipsizeMode -> Bool
    (EllipsizeMode -> EllipsizeMode -> Bool)
    -> (EllipsizeMode -> EllipsizeMode -> Bool) -> Eq EllipsizeMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EllipsizeMode -> EllipsizeMode -> Bool
    == :: EllipsizeMode -> EllipsizeMode -> Bool
    $c/= :: EllipsizeMode -> EllipsizeMode -> Bool
    /= :: EllipsizeMode -> EllipsizeMode -> Bool
    Eq)

    instance P.Enum EllipsizeMode where
        fromEnum :: EllipsizeMode -> Int
    fromEnum EllipsizeMode
    EllipsizeModeNone = Int
    0
        fromEnum EllipsizeMode
    EllipsizeModeStart = Int
    1
        fromEnum EllipsizeMode
    EllipsizeModeMiddle = Int
    2
        fromEnum EllipsizeMode
    EllipsizeModeEnd = Int
    3
        fromEnum (AnotherEllipsizeMode Int
    k) = Int
    k

        toEnum :: Int -> EllipsizeMode
    toEnum Int
    0 = EllipsizeMode
    EllipsizeModeNone
        toEnum Int
    1 = EllipsizeMode
    EllipsizeModeStart
        toEnum Int
    2 = EllipsizeMode
    EllipsizeModeMiddle
        toEnum Int
    3 = EllipsizeMode
    EllipsizeModeEnd
        toEnum Int
    k = Int -> EllipsizeMode
    AnotherEllipsizeMode Int
    k

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

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

    foreign import ccall "pango_ellipsize_mode_get_type" c_pango_ellipsize_mode_get_type ::
        IO GType

    instance B.Types.TypedObject EllipsizeMode where
        glibType :: IO GType
    glibType = IO GType
    c_pango_ellipsize_mode_get_type

    instance B.Types.BoxedEnum EllipsizeMode

    -- Enum Direction
    -- | @PangoDirection@ represents a direction in the Unicode bidirectional
    -- algorithm.
    --
    -- Not every value in this enumeration makes sense for every usage of
    -- @PangoDirection@; for example, the return value of [func/@unicharDirection@/]
    -- and [func/@findBaseDir@/] cannot be @PANGO_DIRECTION_WEAK_LTR@ or
    -- @PANGO_DIRECTION_WEAK_RTL@, since every character is either neutral
    -- or has a strong direction; on the other hand @PANGO_DIRECTION_NEUTRAL@
    -- doesn\'t make sense to pass to [func/@itemizeWithBaseDir@/].
    --
    -- The @PANGO_DIRECTION_TTB_LTR@, @PANGO_DIRECTION_TTB_RTL@ values come from
    -- an earlier interpretation of this enumeration as the writing direction
    -- of a block of text and are no longer used. See @PangoGravity@ for how
    -- vertical text is handled in Pango.
    --
    -- If you are interested in text direction, you should really use fribidi
    -- directly. @PangoDirection@ is only retained because it is used in some
    -- public apis.
    data Direction =
          DirectionLtr
        -- ^ A strong left-to-right direction
        | DirectionRtl
        -- ^ A strong right-to-left direction
        | DirectionTtbLtr
        -- ^ Deprecated value; treated the
        --   same as @PANGO_DIRECTION_RTL@.
        | DirectionTtbRtl
        -- ^ Deprecated value; treated the
        --   same as @PANGO_DIRECTION_LTR@
        | DirectionWeakLtr
        -- ^ A weak left-to-right direction
        | DirectionWeakRtl
        -- ^ A weak right-to-left direction
        | DirectionNeutral
        -- ^ No direction specified
        | AnotherDirection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Direction -> ShowS
    [Direction] -> ShowS
    Direction -> String
    (Int -> Direction -> ShowS)
    -> (Direction -> String)
    -> ([Direction] -> ShowS)
    -> Show Direction
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Direction -> ShowS
    showsPrec :: Int -> Direction -> ShowS
    $cshow :: Direction -> String
    show :: Direction -> String
    $cshowList :: [Direction] -> ShowS
    showList :: [Direction] -> ShowS
    Show, Direction -> Direction -> Bool
    (Direction -> Direction -> Bool)
    -> (Direction -> Direction -> Bool) -> Eq Direction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Direction -> Direction -> Bool
    == :: Direction -> Direction -> Bool
    $c/= :: Direction -> Direction -> Bool
    /= :: Direction -> Direction -> Bool
    Eq)

    instance P.Enum Direction where
        fromEnum :: Direction -> Int
    fromEnum Direction
    DirectionLtr = Int
    0
        fromEnum Direction
    DirectionRtl = Int
    1
        fromEnum Direction
    DirectionTtbLtr = Int
    2
        fromEnum Direction
    DirectionTtbRtl = Int
    3
        fromEnum Direction
    DirectionWeakLtr = Int
    4
        fromEnum Direction
    DirectionWeakRtl = Int
    5
        fromEnum Direction
    DirectionNeutral = Int
    6
        fromEnum (AnotherDirection Int
    k) = Int
    k

        toEnum :: Int -> Direction
    toEnum Int
    0 = Direction
    DirectionLtr
        toEnum Int
    1 = Direction
    DirectionRtl
        toEnum Int
    2 = Direction
    DirectionTtbLtr
        toEnum Int
    3 = Direction
    DirectionTtbRtl
        toEnum Int
    4 = Direction
    DirectionWeakLtr
        toEnum Int
    5 = Direction
    DirectionWeakRtl
        toEnum Int
    6 = Direction
    DirectionNeutral
        toEnum Int
    k = Int -> Direction
    AnotherDirection Int
    k

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

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

    foreign import ccall "pango_direction_get_type" c_pango_direction_get_type ::
        IO GType

    instance B.Types.TypedObject Direction where
        glibType :: IO GType
    glibType = IO GType
    c_pango_direction_get_type

    instance B.Types.BoxedEnum Direction

    -- Enum CoverageLevel
    -- | @PangoCoverageLevel@ is used to indicate how well a font can
    -- represent a particular Unicode character for a particular script.
    --
    -- Since 1.44, only 'GI.Pango.Enums.CoverageLevelNone' and 'GI.Pango.Enums.CoverageLevelExact'
    -- will be returned.
    data CoverageLevel =
          CoverageLevelNone
        -- ^ The character is not representable with
        --   the font.
        | CoverageLevelFallback
        -- ^ The character is represented in a
        --   way that may be comprehensible but is not the correct
        --   graphical form. For instance, a Hangul character represented
        --   as a a sequence of Jamos, or a Latin transliteration of a
        --   Cyrillic word.
        | CoverageLevelApproximate
        -- ^ The character is represented as
        --   basically the correct graphical form, but with a stylistic
        --   variant inappropriate for the current script.
        | CoverageLevelExact
        -- ^ The character is represented as the
        --   correct graphical form.
        | AnotherCoverageLevel Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CoverageLevel -> ShowS
    [CoverageLevel] -> ShowS
    CoverageLevel -> String
    (Int -> CoverageLevel -> ShowS)
    -> (CoverageLevel -> String)
    -> ([CoverageLevel] -> ShowS)
    -> Show CoverageLevel
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CoverageLevel -> ShowS
    showsPrec :: Int -> CoverageLevel -> ShowS
    $cshow :: CoverageLevel -> String
    show :: CoverageLevel -> String
    $cshowList :: [CoverageLevel] -> ShowS
    showList :: [CoverageLevel] -> ShowS
    Show, CoverageLevel -> CoverageLevel -> Bool
    (CoverageLevel -> CoverageLevel -> Bool)
    -> (CoverageLevel -> CoverageLevel -> Bool) -> Eq CoverageLevel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CoverageLevel -> CoverageLevel -> Bool
    == :: CoverageLevel -> CoverageLevel -> Bool
    $c/= :: CoverageLevel -> CoverageLevel -> Bool
    /= :: CoverageLevel -> CoverageLevel -> Bool
    Eq)

    instance P.Enum CoverageLevel where
        fromEnum :: CoverageLevel -> Int
    fromEnum CoverageLevel
    CoverageLevelNone = Int
    0
        fromEnum CoverageLevel
    CoverageLevelFallback = Int
    1
        fromEnum CoverageLevel
    CoverageLevelApproximate = Int
    2
        fromEnum CoverageLevel
    CoverageLevelExact = Int
    3
        fromEnum (AnotherCoverageLevel Int
    k) = Int
    k

        toEnum :: Int -> CoverageLevel
    toEnum Int
    0 = CoverageLevel
    CoverageLevelNone
        toEnum Int
    1 = CoverageLevel
    CoverageLevelFallback
        toEnum Int
    2 = CoverageLevel
    CoverageLevelApproximate
        toEnum Int
    3 = CoverageLevel
    CoverageLevelExact
        toEnum Int
    k = Int -> CoverageLevel
    AnotherCoverageLevel Int
    k

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

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

    foreign import ccall "pango_coverage_level_get_type" c_pango_coverage_level_get_type ::
        IO GType

    instance B.Types.TypedObject CoverageLevel where
        glibType :: IO GType
    glibType = IO GType
    c_pango_coverage_level_get_type

    instance B.Types.BoxedEnum CoverageLevel

    -- Enum BidiType
    {-# DEPRECATED BidiType ["(Since version 1.44)","Use fribidi for this information"] #-}
    -- | @PangoBidiType@ represents the bidirectional character
    -- type of a Unicode character.
    --
    -- The values in this enumeration are specified by the
    -- <http://www.unicode.org/reports/tr9/ Unicode bidirectional algorithm>.
    --
    -- /Since: 1.22/
    data BidiType =
          BidiTypeL
        -- ^ Left-to-Right
        | BidiTypeLre
        -- ^ Left-to-Right Embedding
        | BidiTypeLro
        -- ^ Left-to-Right Override
        | BidiTypeR
        -- ^ Right-to-Left
        | BidiTypeAl
        -- ^ Right-to-Left Arabic
        | BidiTypeRle
        -- ^ Right-to-Left Embedding
        | BidiTypeRlo
        -- ^ Right-to-Left Override
        | BidiTypePdf
        -- ^ Pop Directional Format
        | BidiTypeEn
        -- ^ European Number
        | BidiTypeEs
        -- ^ European Number Separator
        | BidiTypeEt
        -- ^ European Number Terminator
        | BidiTypeAn
        -- ^ Arabic Number
        | BidiTypeCs
        -- ^ Common Number Separator
        | BidiTypeNsm
        -- ^ Nonspacing Mark
        | BidiTypeBn
        -- ^ Boundary Neutral
        | BidiTypeB
        -- ^ Paragraph Separator
        | BidiTypeS
        -- ^ Segment Separator
        | BidiTypeWs
        -- ^ Whitespace
        | BidiTypeOn
        -- ^ Other Neutrals
        | BidiTypeLri
        -- ^ Left-to-Right isolate. Since 1.48.6
        | BidiTypeRli
        -- ^ Right-to-Left isolate. Since 1.48.6
        | BidiTypeFsi
        -- ^ First strong isolate. Since 1.48.6
        | BidiTypePdi
        -- ^ Pop directional isolate. Since 1.48.6
        | AnotherBidiType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BidiType -> ShowS
    [BidiType] -> ShowS
    BidiType -> String
    (Int -> BidiType -> ShowS)
    -> (BidiType -> String) -> ([BidiType] -> ShowS) -> Show BidiType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BidiType -> ShowS
    showsPrec :: Int -> BidiType -> ShowS
    $cshow :: BidiType -> String
    show :: BidiType -> String
    $cshowList :: [BidiType] -> ShowS
    showList :: [BidiType] -> ShowS
    Show, BidiType -> BidiType -> Bool
    (BidiType -> BidiType -> Bool)
    -> (BidiType -> BidiType -> Bool) -> Eq BidiType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BidiType -> BidiType -> Bool
    == :: BidiType -> BidiType -> Bool
    $c/= :: BidiType -> BidiType -> Bool
    /= :: BidiType -> BidiType -> Bool
    Eq)

    instance P.Enum BidiType where
        fromEnum :: BidiType -> Int
    fromEnum BidiType
    BidiTypeL = Int
    0
        fromEnum BidiType
    BidiTypeLre = Int
    1
        fromEnum BidiType
    BidiTypeLro = Int
    2
        fromEnum BidiType
    BidiTypeR = Int
    3
        fromEnum BidiType
    BidiTypeAl = Int
    4
        fromEnum BidiType
    BidiTypeRle = Int
    5
        fromEnum BidiType
    BidiTypeRlo = Int
    6
        fromEnum BidiType
    BidiTypePdf = Int
    7
        fromEnum BidiType
    BidiTypeEn = Int
    8
        fromEnum BidiType
    BidiTypeEs = Int
    9
        fromEnum BidiType
    BidiTypeEt = Int
    10
        fromEnum BidiType
    BidiTypeAn = Int
    11
        fromEnum BidiType
    BidiTypeCs = Int
    12
        fromEnum BidiType
    BidiTypeNsm = Int
    13
        fromEnum BidiType
    BidiTypeBn = Int
    14
        fromEnum BidiType
    BidiTypeB = Int
    15
        fromEnum BidiType
    BidiTypeS = Int
    16
        fromEnum BidiType
    BidiTypeWs = Int
    17
        fromEnum BidiType
    BidiTypeOn = Int
    18
        fromEnum BidiType
    BidiTypeLri = Int
    19
        fromEnum BidiType
    BidiTypeRli = Int
    20
        fromEnum BidiType
    BidiTypeFsi = Int
    21
        fromEnum BidiType
    BidiTypePdi = Int
    22
        fromEnum (AnotherBidiType Int
    k) = Int
    k

        toEnum :: Int -> BidiType
    toEnum Int
    0 = BidiType
    BidiTypeL
        toEnum Int
    1 = BidiType
    BidiTypeLre
        toEnum Int
    2 = BidiType
    BidiTypeLro
        toEnum Int
    3 = BidiType
    BidiTypeR
        toEnum Int
    4 = BidiType
    BidiTypeAl
        toEnum Int
    5 = BidiType
    BidiTypeRle
        toEnum Int
    6 = BidiType
    BidiTypeRlo
        toEnum Int
    7 = BidiType
    BidiTypePdf
        toEnum Int
    8 = BidiType
    BidiTypeEn
        toEnum Int
    9 = BidiType
    BidiTypeEs
        toEnum Int
    10 = BidiType
    BidiTypeEt
        toEnum Int
    11 = BidiType
    BidiTypeAn
        toEnum Int
    12 = BidiType
    BidiTypeCs
        toEnum Int
    13 = BidiType
    BidiTypeNsm
        toEnum Int
    14 = BidiType
    BidiTypeBn
        toEnum Int
    15 = BidiType
    BidiTypeB
        toEnum Int
    16 = BidiType
    BidiTypeS
        toEnum Int
    17 = BidiType
    BidiTypeWs
        toEnum Int
    18 = BidiType
    BidiTypeOn
        toEnum Int
    19 = BidiType
    BidiTypeLri
        toEnum Int
    20 = BidiType
    BidiTypeRli
        toEnum Int
    21 = BidiType
    BidiTypeFsi
        toEnum Int
    22 = BidiType
    BidiTypePdi
        toEnum Int
    k = Int -> BidiType
    AnotherBidiType Int
    k

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

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

    foreign import ccall "pango_bidi_type_get_type" c_pango_bidi_type_get_type ::
        IO GType

    instance B.Types.TypedObject BidiType where
        glibType :: IO GType
    glibType = IO GType
    c_pango_bidi_type_get_type

    instance B.Types.BoxedEnum BidiType

    -- Enum BaselineShift
    -- | An enumeration that affects baseline shifts between runs.
    --
    -- /Since: 1.50/
    data BaselineShift =
          BaselineShiftNone
        -- ^ Leave the baseline unchanged
        | BaselineShiftSuperscript
        -- ^ Shift the baseline to the superscript position,
        --   relative to the previous run
        | BaselineShiftSubscript
        -- ^ Shift the baseline to the subscript position,
        --   relative to the previous run
        | AnotherBaselineShift Int
        -- ^ Catch-all for unknown values
        deriving (Int -> BaselineShift -> ShowS
    [BaselineShift] -> ShowS
    BaselineShift -> String
    (Int -> BaselineShift -> ShowS)
    -> (BaselineShift -> String)
    -> ([BaselineShift] -> ShowS)
    -> Show BaselineShift
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BaselineShift -> ShowS
    showsPrec :: Int -> BaselineShift -> ShowS
    $cshow :: BaselineShift -> String
    show :: BaselineShift -> String
    $cshowList :: [BaselineShift] -> ShowS
    showList :: [BaselineShift] -> ShowS
    Show, BaselineShift -> BaselineShift -> Bool
    (BaselineShift -> BaselineShift -> Bool)
    -> (BaselineShift -> BaselineShift -> Bool) -> Eq BaselineShift
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BaselineShift -> BaselineShift -> Bool
    == :: BaselineShift -> BaselineShift -> Bool
    $c/= :: BaselineShift -> BaselineShift -> Bool
    /= :: BaselineShift -> BaselineShift -> Bool
    Eq)

    instance P.Enum BaselineShift where
        fromEnum :: BaselineShift -> Int
    fromEnum BaselineShift
    BaselineShiftNone = Int
    0
        fromEnum BaselineShift
    BaselineShiftSuperscript = Int
    1
        fromEnum BaselineShift
    BaselineShiftSubscript = Int
    2
        fromEnum (AnotherBaselineShift Int
    k) = Int
    k

        toEnum :: Int -> BaselineShift
    toEnum Int
    0 = BaselineShift
    BaselineShiftNone
        toEnum Int
    1 = BaselineShift
    BaselineShiftSuperscript
        toEnum Int
    2 = BaselineShift
    BaselineShiftSubscript
        toEnum Int
    k = Int -> BaselineShift
    AnotherBaselineShift Int
    k

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

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

    foreign import ccall "pango_baseline_shift_get_type" c_pango_baseline_shift_get_type ::
        IO GType

    instance B.Types.TypedObject BaselineShift where
        glibType :: IO GType
    glibType = IO GType
    c_pango_baseline_shift_get_type

    instance B.Types.BoxedEnum BaselineShift

    -- Enum AttrType
    -- | The @PangoAttrType@ distinguishes between different types of attributes.
    --
    -- Along with the predefined values, it is possible to allocate additional
    -- values for custom attributes using @/AttrType.register/@. The predefined
    -- values are given below. The type of structure used to store the attribute is
    -- listed in parentheses after the description.
    data AttrType =
          AttrTypeInvalid
        -- ^ does not happen
        | AttrTypeLanguage
        -- ^ language ([struct/@pango@/.AttrLanguage])
        | AttrTypeFamily
        -- ^ font family name list ([struct/@pango@/.AttrString])
        | AttrTypeStyle
        -- ^ font slant style ([struct/@pango@/.AttrInt])
        | AttrTypeWeight
        -- ^ font weight ([struct/@pango@/.AttrInt])
        | AttrTypeVariant
        -- ^ font variant (normal or small caps) ([struct/@pango@/.AttrInt])
        | AttrTypeStretch
        -- ^ font stretch ([struct/@pango@/.AttrInt])
        | AttrTypeSize
        -- ^ font size in points scaled by 'GI.Pango.Constants.SCALE' ([struct/@pango@/.AttrInt])
        | AttrTypeFontDesc
        -- ^ font description ([struct/@pango@/.AttrFontDesc])
        | AttrTypeForeground
        -- ^ foreground color ([struct/@pango@/.AttrColor])
        | AttrTypeBackground
        -- ^ background color ([struct/@pango@/.AttrColor])
        | AttrTypeUnderline
        -- ^ whether the text has an underline ([struct/@pango@/.AttrInt])
        | AttrTypeStrikethrough
        -- ^ whether the text is struck-through ([struct/@pango@/.AttrInt])
        | AttrTypeRise
        -- ^ baseline displacement ([struct/@pango@/.AttrInt])
        | AttrTypeShape
        -- ^ shape ([struct/@pango@/.AttrShape])
        | AttrTypeScale
        -- ^ font size scale factor ([struct/@pango@/.AttrFloat])
        | AttrTypeFallback
        -- ^ whether fallback is enabled ([struct/@pango@/.AttrInt])
        | AttrTypeLetterSpacing
        -- ^ letter spacing ([struct/@pangoAttrInt@/])
        | AttrTypeUnderlineColor
        -- ^ underline color ([struct/@pango@/.AttrColor])
        | AttrTypeStrikethroughColor
        -- ^ strikethrough color ([struct/@pango@/.AttrColor])
        | AttrTypeAbsoluteSize
        -- ^ font size in pixels scaled by 'GI.Pango.Constants.SCALE' ([struct/@pango@/.AttrInt])
        | AttrTypeGravity
        -- ^ base text gravity ([struct/@pango@/.AttrInt])
        | AttrTypeGravityHint
        -- ^ gravity hint ([struct/@pango@/.AttrInt])
        | AttrTypeFontFeatures
        -- ^ OpenType font features ([struct/@pango@/.AttrFontFeatures]). Since 1.38
        | AttrTypeForegroundAlpha
        -- ^ foreground alpha ([struct/@pango@/.AttrInt]). Since 1.38
        | AttrTypeBackgroundAlpha
        -- ^ background alpha ([struct/@pango@/.AttrInt]). Since 1.38
        | AttrTypeAllowBreaks
        -- ^ whether breaks are allowed ([struct/@pango@/.AttrInt]). Since 1.44
        | AttrTypeShow
        -- ^ how to render invisible characters ([struct/@pango@/.AttrInt]). Since 1.44
        | AttrTypeInsertHyphens
        -- ^ whether to insert hyphens at intra-word line breaks ([struct/@pango@/.AttrInt]). Since 1.44
        | AttrTypeOverline
        -- ^ whether the text has an overline ([struct/@pango@/.AttrInt]). Since 1.46
        | AttrTypeOverlineColor
        -- ^ overline color ([struct/@pango@/.AttrColor]). Since 1.46
        | AttrTypeLineHeight
        -- ^ line height factor ([struct/@pango@/.AttrFloat]). Since: 1.50
        | AttrTypeAbsoluteLineHeight
        -- ^ line height ([struct/@pango@/.AttrInt]). Since: 1.50
        | AttrTypeTextTransform
        -- ^ /No description available in the introspection data./
        | AttrTypeWord
        -- ^ override segmentation to classify the range of the attribute as a single word ([struct/@pango@/.AttrInt]). Since 1.50
        | AttrTypeSentence
        -- ^ override segmentation to classify the range of the attribute as a single sentence ([struct/@pango@/.AttrInt]). Since 1.50
        | AttrTypeBaselineShift
        -- ^ baseline displacement ([struct/@pango@/.AttrInt]). Since 1.50
        | AttrTypeFontScale
        -- ^ font-relative size change ([struct/@pango@/.AttrInt]). Since 1.50
        | AnotherAttrType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AttrType -> ShowS
    [AttrType] -> ShowS
    AttrType -> String
    (Int -> AttrType -> ShowS)
    -> (AttrType -> String) -> ([AttrType] -> ShowS) -> Show AttrType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AttrType -> ShowS
    showsPrec :: Int -> AttrType -> ShowS
    $cshow :: AttrType -> String
    show :: AttrType -> String
    $cshowList :: [AttrType] -> ShowS
    showList :: [AttrType] -> ShowS
    Show, AttrType -> AttrType -> Bool
    (AttrType -> AttrType -> Bool)
    -> (AttrType -> AttrType -> Bool) -> Eq AttrType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AttrType -> AttrType -> Bool
    == :: AttrType -> AttrType -> Bool
    $c/= :: AttrType -> AttrType -> Bool
    /= :: AttrType -> AttrType -> Bool
    Eq)

    instance P.Enum AttrType where
        fromEnum :: AttrType -> Int
    fromEnum AttrType
    AttrTypeInvalid = Int
    0
        fromEnum AttrType
    AttrTypeLanguage = Int
    1
        fromEnum AttrType
    AttrTypeFamily = Int
    2
        fromEnum AttrType
    AttrTypeStyle = Int
    3
        fromEnum AttrType
    AttrTypeWeight = Int
    4
        fromEnum AttrType
    AttrTypeVariant = Int
    5
        fromEnum AttrType
    AttrTypeStretch = Int
    6
        fromEnum AttrType
    AttrTypeSize = Int
    7
        fromEnum AttrType
    AttrTypeFontDesc = Int
    8
        fromEnum AttrType
    AttrTypeForeground = Int
    9
        fromEnum AttrType
    AttrTypeBackground = Int
    10
        fromEnum AttrType
    AttrTypeUnderline = Int
    11
        fromEnum AttrType
    AttrTypeStrikethrough = Int
    12
        fromEnum AttrType
    AttrTypeRise = Int
    13
        fromEnum AttrType
    AttrTypeShape = Int
    14
        fromEnum AttrType
    AttrTypeScale = Int
    15
        fromEnum AttrType
    AttrTypeFallback = Int
    16
        fromEnum AttrType
    AttrTypeLetterSpacing = Int
    17
        fromEnum AttrType
    AttrTypeUnderlineColor = Int
    18
        fromEnum AttrType
    AttrTypeStrikethroughColor = Int
    19
        fromEnum AttrType
    AttrTypeAbsoluteSize = Int
    20
        fromEnum AttrType
    AttrTypeGravity = Int
    21
        fromEnum AttrType
    AttrTypeGravityHint = Int
    22
        fromEnum AttrType
    AttrTypeFontFeatures = Int
    23
        fromEnum AttrType
    AttrTypeForegroundAlpha = Int
    24
        fromEnum AttrType
    AttrTypeBackgroundAlpha = Int
    25
        fromEnum AttrType
    AttrTypeAllowBreaks = Int
    26
        fromEnum AttrType
    AttrTypeShow = Int
    27
        fromEnum AttrType
    AttrTypeInsertHyphens = Int
    28
        fromEnum AttrType
    AttrTypeOverline = Int
    29
        fromEnum AttrType
    AttrTypeOverlineColor = Int
    30
        fromEnum AttrType
    AttrTypeLineHeight = Int
    31
        fromEnum AttrType
    AttrTypeAbsoluteLineHeight = Int
    32
        fromEnum AttrType
    AttrTypeTextTransform = Int
    33
        fromEnum AttrType
    AttrTypeWord = Int
    34
        fromEnum AttrType
    AttrTypeSentence = Int
    35
        fromEnum AttrType
    AttrTypeBaselineShift = Int
    36
        fromEnum AttrType
    AttrTypeFontScale = Int
    37
        fromEnum (AnotherAttrType Int
    k) = Int
    k

        toEnum :: Int -> AttrType
    toEnum Int
    0 = AttrType
    AttrTypeInvalid
        toEnum Int
    1 = AttrType
    AttrTypeLanguage
        toEnum Int
    2 = AttrType
    AttrTypeFamily
        toEnum Int
    3 = AttrType
    AttrTypeStyle
        toEnum Int
    4 = AttrType
    AttrTypeWeight
        toEnum Int
    5 = AttrType
    AttrTypeVariant
        toEnum Int
    6 = AttrType
    AttrTypeStretch
        toEnum Int
    7 = AttrType
    AttrTypeSize
        toEnum Int
    8 = AttrType
    AttrTypeFontDesc
        toEnum Int
    9 = AttrType
    AttrTypeForeground
        toEnum Int
    10 = AttrType
    AttrTypeBackground
        toEnum Int
    11 = AttrType
    AttrTypeUnderline
        toEnum Int
    12 = AttrType
    AttrTypeStrikethrough
        toEnum Int
    13 = AttrType
    AttrTypeRise
        toEnum Int
    14 = AttrType
    AttrTypeShape
        toEnum Int
    15 = AttrType
    AttrTypeScale
        toEnum Int
    16 = AttrType
    AttrTypeFallback
        toEnum Int
    17 = AttrType
    AttrTypeLetterSpacing
        toEnum Int
    18 = AttrType
    AttrTypeUnderlineColor
        toEnum Int
    19 = AttrType
    AttrTypeStrikethroughColor
        toEnum Int
    20 = AttrType
    AttrTypeAbsoluteSize
        toEnum Int
    21 = AttrType
    AttrTypeGravity
        toEnum Int
    22 = AttrType
    AttrTypeGravityHint
        toEnum Int
    23 = AttrType
    AttrTypeFontFeatures
        toEnum Int
    24 = AttrType
    AttrTypeForegroundAlpha
        toEnum Int
    25 = AttrType
    AttrTypeBackgroundAlpha
        toEnum Int
    26 = AttrType
    AttrTypeAllowBreaks
        toEnum Int
    27 = AttrType
    AttrTypeShow
        toEnum Int
    28 = AttrType
    AttrTypeInsertHyphens
        toEnum Int
    29 = AttrType
    AttrTypeOverline
        toEnum Int
    30 = AttrType
    AttrTypeOverlineColor
        toEnum Int
    31 = AttrType
    AttrTypeLineHeight
        toEnum Int
    32 = AttrType
    AttrTypeAbsoluteLineHeight
        toEnum Int
    33 = AttrType
    AttrTypeTextTransform
        toEnum Int
    34 = AttrType
    AttrTypeWord
        toEnum Int
    35 = AttrType
    AttrTypeSentence
        toEnum Int
    36 = AttrType
    AttrTypeBaselineShift
        toEnum Int
    37 = AttrType
    AttrTypeFontScale
        toEnum Int
    k = Int -> AttrType
    AnotherAttrType Int
    k

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

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

    foreign import ccall "pango_attr_type_get_type" c_pango_attr_type_get_type ::
        IO GType

    instance B.Types.TypedObject AttrType where
        glibType :: IO GType
    glibType = IO GType
    c_pango_attr_type_get_type

    instance B.Types.BoxedEnum AttrType

    -- Enum Alignment
    -- | @PangoAlignment@ describes how to align the lines of a @PangoLayout@
    -- within the available space.
    --
    -- If the @PangoLayout@ is set to justify using 'GI.Pango.Objects.Layout.layoutSetJustify',
    -- this only affects partial lines.
    --
    -- See 'GI.Pango.Objects.Layout.layoutSetAutoDir' for how text direction affects
    -- the interpretation of @PangoAlignment@ values.
    data Alignment =
          AlignmentLeft
        -- ^ Put all available space on the right
        | AlignmentCenter
        -- ^ Center the line within the available space
        | AlignmentRight
        -- ^ Put all available space on the left
        | AnotherAlignment Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Alignment -> ShowS
    [Alignment] -> ShowS
    Alignment -> String
    (Int -> Alignment -> ShowS)
    -> (Alignment -> String)
    -> ([Alignment] -> ShowS)
    -> Show Alignment
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Alignment -> ShowS
    showsPrec :: Int -> Alignment -> ShowS
    $cshow :: Alignment -> String
    show :: Alignment -> String
    $cshowList :: [Alignment] -> ShowS
    showList :: [Alignment] -> ShowS
    Show, Alignment -> Alignment -> Bool
    (Alignment -> Alignment -> Bool)
    -> (Alignment -> Alignment -> Bool) -> Eq Alignment
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Alignment -> Alignment -> Bool
    == :: Alignment -> Alignment -> Bool
    $c/= :: Alignment -> Alignment -> Bool
    /= :: Alignment -> Alignment -> Bool
    Eq)

    instance P.Enum Alignment where
        fromEnum :: Alignment -> Int
    fromEnum Alignment
    AlignmentLeft = Int
    0
        fromEnum Alignment
    AlignmentCenter = Int
    1
        fromEnum Alignment
    AlignmentRight = Int
    2
        fromEnum (AnotherAlignment Int
    k) = Int
    k

        toEnum :: Int -> Alignment
    toEnum Int
    0 = Alignment
    AlignmentLeft
        toEnum Int
    1 = Alignment
    AlignmentCenter
        toEnum Int
    2 = Alignment
    AlignmentRight
        toEnum Int
    k = Int -> Alignment
    AnotherAlignment Int
    k

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

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

    foreign import ccall "pango_alignment_get_type" c_pango_alignment_get_type ::
        IO GType

    instance B.Types.TypedObject Alignment where
        glibType :: IO GType
    glibType = IO GType
    c_pango_alignment_get_type

    instance B.Types.BoxedEnum Alignment