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

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

    module GI.Pango.Enums
        (

     -- * Enumerations
    -- ** Alignment #enum:Alignment#

        Alignment(..)                           ,

    -- ** AttrType #enum:AttrType#

        AttrType(..)                            ,

    -- ** BidiType #enum:BidiType#

        BidiType(..)                            ,

    -- ** CoverageLevel #enum:CoverageLevel#

        CoverageLevel(..)                       ,

    -- ** Direction #enum:Direction#

        Direction(..)                           ,

    -- ** EllipsizeMode #enum:EllipsizeMode#

        EllipsizeMode(..)                       ,

    -- ** Gravity #enum:Gravity#

        Gravity(..)                             ,

    -- ** GravityHint #enum:GravityHint#

        GravityHint(..)                         ,

    -- ** Overline #enum:Overline#

        Overline(..)                            ,

    -- ** RenderPart #enum:RenderPart#

        RenderPart(..)                          ,

    -- ** Script #enum:Script#

        Script(..)                              ,

    -- ** Stretch #enum:Stretch#

        Stretch(..)                             ,

    -- ** Style #enum:Style#

        Style(..)                               ,

    -- ** TabAlign #enum:TabAlign#

        TabAlign(..)                            ,

    -- ** 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.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    -- Enum WrapMode
    -- | A t'GI.Pango.Enums.WrapMode' describes how to wrap the lines of a t'GI.Pango.Objects.Layout.Layout' to the desired width.
    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
    showList :: [WrapMode] -> ShowS
    $cshowList :: [WrapMode] -> ShowS
    show :: WrapMode -> String
    $cshow :: WrapMode -> String
    showsPrec :: Int -> WrapMode -> ShowS
    $cshowsPrec :: Int -> WrapMode -> ShowS
    Show, WrapMode -> WrapMode -> Bool
    (WrapMode -> WrapMode -> Bool)
    -> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: WrapMode -> WrapMode -> Bool
    $c/= :: WrapMode -> WrapMode -> Bool
    == :: WrapMode -> WrapMode -> Bool
    $c== :: WrapMode -> WrapMode -> Bool
    Eq)

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

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

    instance P.Ord WrapMode where
        compare :: WrapMode -> WrapMode -> Ordering
    compare a :: WrapMode
    a b :: 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. This is a numerical
    -- value ranging from 100 to 1000, but there are some 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 normal 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
    showList :: [Weight] -> ShowS
    $cshowList :: [Weight] -> ShowS
    show :: Weight -> String
    $cshow :: Weight -> String
    showsPrec :: Int -> Weight -> ShowS
    $cshowsPrec :: Int -> Weight -> ShowS
    Show, Weight -> Weight -> Bool
    (Weight -> Weight -> Bool)
    -> (Weight -> Weight -> Bool) -> Eq Weight
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Weight -> Weight -> Bool
    $c/= :: Weight -> Weight -> Bool
    == :: Weight -> Weight -> Bool
    $c== :: Weight -> Weight -> Bool
    Eq)

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

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

    instance P.Ord Weight where
        compare :: Weight -> Weight -> Ordering
    compare a :: Weight
    a b :: 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.
        | 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
    showList :: [Variant] -> ShowS
    $cshowList :: [Variant] -> ShowS
    show :: Variant -> String
    $cshow :: Variant -> String
    showsPrec :: Int -> Variant -> ShowS
    $cshowsPrec :: Int -> Variant -> ShowS
    Show, Variant -> Variant -> Bool
    (Variant -> Variant -> Bool)
    -> (Variant -> Variant -> Bool) -> Eq Variant
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Variant -> Variant -> Bool
    $c/= :: Variant -> Variant -> Bool
    == :: Variant -> Variant -> Bool
    $c== :: Variant -> Variant -> Bool
    Eq)

    instance P.Enum Variant where
        fromEnum :: Variant -> Int
    fromEnum VariantNormal = 0
        fromEnum VariantSmallCaps = 1
        fromEnum (AnotherVariant k :: Int
    k) = Int
    k

        toEnum :: Int -> Variant
    toEnum 0 = Variant
    VariantNormal
        toEnum 1 = Variant
    VariantSmallCaps
        toEnum k :: Int
    k = Int -> Variant
    AnotherVariant Int
    k

    instance P.Ord Variant where
        compare :: Variant -> Variant -> Ordering
    compare a :: Variant
    a b :: 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 t'GI.Pango.Enums.Underline' 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
        -- ^ a wavy underline should be drawn below.
        --     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
    showList :: [Underline] -> ShowS
    $cshowList :: [Underline] -> ShowS
    show :: Underline -> String
    $cshow :: Underline -> String
    showsPrec :: Int -> Underline -> ShowS
    $cshowsPrec :: Int -> Underline -> ShowS
    Show, Underline -> Underline -> Bool
    (Underline -> Underline -> Bool)
    -> (Underline -> Underline -> Bool) -> Eq Underline
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Underline -> Underline -> Bool
    $c/= :: Underline -> Underline -> Bool
    == :: Underline -> Underline -> Bool
    $c== :: Underline -> Underline -> Bool
    Eq)

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

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

    instance P.Ord Underline where
        compare :: Underline -> Underline -> Ordering
    compare a :: Underline
    a b :: 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 TabAlign
    -- | A t'GI.Pango.Enums.TabAlign' specifies where a tab stop appears relative to the text.
    data TabAlign =
          TabAlignLeft
        -- ^ the tab stop appears to the left of the text.
        | 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
    showList :: [TabAlign] -> ShowS
    $cshowList :: [TabAlign] -> ShowS
    show :: TabAlign -> String
    $cshow :: TabAlign -> String
    showsPrec :: Int -> TabAlign -> ShowS
    $cshowsPrec :: Int -> TabAlign -> ShowS
    Show, TabAlign -> TabAlign -> Bool
    (TabAlign -> TabAlign -> Bool)
    -> (TabAlign -> TabAlign -> Bool) -> Eq TabAlign
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TabAlign -> TabAlign -> Bool
    $c/= :: TabAlign -> TabAlign -> Bool
    == :: TabAlign -> TabAlign -> Bool
    $c== :: TabAlign -> TabAlign -> Bool
    Eq)

    instance P.Enum TabAlign where
        fromEnum :: TabAlign -> Int
    fromEnum TabAlignLeft = 0
        fromEnum (AnotherTabAlign k :: Int
    k) = Int
    k

        toEnum :: Int -> TabAlign
    toEnum 0 = TabAlign
    TabAlignLeft
        toEnum k :: Int
    k = Int -> TabAlign
    AnotherTabAlign Int
    k

    instance P.Ord TabAlign where
        compare :: TabAlign -> TabAlign -> Ordering
    compare a :: TabAlign
    a b :: 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
    showList :: [Style] -> ShowS
    $cshowList :: [Style] -> ShowS
    show :: Style -> String
    $cshow :: Style -> String
    showsPrec :: Int -> Style -> ShowS
    $cshowsPrec :: Int -> Style -> ShowS
    Show, Style -> Style -> Bool
    (Style -> Style -> Bool) -> (Style -> Style -> Bool) -> Eq Style
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Style -> Style -> Bool
    $c/= :: Style -> Style -> Bool
    == :: Style -> Style -> Bool
    $c== :: Style -> Style -> Bool
    Eq)

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

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

    instance P.Ord Style where
        compare :: Style -> Style -> Ordering
    compare a :: Style
    a b :: 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
    showList :: [Stretch] -> ShowS
    $cshowList :: [Stretch] -> ShowS
    show :: Stretch -> String
    $cshow :: Stretch -> String
    showsPrec :: Int -> Stretch -> ShowS
    $cshowsPrec :: Int -> Stretch -> ShowS
    Show, Stretch -> Stretch -> Bool
    (Stretch -> Stretch -> Bool)
    -> (Stretch -> Stretch -> Bool) -> Eq Stretch
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Stretch -> Stretch -> Bool
    $c/= :: Stretch -> Stretch -> Bool
    == :: Stretch -> Stretch -> Bool
    $c== :: Stretch -> Stretch -> Bool
    Eq)

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

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

    instance P.Ord Stretch where
        compare :: Stretch -> Stretch -> Ordering
    compare a :: Stretch
    a b :: 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 t'GI.Pango.Enums.Script' enumeration identifies different writing
    -- systems. The values correspond to the names as defined in the
    -- Unicode standard. See \<ulink
    -- url=\"http:\/\/www.unicode.org\/reports\/tr24\/\">Unicode Standard Annex
    -- @/24/@: Script names\<\/ulink>.
    --
    -- 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 GUnicodeScript 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
    showList :: [Script] -> ShowS
    $cshowList :: [Script] -> ShowS
    show :: Script -> String
    $cshow :: Script -> String
    showsPrec :: Int -> Script -> ShowS
    $cshowsPrec :: Int -> Script -> ShowS
    Show, Script -> Script -> Bool
    (Script -> Script -> Bool)
    -> (Script -> Script -> Bool) -> Eq Script
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Script -> Script -> Bool
    $c/= :: Script -> Script -> Bool
    == :: Script -> Script -> Bool
    $c== :: Script -> Script -> Bool
    Eq)

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

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

    instance P.Ord Script where
        compare :: Script -> Script -> Ordering
    compare a :: Script
    a b :: 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
    -- | t'GI.Pango.Enums.RenderPart' 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
    showList :: [RenderPart] -> ShowS
    $cshowList :: [RenderPart] -> ShowS
    show :: RenderPart -> String
    $cshow :: RenderPart -> String
    showsPrec :: Int -> RenderPart -> ShowS
    $cshowsPrec :: Int -> RenderPart -> ShowS
    Show, RenderPart -> RenderPart -> Bool
    (RenderPart -> RenderPart -> Bool)
    -> (RenderPart -> RenderPart -> Bool) -> Eq RenderPart
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: RenderPart -> RenderPart -> Bool
    $c/= :: RenderPart -> RenderPart -> Bool
    == :: RenderPart -> RenderPart -> Bool
    $c== :: RenderPart -> RenderPart -> Bool
    Eq)

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

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

    instance P.Ord RenderPart where
        compare :: RenderPart -> RenderPart -> Ordering
    compare a :: RenderPart
    a b :: 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 t'GI.Pango.Enums.Overline' 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
    showList :: [Overline] -> ShowS
    $cshowList :: [Overline] -> ShowS
    show :: Overline -> String
    $cshow :: Overline -> String
    showsPrec :: Int -> Overline -> ShowS
    $cshowsPrec :: Int -> Overline -> ShowS
    Show, Overline -> Overline -> Bool
    (Overline -> Overline -> Bool)
    -> (Overline -> Overline -> Bool) -> Eq Overline
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Overline -> Overline -> Bool
    $c/= :: Overline -> Overline -> Bool
    == :: Overline -> Overline -> Bool
    $c== :: Overline -> Overline -> Bool
    Eq)

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

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

    instance P.Ord Overline where
        compare :: Overline -> Overline -> Ordering
    compare a :: Overline
    a b :: 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 GravityHint
    -- | The t'GI.Pango.Enums.GravityHint' defines how horizontal scripts should behave in a
    -- vertical context.  That is, English excerpt in a vertical paragraph for
    -- example.
    --
    -- See 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
    showList :: [GravityHint] -> ShowS
    $cshowList :: [GravityHint] -> ShowS
    show :: GravityHint -> String
    $cshow :: GravityHint -> String
    showsPrec :: Int -> GravityHint -> ShowS
    $cshowsPrec :: Int -> GravityHint -> ShowS
    Show, GravityHint -> GravityHint -> Bool
    (GravityHint -> GravityHint -> Bool)
    -> (GravityHint -> GravityHint -> Bool) -> Eq GravityHint
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: GravityHint -> GravityHint -> Bool
    $c/= :: GravityHint -> GravityHint -> Bool
    == :: GravityHint -> GravityHint -> Bool
    $c== :: GravityHint -> GravityHint -> Bool
    Eq)

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

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

    instance P.Ord GravityHint where
        compare :: GravityHint -> GravityHint -> Ordering
    compare a :: GravityHint
    a b :: 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
    -- | The t'GI.Pango.Enums.Gravity' type 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 PangoMatrix,
    -- and then glyph orientation is controlled using t'GI.Pango.Enums.Gravity'.
    -- Not every value in this enumeration makes sense for every usage of
    -- t'GI.Pango.Enums.Gravity'; 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)
        | GravityEast
        -- ^ Glyphs are rotated 90 degrees clockwise
        | GravityNorth
        -- ^ Glyphs are upside-down
        | GravityWest
        -- ^ Glyphs are rotated 90 degrees counter-clockwise
        | 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
    showList :: [Gravity] -> ShowS
    $cshowList :: [Gravity] -> ShowS
    show :: Gravity -> String
    $cshow :: Gravity -> String
    showsPrec :: Int -> Gravity -> ShowS
    $cshowsPrec :: Int -> Gravity -> ShowS
    Show, Gravity -> Gravity -> Bool
    (Gravity -> Gravity -> Bool)
    -> (Gravity -> Gravity -> Bool) -> Eq Gravity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Gravity -> Gravity -> Bool
    $c/= :: Gravity -> Gravity -> Bool
    == :: Gravity -> Gravity -> Bool
    $c== :: Gravity -> Gravity -> Bool
    Eq)

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

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

    instance P.Ord Gravity where
        compare :: Gravity -> Gravity -> Ordering
    compare a :: Gravity
    a b :: 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 EllipsizeMode
    -- | The t'GI.Pango.Enums.EllipsizeMode' type describes what sort of (if any)
    -- ellipsization should be applied to a line of 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
    showList :: [EllipsizeMode] -> ShowS
    $cshowList :: [EllipsizeMode] -> ShowS
    show :: EllipsizeMode -> String
    $cshow :: EllipsizeMode -> String
    showsPrec :: Int -> EllipsizeMode -> ShowS
    $cshowsPrec :: Int -> EllipsizeMode -> ShowS
    Show, EllipsizeMode -> EllipsizeMode -> Bool
    (EllipsizeMode -> EllipsizeMode -> Bool)
    -> (EllipsizeMode -> EllipsizeMode -> Bool) -> Eq EllipsizeMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: EllipsizeMode -> EllipsizeMode -> Bool
    $c/= :: EllipsizeMode -> EllipsizeMode -> Bool
    == :: EllipsizeMode -> EllipsizeMode -> Bool
    $c== :: EllipsizeMode -> EllipsizeMode -> Bool
    Eq)

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

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

    instance P.Ord EllipsizeMode where
        compare :: EllipsizeMode -> EllipsizeMode -> Ordering
    compare a :: EllipsizeMode
    a b :: 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
    -- | The t'GI.Pango.Enums.Direction' type represents a direction in the
    -- Unicode bidirectional algorithm; not every value in this
    -- enumeration makes sense for every usage of t'GI.Pango.Enums.Direction';
    -- for example, the return value of 'GI.Pango.Functions.unicharDirection'
    -- and 'GI.Pango.Functions.findBaseDir' cannot be 'GI.Pango.Enums.DirectionWeakLtr'
    -- or 'GI.Pango.Enums.DirectionWeakRtl', since every character is either
    -- neutral or has a strong direction; on the other hand
    -- 'GI.Pango.Enums.DirectionNeutral' doesn\'t make sense to pass
    -- to 'GI.Pango.Functions.itemizeWithBaseDir'.
    --
    -- The 'GI.Pango.Enums.DirectionTtbLtr', 'GI.Pango.Enums.DirectionTtbRtl'
    -- values come from an earlier interpretation of this
    -- enumeration as the writing direction of a block of
    -- text and are no longer used; See t'GI.Pango.Enums.Gravity' 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 'GI.Pango.Enums.DirectionRtl'.
        | DirectionTtbRtl
        -- ^ Deprecated value; treated the
        --   same as 'GI.Pango.Enums.DirectionLtr'
        | 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
    showList :: [Direction] -> ShowS
    $cshowList :: [Direction] -> ShowS
    show :: Direction -> String
    $cshow :: Direction -> String
    showsPrec :: Int -> Direction -> ShowS
    $cshowsPrec :: Int -> Direction -> ShowS
    Show, Direction -> Direction -> Bool
    (Direction -> Direction -> Bool)
    -> (Direction -> Direction -> Bool) -> Eq Direction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Direction -> Direction -> Bool
    $c/= :: Direction -> Direction -> Bool
    == :: Direction -> Direction -> Bool
    $c== :: Direction -> Direction -> Bool
    Eq)

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

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

    instance P.Ord Direction where
        compare :: Direction -> Direction -> Ordering
    compare a :: Direction
    a b :: 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
    -- | Used to indicate how well a font can represent a particular Unicode
    -- character point 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
    showList :: [CoverageLevel] -> ShowS
    $cshowList :: [CoverageLevel] -> ShowS
    show :: CoverageLevel -> String
    $cshow :: CoverageLevel -> String
    showsPrec :: Int -> CoverageLevel -> ShowS
    $cshowsPrec :: Int -> CoverageLevel -> ShowS
    Show, CoverageLevel -> CoverageLevel -> Bool
    (CoverageLevel -> CoverageLevel -> Bool)
    -> (CoverageLevel -> CoverageLevel -> Bool) -> Eq CoverageLevel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: CoverageLevel -> CoverageLevel -> Bool
    $c/= :: CoverageLevel -> CoverageLevel -> Bool
    == :: CoverageLevel -> CoverageLevel -> Bool
    $c== :: CoverageLevel -> CoverageLevel -> Bool
    Eq)

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

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

    instance P.Ord CoverageLevel where
        compare :: CoverageLevel -> CoverageLevel -> Ordering
    compare a :: CoverageLevel
    a b :: 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"] #-}
    -- | The t'GI.Pango.Enums.BidiType' type represents the bidirectional character
    -- type of a Unicode character as specified by the
    -- \<ulink url=\"http:\/\/www.unicode.org\/reports\/tr9\/\">Unicode bidirectional algorithm\<\/ulink>.
    --
    -- /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
        | 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
    showList :: [BidiType] -> ShowS
    $cshowList :: [BidiType] -> ShowS
    show :: BidiType -> String
    $cshow :: BidiType -> String
    showsPrec :: Int -> BidiType -> ShowS
    $cshowsPrec :: Int -> BidiType -> ShowS
    Show, BidiType -> BidiType -> Bool
    (BidiType -> BidiType -> Bool)
    -> (BidiType -> BidiType -> Bool) -> Eq BidiType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: BidiType -> BidiType -> Bool
    $c/= :: BidiType -> BidiType -> Bool
    == :: BidiType -> BidiType -> Bool
    $c== :: BidiType -> BidiType -> Bool
    Eq)

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

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

    instance P.Ord BidiType where
        compare :: BidiType -> BidiType -> Ordering
    compare a :: BidiType
    a b :: 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 AttrType
    -- | The t'GI.Pango.Enums.AttrType'
    -- distinguishes between different types of attributes. Along with the
    -- predefined values, it is possible to allocate additional values
    -- for custom attributes using 'GI.Pango.Functions.attrTypeRegister'. 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 (t'GI.Pango.Structs.AttrLanguage.AttrLanguage')
        | AttrTypeFamily
        -- ^ font family name list (t'GI.Pango.Structs.AttrString.AttrString')
        | AttrTypeStyle
        -- ^ font slant style (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeWeight
        -- ^ font weight (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeVariant
        -- ^ font variant (normal or small caps) (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeStretch
        -- ^ font stretch (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeSize
        -- ^ font size in points scaled by 'GI.Pango.Constants.SCALE' (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeFontDesc
        -- ^ font description (t'GI.Pango.Structs.AttrFontDesc.AttrFontDesc')
        | AttrTypeForeground
        -- ^ foreground color (t'GI.Pango.Structs.AttrColor.AttrColor')
        | AttrTypeBackground
        -- ^ background color (t'GI.Pango.Structs.AttrColor.AttrColor')
        | AttrTypeUnderline
        -- ^ whether the text has an underline (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeStrikethrough
        -- ^ whether the text is struck-through (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeRise
        -- ^ baseline displacement (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeShape
        -- ^ shape (t'GI.Pango.Structs.AttrShape.AttrShape')
        | AttrTypeScale
        -- ^ font size scale factor (t'GI.Pango.Structs.AttrFloat.AttrFloat')
        | AttrTypeFallback
        -- ^ whether fallback is enabled (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeLetterSpacing
        -- ^ letter spacing (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeUnderlineColor
        -- ^ underline color (t'GI.Pango.Structs.AttrColor.AttrColor')
        | AttrTypeStrikethroughColor
        -- ^ strikethrough color (t'GI.Pango.Structs.AttrColor.AttrColor')
        | AttrTypeAbsoluteSize
        -- ^ font size in pixels scaled by 'GI.Pango.Constants.SCALE' (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeGravity
        -- ^ base text gravity (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeGravityHint
        -- ^ gravity hint (t'GI.Pango.Structs.AttrInt.AttrInt')
        | AttrTypeFontFeatures
        -- ^ OpenType font features (t'GI.Pango.Structs.AttrString.AttrString'). Since 1.38
        | AttrTypeForegroundAlpha
        -- ^ foreground alpha (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.38
        | AttrTypeBackgroundAlpha
        -- ^ background alpha (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.38
        | AttrTypeAllowBreaks
        -- ^ whether breaks are allowed (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.44
        | AttrTypeShow
        -- ^ how to render invisible characters (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.44
        | AttrTypeInsertHyphens
        -- ^ whether to insert hyphens at intra-word line breaks (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.44
        | AttrTypeOverline
        -- ^ whether the text has an overline (t'GI.Pango.Structs.AttrInt.AttrInt'). Since 1.46
        | AttrTypeOverlineColor
        -- ^ overline color (t'GI.Pango.Structs.AttrColor.AttrColor'). Since 1.46
        | 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
    showList :: [AttrType] -> ShowS
    $cshowList :: [AttrType] -> ShowS
    show :: AttrType -> String
    $cshow :: AttrType -> String
    showsPrec :: Int -> AttrType -> ShowS
    $cshowsPrec :: Int -> AttrType -> ShowS
    Show, AttrType -> AttrType -> Bool
    (AttrType -> AttrType -> Bool)
    -> (AttrType -> AttrType -> Bool) -> Eq AttrType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AttrType -> AttrType -> Bool
    $c/= :: AttrType -> AttrType -> Bool
    == :: AttrType -> AttrType -> Bool
    $c== :: AttrType -> AttrType -> Bool
    Eq)

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

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

    instance P.Ord AttrType where
        compare :: AttrType -> AttrType -> Ordering
    compare a :: AttrType
    a b :: 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
    -- | A t'GI.Pango.Enums.Alignment' describes how to align the lines of a t'GI.Pango.Objects.Layout.Layout' within the
    -- available space. If the t'GI.Pango.Objects.Layout.Layout' is set to justify
    -- using 'GI.Pango.Objects.Layout.layoutSetJustify', this only has effect for partial lines.
    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
    showList :: [Alignment] -> ShowS
    $cshowList :: [Alignment] -> ShowS
    show :: Alignment -> String
    $cshow :: Alignment -> String
    showsPrec :: Int -> Alignment -> ShowS
    $cshowsPrec :: Int -> Alignment -> ShowS
    Show, Alignment -> Alignment -> Bool
    (Alignment -> Alignment -> Bool)
    -> (Alignment -> Alignment -> Bool) -> Eq Alignment
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Alignment -> Alignment -> Bool
    $c/= :: Alignment -> Alignment -> Bool
    == :: Alignment -> Alignment -> Bool
    $c== :: Alignment -> Alignment -> Bool
    Eq)

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

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

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