    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The @PangoAttribute@ structure represents the common portions of all
    -- attributes.
    --
    -- Particular types of attributes include this structure as their initial
    -- portion. The common portion of the attribute holds the range to which
    -- the value in the type-specific part of the attribute applies and should
    -- be initialized using 'GI.Pango.Structs.Attribute.attributeInit'. By default, an attribute
    -- will have an all-inclusive range of [0,@/G_MAXUINT/@].

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

    module GI.Pango.Structs.Attribute
        (

    -- * Exported types
        Attribute(..)                           ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [asColor]("GI.Pango.Structs.Attribute#g:method:asColor"), [asFloat]("GI.Pango.Structs.Attribute#g:method:asFloat"), [asFontDesc]("GI.Pango.Structs.Attribute#g:method:asFontDesc"), [asFontFeatures]("GI.Pango.Structs.Attribute#g:method:asFontFeatures"), [asInt]("GI.Pango.Structs.Attribute#g:method:asInt"), [asLanguage]("GI.Pango.Structs.Attribute#g:method:asLanguage"), [asShape]("GI.Pango.Structs.Attribute#g:method:asShape"), [asSize]("GI.Pango.Structs.Attribute#g:method:asSize"), [asString]("GI.Pango.Structs.Attribute#g:method:asString"), [copy]("GI.Pango.Structs.Attribute#g:method:copy"), [destroy]("GI.Pango.Structs.Attribute#g:method:destroy"), [equal]("GI.Pango.Structs.Attribute#g:method:equal"), [init]("GI.Pango.Structs.Attribute#g:method:init").
    --
    -- ==== Getters
    -- /None/.
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveAttributeMethod                  ,
    #endif

    -- ** asColor #method:asColor#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsColorMethodInfo              ,
    #endif
        attributeAsColor                        ,

    -- ** asFloat #method:asFloat#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsFloatMethodInfo              ,
    #endif
        attributeAsFloat                        ,

    -- ** asFontDesc #method:asFontDesc#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsFontDescMethodInfo           ,
    #endif
        attributeAsFontDesc                     ,

    -- ** asFontFeatures #method:asFontFeatures#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsFontFeaturesMethodInfo       ,
    #endif
        attributeAsFontFeatures                 ,

    -- ** asInt #method:asInt#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsIntMethodInfo                ,
    #endif
        attributeAsInt                          ,

    -- ** asLanguage #method:asLanguage#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsLanguageMethodInfo           ,
    #endif
        attributeAsLanguage                     ,

    -- ** asShape #method:asShape#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsShapeMethodInfo              ,
    #endif
        attributeAsShape                        ,

    -- ** asSize #method:asSize#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsSizeMethodInfo               ,
    #endif
        attributeAsSize                         ,

    -- ** asString #method:asString#

    #if defined(ENABLE_OVERLOADING)
        AttributeAsStringMethodInfo             ,
    #endif
        attributeAsString                       ,

    -- ** copy #method:copy#

    #if defined(ENABLE_OVERLOADING)
        AttributeCopyMethodInfo                 ,
    #endif
        attributeCopy                           ,

    -- ** destroy #method:destroy#

    #if defined(ENABLE_OVERLOADING)
        AttributeDestroyMethodInfo              ,
    #endif
        attributeDestroy                        ,

    -- ** equal #method:equal#

    #if defined(ENABLE_OVERLOADING)
        AttributeEqualMethodInfo                ,
    #endif
        attributeEqual                          ,

    -- ** init #method:init#

    #if defined(ENABLE_OVERLOADING)
        AttributeInitMethodInfo                 ,
    #endif
        attributeInit                           ,

     -- * Properties

    -- ** endIndex #attr:endIndex#
    -- | end index of the range (in bytes). The character at this index
    --   is not included in the range.

    #if defined(ENABLE_OVERLOADING)
        attribute_endIndex                      ,
    #endif
        getAttributeEndIndex                    ,
        setAttributeEndIndex                    ,

    -- ** klass #attr:klass#
    -- | the class structure holding information about the type of the attribute

    #if defined(ENABLE_OVERLOADING)
        attribute_klass                         ,
    #endif
        clearAttributeKlass                     ,
        getAttributeKlass                       ,
        setAttributeKlass                       ,

    -- ** startIndex #attr:startIndex#
    -- | the start index of the range (in bytes).

    #if defined(ENABLE_OVERLOADING)
        attribute_startIndex                    ,
    #endif
        getAttributeStartIndex                  ,
        setAttributeStartIndex                  ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R

    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrClass as Pango.AttrClass
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrColor as Pango.AttrColor
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFloat as Pango.AttrFloat
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFontDesc as Pango.AttrFontDesc
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrFontFeatures as Pango.AttrFontFeatures
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrInt as Pango.AttrInt
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrLanguage as Pango.AttrLanguage
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrShape as Pango.AttrShape
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrSize as Pango.AttrSize
    import {-# SOURCE #-} qualified GI.Pango.Structs.AttrString as Pango.AttrString

    -- | Memory-managed wrapper type.
    newtype Attribute = Attribute (SP.ManagedPtr Attribute)
        deriving (Attribute -> Attribute -> Bool
    (Attribute -> Attribute -> Bool)
    -> (Attribute -> Attribute -> Bool) -> Eq Attribute
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Attribute -> Attribute -> Bool
    == :: Attribute -> Attribute -> Bool
    $c/= :: Attribute -> Attribute -> Bool
    /= :: Attribute -> Attribute -> Bool
    Eq)

    instance SP.ManagedPtrNewtype Attribute where
        toManagedPtr :: Attribute -> ManagedPtr Attribute
    toManagedPtr (Attribute ManagedPtr Attribute
    p) = ManagedPtr Attribute
    p

    foreign import ccall "pango_attribute_get_type" c_pango_attribute_get_type ::
        IO GType

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

    instance B.Types.TypedObject Attribute where
        glibType :: IO GType
    glibType = IO GType
    c_pango_attribute_get_type

    instance B.Types.GBoxed Attribute

    -- | Convert 'Attribute' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe Attribute) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_pango_attribute_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Attribute -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Attribute
    P.Nothing = Ptr GValue -> Ptr Attribute -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr Attribute
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Attribute)
        gvalueSet_ Ptr GValue
    gv (P.Just Attribute
    obj) = Attribute -> (Ptr Attribute -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Attribute
    obj (Ptr GValue -> Ptr Attribute -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Attribute)
    gvalueGet_ Ptr GValue
    gv = do
            Ptr Attribute
    ptr <- Ptr GValue -> IO (Ptr Attribute)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr Attribute)
            if Ptr Attribute
    ptr Ptr Attribute -> Ptr Attribute -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Ptr Attribute
    forall a. Ptr a
    FP.nullPtr
            then Attribute -> Maybe Attribute
    forall a. a -> Maybe a
    P.Just (Attribute -> Maybe Attribute)
    -> IO Attribute -> IO (Maybe Attribute)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ManagedPtr Attribute -> Attribute)
    -> Ptr Attribute -> IO Attribute
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.newBoxed ManagedPtr Attribute -> Attribute
    Attribute Ptr Attribute
    ptr
            else Maybe Attribute -> IO (Maybe Attribute)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Attribute
    forall a. Maybe a
    P.Nothing

    -- | Get the value of the “@klass@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attribute #klass
    -- @
    getAttributeKlass :: MonadIO m => Attribute -> m (Maybe Pango.AttrClass.AttrClass)
    getAttributeKlass :: forall (m :: * -> *). MonadIO m => Attribute -> m (Maybe AttrClass)
    getAttributeKlass Attribute
    s = IO (Maybe AttrClass) -> m (Maybe AttrClass)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrClass) -> m (Maybe AttrClass))
    -> IO (Maybe AttrClass) -> m (Maybe AttrClass)
    forall a b. (a -> b) -> a -> b
    $ Attribute
    -> (Ptr Attribute -> IO (Maybe AttrClass)) -> IO (Maybe AttrClass)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Attribute
    s ((Ptr Attribute -> IO (Maybe AttrClass)) -> IO (Maybe AttrClass))
    -> (Ptr Attribute -> IO (Maybe AttrClass)) -> IO (Maybe AttrClass)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Attribute
    ptr -> do
        Ptr AttrClass
    val <- Ptr (Ptr AttrClass) -> IO (Ptr AttrClass)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Attribute
    ptr Ptr Attribute -> Int -> Ptr (Ptr AttrClass)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO (Ptr Pango.AttrClass.AttrClass)
        Maybe AttrClass
    result <- Ptr AttrClass
    -> (Ptr AttrClass -> IO AttrClass) -> IO (Maybe AttrClass)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    SP.convertIfNonNull Ptr AttrClass
    val ((Ptr AttrClass -> IO AttrClass) -> IO (Maybe AttrClass))
    -> (Ptr AttrClass -> IO AttrClass) -> IO (Maybe AttrClass)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrClass
    val' -> do
            AttrClass
    val'' <- ((ManagedPtr AttrClass -> AttrClass)
    -> Ptr AttrClass -> IO AttrClass
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrClass -> AttrClass
    Pango.AttrClass.AttrClass) Ptr AttrClass
    val'
            AttrClass -> IO AttrClass
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrClass
    val''
        Maybe AttrClass -> IO (Maybe AttrClass)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrClass
    result

    -- | Set the value of the “@klass@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' attribute [ #klass 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAttributeKlass :: MonadIO m => Attribute -> Ptr Pango.AttrClass.AttrClass -> m ()
    setAttributeKlass :: forall (m :: * -> *).
    MonadIO m =>
    Attribute -> Ptr AttrClass -> m ()
    setAttributeKlass Attribute
    s Ptr AttrClass
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Attribute -> (Ptr Attribute -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Attribute
    s ((Ptr Attribute -> IO ()) -> IO ())
    -> (Ptr Attribute -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Attribute
    ptr -> do
        Ptr (Ptr AttrClass) -> Ptr AttrClass -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Attribute
    ptr Ptr Attribute -> Int -> Ptr (Ptr AttrClass)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr AttrClass
    val :: Ptr Pango.AttrClass.AttrClass)

    -- | Set the value of the “@klass@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #klass
    -- @
    clearAttributeKlass :: MonadIO m => Attribute -> m ()
    clearAttributeKlass :: forall (m :: * -> *). MonadIO m => Attribute -> m ()
    clearAttributeKlass Attribute
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Attribute -> (Ptr Attribute -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Attribute
    s ((Ptr Attribute -> IO ()) -> IO ())
    -> (Ptr Attribute -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Attribute
    ptr -> do
        Ptr (Ptr AttrClass) -> Ptr AttrClass -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Attribute
    ptr Ptr Attribute -> Int -> Ptr (Ptr AttrClass)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (Ptr AttrClass
    forall a. Ptr a
    FP.nullPtr :: Ptr Pango.AttrClass.AttrClass)

    #if defined(ENABLE_OVERLOADING)
    data AttributeKlassFieldInfo
    instance AttrInfo AttributeKlassFieldInfo where
        type AttrBaseTypeConstraint AttributeKlassFieldInfo = (~) Attribute
        type AttrAllowedOps AttributeKlassFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint AttributeKlassFieldInfo = (~) (Ptr Pango.AttrClass.AttrClass)
        type AttrTransferTypeConstraint AttributeKlassFieldInfo = (~)(Ptr Pango.AttrClass.AttrClass)
        type AttrTransferType AttributeKlassFieldInfo = (Ptr Pango.AttrClass.AttrClass)
        type AttrGetType AttributeKlassFieldInfo = Maybe Pango.AttrClass.AttrClass
        type AttrLabel AttributeKlassFieldInfo = "klass"
        type AttrOrigin AttributeKlassFieldInfo = Attribute
        attrGet = getAttributeKlass
        attrSet = setAttributeKlass
        attrConstruct = undefined
        attrClear = clearAttributeKlass
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.klass"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#g:attr:klass"
            })

    attribute_klass :: AttrLabelProxy "klass"
    attribute_klass = AttrLabelProxy

    #endif

    -- | Get the value of the “@start_index@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attribute #startIndex
    -- @
    getAttributeStartIndex :: MonadIO m => Attribute -> m Word32
    getAttributeStartIndex :: forall (m :: * -> *). MonadIO m => Attribute -> m Word32
    getAttributeStartIndex Attribute
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ Attribute -> (Ptr Attribute -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Attribute
    s ((Ptr Attribute -> IO Word32) -> IO Word32)
    -> (Ptr Attribute -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr Attribute
    ptr -> do
        Word32
    val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Attribute
    ptr Ptr Attribute -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) :: IO Word32
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    val

    -- | Set the value of the “@start_index@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' attribute [ #startIndex 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAttributeStartIndex :: MonadIO m => Attribute -> Word32 -> m ()
    setAttributeStartIndex :: forall (m :: * -> *). MonadIO m => Attribute -> Word32 -> m ()
    setAttributeStartIndex Attribute
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Attribute -> (Ptr Attribute -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Attribute
    s ((Ptr Attribute -> IO ()) -> IO ())
    -> (Ptr Attribute -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Attribute
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Attribute
    ptr Ptr Attribute -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data AttributeStartIndexFieldInfo
    instance AttrInfo AttributeStartIndexFieldInfo where
        type AttrBaseTypeConstraint AttributeStartIndexFieldInfo = (~) Attribute
        type AttrAllowedOps AttributeStartIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint AttributeStartIndexFieldInfo = (~) Word32
        type AttrTransferTypeConstraint AttributeStartIndexFieldInfo = (~)Word32
        type AttrTransferType AttributeStartIndexFieldInfo = Word32
        type AttrGetType AttributeStartIndexFieldInfo = Word32
        type AttrLabel AttributeStartIndexFieldInfo = "start_index"
        type AttrOrigin AttributeStartIndexFieldInfo = Attribute
        attrGet = getAttributeStartIndex
        attrSet = setAttributeStartIndex
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.startIndex"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#g:attr:startIndex"
            })

    attribute_startIndex :: AttrLabelProxy "startIndex"
    attribute_startIndex = AttrLabelProxy

    #endif

    -- | Get the value of the “@end_index@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' attribute #endIndex
    -- @
    getAttributeEndIndex :: MonadIO m => Attribute -> m Word32
    getAttributeEndIndex :: forall (m :: * -> *). MonadIO m => Attribute -> m Word32
    getAttributeEndIndex Attribute
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ Attribute -> (Ptr Attribute -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Attribute
    s ((Ptr Attribute -> IO Word32) -> IO Word32)
    -> (Ptr Attribute -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr Attribute
    ptr -> do
        Word32
    val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Attribute
    ptr Ptr Attribute -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    12) :: IO Word32
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    val

    -- | Set the value of the “@end_index@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' attribute [ #endIndex 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAttributeEndIndex :: MonadIO m => Attribute -> Word32 -> m ()
    setAttributeEndIndex :: forall (m :: * -> *). MonadIO m => Attribute -> Word32 -> m ()
    setAttributeEndIndex Attribute
    s Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ Attribute -> (Ptr Attribute -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Attribute
    s ((Ptr Attribute -> IO ()) -> IO ())
    -> (Ptr Attribute -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Attribute
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Attribute
    ptr Ptr Attribute -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    12) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data AttributeEndIndexFieldInfo
    instance AttrInfo AttributeEndIndexFieldInfo where
        type AttrBaseTypeConstraint AttributeEndIndexFieldInfo = (~) Attribute
        type AttrAllowedOps AttributeEndIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint AttributeEndIndexFieldInfo = (~) Word32
        type AttrTransferTypeConstraint AttributeEndIndexFieldInfo = (~)Word32
        type AttrTransferType AttributeEndIndexFieldInfo = Word32
        type AttrGetType AttributeEndIndexFieldInfo = Word32
        type AttrLabel AttributeEndIndexFieldInfo = "end_index"
        type AttrOrigin AttributeEndIndexFieldInfo = Attribute
        attrGet = getAttributeEndIndex
        attrSet = setAttributeEndIndex
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.endIndex"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#g:attr:endIndex"
            })

    attribute_endIndex :: AttrLabelProxy "endIndex"
    attribute_endIndex = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Attribute
    type instance O.AttributeList Attribute = AttributeAttributeList
    type AttributeAttributeList = ('[ '("klass", AttributeKlassFieldInfo), '("startIndex", AttributeStartIndexFieldInfo), '("endIndex", AttributeEndIndexFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    -- method Attribute::as_color
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` such as foreground"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "AttrColor" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_color" pango_attribute_as_color ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrColor.AttrColor)

    -- | Returns the attribute cast to @PangoAttrColor@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsColor ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ such as foreground
        -> m (Maybe Pango.AttrColor.AttrColor)
        -- ^ __Returns:__ The attribute as @PangoAttrColor@,
        --   or 'P.Nothing' if it\'s not a color attribute
    attributeAsColor :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrColor)
    attributeAsColor Attribute
    attr = IO (Maybe AttrColor) -> m (Maybe AttrColor)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrColor) -> m (Maybe AttrColor))
    -> IO (Maybe AttrColor) -> m (Maybe AttrColor)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrColor
    result <- Ptr Attribute -> IO (Ptr AttrColor)
    pango_attribute_as_color Ptr Attribute
    attr'
        Maybe AttrColor
    maybeResult <- Ptr AttrColor
    -> (Ptr AttrColor -> IO AttrColor) -> IO (Maybe AttrColor)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrColor
    result ((Ptr AttrColor -> IO AttrColor) -> IO (Maybe AttrColor))
    -> (Ptr AttrColor -> IO AttrColor) -> IO (Maybe AttrColor)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrColor
    result' -> do
            AttrColor
    result'' <- ((ManagedPtr AttrColor -> AttrColor)
    -> Ptr AttrColor -> IO AttrColor
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrColor -> AttrColor
    Pango.AttrColor.AttrColor) Ptr AttrColor
    result'
            AttrColor -> IO AttrColor
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrColor
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrColor -> IO (Maybe AttrColor)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrColor
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsColorMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrColor.AttrColor)), MonadIO m) => O.OverloadedMethod AttributeAsColorMethodInfo Attribute signature where
        overloadedMethod = attributeAsColor

    instance O.OverloadedMethodInfo AttributeAsColorMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsColor",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsColor"
            })

    #endif

    -- method Attribute::as_float
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` such as scale"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "AttrFloat" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_float" pango_attribute_as_float ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrFloat.AttrFloat)

    -- | Returns the attribute cast to @PangoAttrFloat@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsFloat ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ such as scale
        -> m (Maybe Pango.AttrFloat.AttrFloat)
        -- ^ __Returns:__ The attribute as @PangoAttrFloat@,
        --   or 'P.Nothing' if it\'s not a floating point attribute
    attributeAsFloat :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrFloat)
    attributeAsFloat Attribute
    attr = IO (Maybe AttrFloat) -> m (Maybe AttrFloat)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrFloat) -> m (Maybe AttrFloat))
    -> IO (Maybe AttrFloat) -> m (Maybe AttrFloat)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrFloat
    result <- Ptr Attribute -> IO (Ptr AttrFloat)
    pango_attribute_as_float Ptr Attribute
    attr'
        Maybe AttrFloat
    maybeResult <- Ptr AttrFloat
    -> (Ptr AttrFloat -> IO AttrFloat) -> IO (Maybe AttrFloat)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrFloat
    result ((Ptr AttrFloat -> IO AttrFloat) -> IO (Maybe AttrFloat))
    -> (Ptr AttrFloat -> IO AttrFloat) -> IO (Maybe AttrFloat)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrFloat
    result' -> do
            AttrFloat
    result'' <- ((ManagedPtr AttrFloat -> AttrFloat)
    -> Ptr AttrFloat -> IO AttrFloat
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrFloat -> AttrFloat
    Pango.AttrFloat.AttrFloat) Ptr AttrFloat
    result'
            AttrFloat -> IO AttrFloat
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrFloat
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrFloat -> IO (Maybe AttrFloat)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrFloat
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsFloatMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrFloat.AttrFloat)), MonadIO m) => O.OverloadedMethod AttributeAsFloatMethodInfo Attribute signature where
        overloadedMethod = attributeAsFloat

    instance O.OverloadedMethodInfo AttributeAsFloatMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsFloat",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsFloat"
            })

    #endif

    -- method Attribute::as_font_desc
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "A `PangoAttribute` representing a font description"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Pango" , name = "AttrFontDesc" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_font_desc" pango_attribute_as_font_desc ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrFontDesc.AttrFontDesc)

    -- | Returns the attribute cast to @PangoAttrFontDesc@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsFontDesc ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ representing a font description
        -> m (Maybe Pango.AttrFontDesc.AttrFontDesc)
        -- ^ __Returns:__ The attribute as @PangoAttrFontDesc@,
        --   or 'P.Nothing' if it\'s not a font description attribute
    attributeAsFontDesc :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrFontDesc)
    attributeAsFontDesc Attribute
    attr = IO (Maybe AttrFontDesc) -> m (Maybe AttrFontDesc)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrFontDesc) -> m (Maybe AttrFontDesc))
    -> IO (Maybe AttrFontDesc) -> m (Maybe AttrFontDesc)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrFontDesc
    result <- Ptr Attribute -> IO (Ptr AttrFontDesc)
    pango_attribute_as_font_desc Ptr Attribute
    attr'
        Maybe AttrFontDesc
    maybeResult <- Ptr AttrFontDesc
    -> (Ptr AttrFontDesc -> IO AttrFontDesc) -> IO (Maybe AttrFontDesc)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrFontDesc
    result ((Ptr AttrFontDesc -> IO AttrFontDesc) -> IO (Maybe AttrFontDesc))
    -> (Ptr AttrFontDesc -> IO AttrFontDesc) -> IO (Maybe AttrFontDesc)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrFontDesc
    result' -> do
            AttrFontDesc
    result'' <- ((ManagedPtr AttrFontDesc -> AttrFontDesc)
    -> Ptr AttrFontDesc -> IO AttrFontDesc
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrFontDesc -> AttrFontDesc
    Pango.AttrFontDesc.AttrFontDesc) Ptr AttrFontDesc
    result'
            AttrFontDesc -> IO AttrFontDesc
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrFontDesc
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrFontDesc -> IO (Maybe AttrFontDesc)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrFontDesc
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsFontDescMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrFontDesc.AttrFontDesc)), MonadIO m) => O.OverloadedMethod AttributeAsFontDescMethodInfo Attribute signature where
        overloadedMethod = attributeAsFontDesc

    instance O.OverloadedMethodInfo AttributeAsFontDescMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsFontDesc",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsFontDesc"
            })

    #endif

    -- method Attribute::as_font_features
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` representing font features"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Pango" , name = "AttrFontFeatures" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_font_features" pango_attribute_as_font_features ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrFontFeatures.AttrFontFeatures)

    -- | Returns the attribute cast to @PangoAttrFontFeatures@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsFontFeatures ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ representing font features
        -> m (Maybe Pango.AttrFontFeatures.AttrFontFeatures)
        -- ^ __Returns:__ The attribute as @PangoAttrFontFeatures@,
        --   or 'P.Nothing' if it\'s not a font features attribute
    attributeAsFontFeatures :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrFontFeatures)
    attributeAsFontFeatures Attribute
    attr = IO (Maybe AttrFontFeatures) -> m (Maybe AttrFontFeatures)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrFontFeatures) -> m (Maybe AttrFontFeatures))
    -> IO (Maybe AttrFontFeatures) -> m (Maybe AttrFontFeatures)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrFontFeatures
    result <- Ptr Attribute -> IO (Ptr AttrFontFeatures)
    pango_attribute_as_font_features Ptr Attribute
    attr'
        Maybe AttrFontFeatures
    maybeResult <- Ptr AttrFontFeatures
    -> (Ptr AttrFontFeatures -> IO AttrFontFeatures)
    -> IO (Maybe AttrFontFeatures)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrFontFeatures
    result ((Ptr AttrFontFeatures -> IO AttrFontFeatures)
     -> IO (Maybe AttrFontFeatures))
    -> (Ptr AttrFontFeatures -> IO AttrFontFeatures)
    -> IO (Maybe AttrFontFeatures)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrFontFeatures
    result' -> do
            AttrFontFeatures
    result'' <- ((ManagedPtr AttrFontFeatures -> AttrFontFeatures)
    -> Ptr AttrFontFeatures -> IO AttrFontFeatures
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrFontFeatures -> AttrFontFeatures
    Pango.AttrFontFeatures.AttrFontFeatures) Ptr AttrFontFeatures
    result'
            AttrFontFeatures -> IO AttrFontFeatures
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrFontFeatures
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrFontFeatures -> IO (Maybe AttrFontFeatures)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrFontFeatures
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsFontFeaturesMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrFontFeatures.AttrFontFeatures)), MonadIO m) => O.OverloadedMethod AttributeAsFontFeaturesMethodInfo Attribute signature where
        overloadedMethod = attributeAsFontFeatures

    instance O.OverloadedMethodInfo AttributeAsFontFeaturesMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsFontFeatures",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsFontFeatures"
            })

    #endif

    -- method Attribute::as_int
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` such as weight"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "AttrInt" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_int" pango_attribute_as_int ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrInt.AttrInt)

    -- | Returns the attribute cast to @PangoAttrInt@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsInt ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ such as weight
        -> m (Maybe Pango.AttrInt.AttrInt)
        -- ^ __Returns:__ The attribute as @PangoAttrInt@,
        --   or 'P.Nothing' if it\'s not an integer attribute
    attributeAsInt :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrInt)
    attributeAsInt Attribute
    attr = IO (Maybe AttrInt) -> m (Maybe AttrInt)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrInt) -> m (Maybe AttrInt))
    -> IO (Maybe AttrInt) -> m (Maybe AttrInt)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrInt
    result <- Ptr Attribute -> IO (Ptr AttrInt)
    pango_attribute_as_int Ptr Attribute
    attr'
        Maybe AttrInt
    maybeResult <- Ptr AttrInt -> (Ptr AttrInt -> IO AttrInt) -> IO (Maybe AttrInt)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrInt
    result ((Ptr AttrInt -> IO AttrInt) -> IO (Maybe AttrInt))
    -> (Ptr AttrInt -> IO AttrInt) -> IO (Maybe AttrInt)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrInt
    result' -> do
            AttrInt
    result'' <- ((ManagedPtr AttrInt -> AttrInt) -> Ptr AttrInt -> IO AttrInt
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrInt -> AttrInt
    Pango.AttrInt.AttrInt) Ptr AttrInt
    result'
            AttrInt -> IO AttrInt
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrInt
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrInt -> IO (Maybe AttrInt)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrInt
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsIntMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrInt.AttrInt)), MonadIO m) => O.OverloadedMethod AttributeAsIntMethodInfo Attribute signature where
        overloadedMethod = attributeAsInt

    instance O.OverloadedMethodInfo AttributeAsIntMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsInt",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsInt"
            })

    #endif

    -- method Attribute::as_language
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` representing a language"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Pango" , name = "AttrLanguage" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_language" pango_attribute_as_language ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrLanguage.AttrLanguage)

    -- | Returns the attribute cast to @PangoAttrLanguage@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsLanguage ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ representing a language
        -> m (Maybe Pango.AttrLanguage.AttrLanguage)
        -- ^ __Returns:__ The attribute as @PangoAttrLanguage@,
        --   or 'P.Nothing' if it\'s not a language attribute
    attributeAsLanguage :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrLanguage)
    attributeAsLanguage Attribute
    attr = IO (Maybe AttrLanguage) -> m (Maybe AttrLanguage)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrLanguage) -> m (Maybe AttrLanguage))
    -> IO (Maybe AttrLanguage) -> m (Maybe AttrLanguage)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrLanguage
    result <- Ptr Attribute -> IO (Ptr AttrLanguage)
    pango_attribute_as_language Ptr Attribute
    attr'
        Maybe AttrLanguage
    maybeResult <- Ptr AttrLanguage
    -> (Ptr AttrLanguage -> IO AttrLanguage) -> IO (Maybe AttrLanguage)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrLanguage
    result ((Ptr AttrLanguage -> IO AttrLanguage) -> IO (Maybe AttrLanguage))
    -> (Ptr AttrLanguage -> IO AttrLanguage) -> IO (Maybe AttrLanguage)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrLanguage
    result' -> do
            AttrLanguage
    result'' <- ((ManagedPtr AttrLanguage -> AttrLanguage)
    -> Ptr AttrLanguage -> IO AttrLanguage
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrLanguage -> AttrLanguage
    Pango.AttrLanguage.AttrLanguage) Ptr AttrLanguage
    result'
            AttrLanguage -> IO AttrLanguage
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrLanguage
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrLanguage -> IO (Maybe AttrLanguage)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrLanguage
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsLanguageMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrLanguage.AttrLanguage)), MonadIO m) => O.OverloadedMethod AttributeAsLanguageMethodInfo Attribute signature where
        overloadedMethod = attributeAsLanguage

    instance O.OverloadedMethodInfo AttributeAsLanguageMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsLanguage",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsLanguage"
            })

    #endif

    -- method Attribute::as_shape
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` representing a shape"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "AttrShape" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_shape" pango_attribute_as_shape ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrShape.AttrShape)

    -- | Returns the attribute cast to @PangoAttrShape@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsShape ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ representing a shape
        -> m (Maybe Pango.AttrShape.AttrShape)
        -- ^ __Returns:__ The attribute as @PangoAttrShape@,
        --   or 'P.Nothing' if it\'s not a shape attribute
    attributeAsShape :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrShape)
    attributeAsShape Attribute
    attr = IO (Maybe AttrShape) -> m (Maybe AttrShape)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrShape) -> m (Maybe AttrShape))
    -> IO (Maybe AttrShape) -> m (Maybe AttrShape)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrShape
    result <- Ptr Attribute -> IO (Ptr AttrShape)
    pango_attribute_as_shape Ptr Attribute
    attr'
        Maybe AttrShape
    maybeResult <- Ptr AttrShape
    -> (Ptr AttrShape -> IO AttrShape) -> IO (Maybe AttrShape)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrShape
    result ((Ptr AttrShape -> IO AttrShape) -> IO (Maybe AttrShape))
    -> (Ptr AttrShape -> IO AttrShape) -> IO (Maybe AttrShape)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrShape
    result' -> do
            AttrShape
    result'' <- ((ManagedPtr AttrShape -> AttrShape)
    -> Ptr AttrShape -> IO AttrShape
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrShape -> AttrShape
    Pango.AttrShape.AttrShape) Ptr AttrShape
    result'
            AttrShape -> IO AttrShape
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrShape
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrShape -> IO (Maybe AttrShape)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrShape
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsShapeMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrShape.AttrShape)), MonadIO m) => O.OverloadedMethod AttributeAsShapeMethodInfo Attribute signature where
        overloadedMethod = attributeAsShape

    instance O.OverloadedMethodInfo AttributeAsShapeMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsShape",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsShape"
            })

    #endif

    -- method Attribute::as_size
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` representing a size"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "AttrSize" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_size" pango_attribute_as_size ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrSize.AttrSize)

    -- | Returns the attribute cast to @PangoAttrSize@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsSize ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ representing a size
        -> m (Maybe Pango.AttrSize.AttrSize)
        -- ^ __Returns:__ The attribute as @PangoAttrSize@,
        --   or NULL if it\'s not a size attribute
    attributeAsSize :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrSize)
    attributeAsSize Attribute
    attr = IO (Maybe AttrSize) -> m (Maybe AttrSize)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrSize) -> m (Maybe AttrSize))
    -> IO (Maybe AttrSize) -> m (Maybe AttrSize)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrSize
    result <- Ptr Attribute -> IO (Ptr AttrSize)
    pango_attribute_as_size Ptr Attribute
    attr'
        Maybe AttrSize
    maybeResult <- Ptr AttrSize
    -> (Ptr AttrSize -> IO AttrSize) -> IO (Maybe AttrSize)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrSize
    result ((Ptr AttrSize -> IO AttrSize) -> IO (Maybe AttrSize))
    -> (Ptr AttrSize -> IO AttrSize) -> IO (Maybe AttrSize)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrSize
    result' -> do
            AttrSize
    result'' <- ((ManagedPtr AttrSize -> AttrSize) -> Ptr AttrSize -> IO AttrSize
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrSize -> AttrSize
    Pango.AttrSize.AttrSize) Ptr AttrSize
    result'
            AttrSize -> IO AttrSize
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrSize
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrSize -> IO (Maybe AttrSize)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrSize
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsSizeMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrSize.AttrSize)), MonadIO m) => O.OverloadedMethod AttributeAsSizeMethodInfo Attribute signature where
        overloadedMethod = attributeAsSize

    instance O.OverloadedMethodInfo AttributeAsSizeMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsSize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsSize"
            })

    #endif

    -- method Attribute::as_string
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "A `PangoAttribute` such as family"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Pango" , name = "AttrString" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_as_string" pango_attribute_as_string ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Pango.AttrString.AttrString)

    -- | Returns the attribute cast to @PangoAttrString@.
    --
    -- This is mainly useful for language bindings.
    --
    -- /Since: 1.50/
    attributeAsString ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: A @PangoAttribute@ such as family
        -> m (Maybe Pango.AttrString.AttrString)
        -- ^ __Returns:__ The attribute as @PangoAttrString@,
        --   or 'P.Nothing' if it\'s not a string attribute
    attributeAsString :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m (Maybe AttrString)
    attributeAsString Attribute
    attr = IO (Maybe AttrString) -> m (Maybe AttrString)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe AttrString) -> m (Maybe AttrString))
    -> IO (Maybe AttrString) -> m (Maybe AttrString)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrString
    result <- Ptr Attribute -> IO (Ptr AttrString)
    pango_attribute_as_string Ptr Attribute
    attr'
        Maybe AttrString
    maybeResult <- Ptr AttrString
    -> (Ptr AttrString -> IO AttrString) -> IO (Maybe AttrString)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr AttrString
    result ((Ptr AttrString -> IO AttrString) -> IO (Maybe AttrString))
    -> (Ptr AttrString -> IO AttrString) -> IO (Maybe AttrString)
    forall a b. (a -> b) -> a -> b
    $ \Ptr AttrString
    result' -> do
            AttrString
    result'' <- ((ManagedPtr AttrString -> AttrString)
    -> Ptr AttrString -> IO AttrString
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr AttrString -> AttrString
    Pango.AttrString.AttrString) Ptr AttrString
    result'
            AttrString -> IO AttrString
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return AttrString
    result''
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Maybe AttrString -> IO (Maybe AttrString)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe AttrString
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data AttributeAsStringMethodInfo
    instance (signature ~ (m (Maybe Pango.AttrString.AttrString)), MonadIO m) => O.OverloadedMethod AttributeAsStringMethodInfo Attribute signature where
        overloadedMethod = attributeAsString

    instance O.OverloadedMethodInfo AttributeAsStringMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeAsString",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeAsString"
            })

    #endif

    -- method Attribute::copy
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoAttribute`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Attribute" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_copy" pango_attribute_copy ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO (Ptr Attribute)

    -- | Make a copy of an attribute.
    attributeCopy ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: a @PangoAttribute@
        -> m Attribute
        -- ^ __Returns:__ the newly allocated
        --   @PangoAttribute@, which should be freed with
        --   'GI.Pango.Structs.Attribute.attributeDestroy'.
    attributeCopy :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m Attribute
    attributeCopy Attribute
    attr = IO Attribute -> m Attribute
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Attribute -> m Attribute) -> IO Attribute -> m Attribute
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr Attribute
    result <- Ptr Attribute -> IO (Ptr Attribute)
    pango_attribute_copy Ptr Attribute
    attr'
        Text -> Ptr Attribute -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "attributeCopy" Ptr Attribute
    result
        Attribute
    result' <- ((ManagedPtr Attribute -> Attribute)
    -> Ptr Attribute -> IO Attribute
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Attribute -> Attribute
    Attribute) Ptr Attribute
    result
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        Attribute -> IO Attribute
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Attribute
    result'

    #if defined(ENABLE_OVERLOADING)
    data AttributeCopyMethodInfo
    instance (signature ~ (m Attribute), MonadIO m) => O.OverloadedMethod AttributeCopyMethodInfo Attribute signature where
        overloadedMethod = attributeCopy

    instance O.OverloadedMethodInfo AttributeCopyMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeCopy",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeCopy"
            })

    #endif

    -- method Attribute::destroy
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoAttribute`."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_destroy" pango_attribute_destroy ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO ()

    -- | Destroy a @PangoAttribute@ and free all associated memory.
    attributeDestroy ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: a @PangoAttribute@.
        -> m ()
    attributeDestroy :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> m ()
    attributeDestroy Attribute
    attr = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr Attribute -> IO ()
    pango_attribute_destroy Ptr Attribute
    attr'
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data AttributeDestroyMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AttributeDestroyMethodInfo Attribute signature where
        overloadedMethod = attributeDestroy

    instance O.OverloadedMethodInfo AttributeDestroyMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeDestroy",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeDestroy"
            })

    #endif

    -- method Attribute::equal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr1"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoAttribute`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "attr2"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "another `PangoAttribute`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_equal" pango_attribute_equal ::
        Ptr Attribute ->                        -- attr1 : TInterface (Name {namespace = "Pango", name = "Attribute"})
        Ptr Attribute ->                        -- attr2 : TInterface (Name {namespace = "Pango", name = "Attribute"})
        IO CInt

    -- | Compare two attributes for equality.
    --
    -- This compares only the actual value of the two
    -- attributes and not the ranges that the attributes
    -- apply to.
    attributeEqual ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr1@/: a @PangoAttribute@
        -> Attribute
        -- ^ /@attr2@/: another @PangoAttribute@
        -> m Bool
        -- ^ __Returns:__ 'P.True' if the two attributes have the same value
    attributeEqual :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> Attribute -> m Bool
    attributeEqual Attribute
    attr1 Attribute
    attr2 = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr1' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr1
        Ptr Attribute
    attr2' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr2
        CInt
    result <- Ptr Attribute -> Ptr Attribute -> IO CInt
    pango_attribute_equal Ptr Attribute
    attr1' Ptr Attribute
    attr2'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr1
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr2
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data AttributeEqualMethodInfo
    instance (signature ~ (Attribute -> m Bool), MonadIO m) => O.OverloadedMethod AttributeEqualMethodInfo Attribute signature where
        overloadedMethod = attributeEqual

    instance O.OverloadedMethodInfo AttributeEqualMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeEqual",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeEqual"
            })

    #endif

    -- method Attribute::init
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "attr"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Attribute" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoAttribute`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "klass"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "AttrClass" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoAttrClass`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_attribute_init" pango_attribute_init ::
        Ptr Attribute ->                        -- attr : TInterface (Name {namespace = "Pango", name = "Attribute"})
        Ptr Pango.AttrClass.AttrClass ->        -- klass : TInterface (Name {namespace = "Pango", name = "AttrClass"})
        IO ()

    -- | Initializes /@attr@/\'s klass to /@klass@/, it\'s start_index to
    -- 'GI.Pango.Constants.ATTR_INDEX_FROM_TEXT_BEGINNING' and end_index to
    -- 'GI.Pango.Constants.ATTR_INDEX_TO_TEXT_END' such that the attribute applies
    -- to the entire text by default.
    --
    -- /Since: 1.20/
    attributeInit ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Attribute
        -- ^ /@attr@/: a @PangoAttribute@
        -> Pango.AttrClass.AttrClass
        -- ^ /@klass@/: a @PangoAttrClass@
        -> m ()
    attributeInit :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Attribute -> AttrClass -> m ()
    attributeInit Attribute
    attr AttrClass
    klass = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Attribute
    attr' <- Attribute -> IO (Ptr Attribute)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Attribute
    attr
        Ptr AttrClass
    klass' <- AttrClass -> IO (Ptr AttrClass)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr AttrClass
    klass
        Ptr Attribute -> Ptr AttrClass -> IO ()
    pango_attribute_init Ptr Attribute
    attr' Ptr AttrClass
    klass'
        Attribute -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Attribute
    attr
        AttrClass -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr AttrClass
    klass
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data AttributeInitMethodInfo
    instance (signature ~ (Pango.AttrClass.AttrClass -> m ()), MonadIO m) => O.OverloadedMethod AttributeInitMethodInfo Attribute signature where
        overloadedMethod = attributeInit

    instance O.OverloadedMethodInfo AttributeInitMethodInfo Attribute where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Structs.Attribute.attributeInit",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Structs-Attribute.html#v:attributeInit"
            })

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveAttributeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveAttributeMethod "asColor" o = AttributeAsColorMethodInfo
        ResolveAttributeMethod "asFloat" o = AttributeAsFloatMethodInfo
        ResolveAttributeMethod "asFontDesc" o = AttributeAsFontDescMethodInfo
        ResolveAttributeMethod "asFontFeatures" o = AttributeAsFontFeaturesMethodInfo
        ResolveAttributeMethod "asInt" o = AttributeAsIntMethodInfo
        ResolveAttributeMethod "asLanguage" o = AttributeAsLanguageMethodInfo
        ResolveAttributeMethod "asShape" o = AttributeAsShapeMethodInfo
        ResolveAttributeMethod "asSize" o = AttributeAsSizeMethodInfo
        ResolveAttributeMethod "asString" o = AttributeAsStringMethodInfo
        ResolveAttributeMethod "copy" o = AttributeCopyMethodInfo
        ResolveAttributeMethod "destroy" o = AttributeDestroyMethodInfo
        ResolveAttributeMethod "equal" o = AttributeEqualMethodInfo
        ResolveAttributeMethod "init" o = AttributeInitMethodInfo
        ResolveAttributeMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveAttributeMethod t Attribute, O.OverloadedMethod info Attribute p) => OL.IsLabel t (Attribute -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveAttributeMethod t Attribute, O.OverloadedMethod info Attribute p, R.HasField t Attribute p) => R.HasField t Attribute p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveAttributeMethod t Attribute, O.OverloadedMethodInfo info Attribute) => OL.IsLabel t (O.MethodProxy info Attribute) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif