    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The t'GI.Pango.Structs.EngineInfo.EngineInfo' structure contains information about a particular
    -- engine. It contains the following fields:

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

    module GI.Pango.Structs.EngineInfo
        (

    -- * Exported types
        EngineInfo(..)                          ,
        newZeroEngineInfo                       ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveEngineInfoMethod                 ,
    #endif

     -- * Properties
    -- ** engineType #attr:engineType#
    -- | a string identifying the engine type.

        clearEngineInfoEngineType               ,
    #if defined(ENABLE_OVERLOADING)
        engineInfo_engineType                   ,
    #endif
        getEngineInfoEngineType                 ,
        setEngineInfoEngineType                 ,

    -- ** id #attr:id#
    -- | a unique string ID for the engine.

        clearEngineInfoId                       ,
    #if defined(ENABLE_OVERLOADING)
        engineInfo_id                           ,
    #endif
        getEngineInfoId                         ,
        setEngineInfoId                         ,

    -- ** nScripts #attr:nScripts#
    -- | number of items in /@scripts@/.

    #if defined(ENABLE_OVERLOADING)
        engineInfo_nScripts                     ,
    #endif
        getEngineInfoNScripts                   ,
        setEngineInfoNScripts                   ,

    -- ** renderType #attr:renderType#
    -- | a string identifying the render type.

        clearEngineInfoRenderType               ,
    #if defined(ENABLE_OVERLOADING)
        engineInfo_renderType                   ,
    #endif
        getEngineInfoRenderType                 ,
        setEngineInfoRenderType                 ,

    -- ** scripts #attr:scripts#
    -- | array of scripts this engine supports.

        clearEngineInfoScripts                  ,
    #if defined(ENABLE_OVERLOADING)
        engineInfo_scripts                      ,
    #endif
        getEngineInfoScripts                    ,
        setEngineInfoScripts                    ,

        ) 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

    import {-# SOURCE #-} qualified GI.Pango.Structs.EngineScriptInfo as Pango.EngineScriptInfo

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

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

    instance BoxedPtr EngineInfo where
        boxedPtrCopy :: EngineInfo -> IO EngineInfo
    boxedPtrCopy = \p :: EngineInfo
    p -> EngineInfo -> (Ptr EngineInfo -> IO EngineInfo) -> IO EngineInfo
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr EngineInfo
    p (Int -> Ptr EngineInfo -> IO (Ptr EngineInfo)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes 40 (Ptr EngineInfo -> IO (Ptr EngineInfo))
    -> (Ptr EngineInfo -> IO EngineInfo)
    -> Ptr EngineInfo
    -> IO EngineInfo
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr EngineInfo -> EngineInfo)
    -> Ptr EngineInfo -> IO EngineInfo
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr EngineInfo -> EngineInfo
    EngineInfo)
        boxedPtrFree :: EngineInfo -> IO ()
    boxedPtrFree = \x :: EngineInfo
    x -> EngineInfo -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr EngineInfo
    x Ptr EngineInfo -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr EngineInfo where
        boxedPtrCalloc :: IO (Ptr EngineInfo)
    boxedPtrCalloc = Int -> IO (Ptr EngineInfo)
    forall a. Int -> IO (Ptr a)
    callocBytes 40

    -- | Construct a `EngineInfo` struct initialized to zero.
    newZeroEngineInfo :: MonadIO m => m EngineInfo
    newZeroEngineInfo :: m EngineInfo
    newZeroEngineInfo = IO EngineInfo -> m EngineInfo
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO EngineInfo -> m EngineInfo) -> IO EngineInfo -> m EngineInfo
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr EngineInfo)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr EngineInfo)
    -> (Ptr EngineInfo -> IO EngineInfo) -> IO EngineInfo
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr EngineInfo -> EngineInfo)
    -> Ptr EngineInfo -> IO EngineInfo
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr EngineInfo -> EngineInfo
    EngineInfo

    instance tag ~ 'AttrSet => Constructible EngineInfo tag where
        new :: (ManagedPtr EngineInfo -> EngineInfo)
    -> [AttrOp EngineInfo tag] -> m EngineInfo
    new _ attrs :: [AttrOp EngineInfo tag]
    attrs = do
            EngineInfo
    o <- m EngineInfo
    forall (m :: * -> *). MonadIO m => m EngineInfo
    newZeroEngineInfo
            EngineInfo -> [AttrOp EngineInfo 'AttrSet] -> m ()
    forall o (m :: * -> *).
    MonadIO m =>
    o -> [AttrOp o 'AttrSet] -> m ()
    GI.Attributes.set EngineInfo
    o [AttrOp EngineInfo tag]
    [AttrOp EngineInfo 'AttrSet]
    attrs
            EngineInfo -> m EngineInfo
    forall (m :: * -> *) a. Monad m => a -> m a
    return EngineInfo
    o

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

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

    -- | Set the value of the “@id@” 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' #id
    -- @
    clearEngineInfoId :: MonadIO m => EngineInfo -> m ()
    clearEngineInfoId :: EngineInfo -> m ()
    clearEngineInfoId s :: EngineInfo
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EngineInfo -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EngineInfo
    s ((Ptr EngineInfo -> IO ()) -> IO ())
    -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr EngineInfo
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EngineInfo
    ptr Ptr EngineInfo -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 0) (CString
    forall a. Ptr a
    FP.nullPtr :: CString)

    #if defined(ENABLE_OVERLOADING)
    data EngineInfoIdFieldInfo
    instance AttrInfo EngineInfoIdFieldInfo where
        type AttrBaseTypeConstraint EngineInfoIdFieldInfo = (~) EngineInfo
        type AttrAllowedOps EngineInfoIdFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint EngineInfoIdFieldInfo = (~) CString
        type AttrTransferTypeConstraint EngineInfoIdFieldInfo = (~)CString
        type AttrTransferType EngineInfoIdFieldInfo = CString
        type AttrGetType EngineInfoIdFieldInfo = Maybe T.Text
        type AttrLabel EngineInfoIdFieldInfo = "id"
        type AttrOrigin EngineInfoIdFieldInfo = EngineInfo
        attrGet = getEngineInfoId
        attrSet = setEngineInfoId
        attrConstruct = undefined
        attrClear = clearEngineInfoId
        attrTransfer _ v = do
            return v

    engineInfo_id :: AttrLabelProxy "id"
    engineInfo_id = AttrLabelProxy

    #endif

    -- | Get the value of the “@engine_type@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' engineInfo #engineType
    -- @
    getEngineInfoEngineType :: MonadIO m => EngineInfo -> m (Maybe T.Text)
    getEngineInfoEngineType :: EngineInfo -> m (Maybe Text)
    getEngineInfoEngineType s :: EngineInfo
    s = IO (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ EngineInfo
    -> (Ptr EngineInfo -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EngineInfo
    s ((Ptr EngineInfo -> IO (Maybe Text)) -> IO (Maybe Text))
    -> (Ptr EngineInfo -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr EngineInfo
    ptr -> do
        CString
    val <- Ptr CString -> IO CString
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EngineInfo
    ptr Ptr EngineInfo -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 8) :: IO CString
        Maybe Text
    result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    SP.convertIfNonNull CString
    val ((CString -> IO Text) -> IO (Maybe Text))
    -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \val' :: CString
    val' -> do
            Text
    val'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    val'
            Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    val''
        Maybe Text -> IO (Maybe Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Text
    result

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

    -- | Set the value of the “@engine_type@” 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' #engineType
    -- @
    clearEngineInfoEngineType :: MonadIO m => EngineInfo -> m ()
    clearEngineInfoEngineType :: EngineInfo -> m ()
    clearEngineInfoEngineType s :: EngineInfo
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EngineInfo -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EngineInfo
    s ((Ptr EngineInfo -> IO ()) -> IO ())
    -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr EngineInfo
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EngineInfo
    ptr Ptr EngineInfo -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 8) (CString
    forall a. Ptr a
    FP.nullPtr :: CString)

    #if defined(ENABLE_OVERLOADING)
    data EngineInfoEngineTypeFieldInfo
    instance AttrInfo EngineInfoEngineTypeFieldInfo where
        type AttrBaseTypeConstraint EngineInfoEngineTypeFieldInfo = (~) EngineInfo
        type AttrAllowedOps EngineInfoEngineTypeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint EngineInfoEngineTypeFieldInfo = (~) CString
        type AttrTransferTypeConstraint EngineInfoEngineTypeFieldInfo = (~)CString
        type AttrTransferType EngineInfoEngineTypeFieldInfo = CString
        type AttrGetType EngineInfoEngineTypeFieldInfo = Maybe T.Text
        type AttrLabel EngineInfoEngineTypeFieldInfo = "engine_type"
        type AttrOrigin EngineInfoEngineTypeFieldInfo = EngineInfo
        attrGet = getEngineInfoEngineType
        attrSet = setEngineInfoEngineType
        attrConstruct = undefined
        attrClear = clearEngineInfoEngineType
        attrTransfer _ v = do
            return v

    engineInfo_engineType :: AttrLabelProxy "engineType"
    engineInfo_engineType = AttrLabelProxy

    #endif

    -- | Get the value of the “@render_type@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' engineInfo #renderType
    -- @
    getEngineInfoRenderType :: MonadIO m => EngineInfo -> m (Maybe T.Text)
    getEngineInfoRenderType :: EngineInfo -> m (Maybe Text)
    getEngineInfoRenderType s :: EngineInfo
    s = IO (Maybe Text) -> m (Maybe Text)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ EngineInfo
    -> (Ptr EngineInfo -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EngineInfo
    s ((Ptr EngineInfo -> IO (Maybe Text)) -> IO (Maybe Text))
    -> (Ptr EngineInfo -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr EngineInfo
    ptr -> do
        CString
    val <- Ptr CString -> IO CString
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr EngineInfo
    ptr Ptr EngineInfo -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 16) :: IO CString
        Maybe Text
    result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    SP.convertIfNonNull CString
    val ((CString -> IO Text) -> IO (Maybe Text))
    -> (CString -> IO Text) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \val' :: CString
    val' -> do
            Text
    val'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    val'
            Text -> IO Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    val''
        Maybe Text -> IO (Maybe Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Text
    result

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

    -- | Set the value of the “@render_type@” 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' #renderType
    -- @
    clearEngineInfoRenderType :: MonadIO m => EngineInfo -> m ()
    clearEngineInfoRenderType :: EngineInfo -> m ()
    clearEngineInfoRenderType s :: EngineInfo
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EngineInfo -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EngineInfo
    s ((Ptr EngineInfo -> IO ()) -> IO ())
    -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr EngineInfo
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EngineInfo
    ptr Ptr EngineInfo -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 16) (CString
    forall a. Ptr a
    FP.nullPtr :: CString)

    #if defined(ENABLE_OVERLOADING)
    data EngineInfoRenderTypeFieldInfo
    instance AttrInfo EngineInfoRenderTypeFieldInfo where
        type AttrBaseTypeConstraint EngineInfoRenderTypeFieldInfo = (~) EngineInfo
        type AttrAllowedOps EngineInfoRenderTypeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint EngineInfoRenderTypeFieldInfo = (~) CString
        type AttrTransferTypeConstraint EngineInfoRenderTypeFieldInfo = (~)CString
        type AttrTransferType EngineInfoRenderTypeFieldInfo = CString
        type AttrGetType EngineInfoRenderTypeFieldInfo = Maybe T.Text
        type AttrLabel EngineInfoRenderTypeFieldInfo = "render_type"
        type AttrOrigin EngineInfoRenderTypeFieldInfo = EngineInfo
        attrGet = getEngineInfoRenderType
        attrSet = setEngineInfoRenderType
        attrConstruct = undefined
        attrClear = clearEngineInfoRenderType
        attrTransfer _ v = do
            return v

    engineInfo_renderType :: AttrLabelProxy "renderType"
    engineInfo_renderType = AttrLabelProxy

    #endif

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

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

    -- | Set the value of the “@scripts@” 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' #scripts
    -- @
    clearEngineInfoScripts :: MonadIO m => EngineInfo -> m ()
    clearEngineInfoScripts :: EngineInfo -> m ()
    clearEngineInfoScripts s :: EngineInfo
    s = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ EngineInfo -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr EngineInfo
    s ((Ptr EngineInfo -> IO ()) -> IO ())
    -> (Ptr EngineInfo -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \ptr :: Ptr EngineInfo
    ptr -> do
        Ptr (Ptr EngineScriptInfo) -> Ptr EngineScriptInfo -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr EngineInfo
    ptr Ptr EngineInfo -> Int -> Ptr (Ptr EngineScriptInfo)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` 24) (Ptr EngineScriptInfo
    forall a. Ptr a
    FP.nullPtr :: Ptr Pango.EngineScriptInfo.EngineScriptInfo)

    #if defined(ENABLE_OVERLOADING)
    data EngineInfoScriptsFieldInfo
    instance AttrInfo EngineInfoScriptsFieldInfo where
        type AttrBaseTypeConstraint EngineInfoScriptsFieldInfo = (~) EngineInfo
        type AttrAllowedOps EngineInfoScriptsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint EngineInfoScriptsFieldInfo = (~) (Ptr Pango.EngineScriptInfo.EngineScriptInfo)
        type AttrTransferTypeConstraint EngineInfoScriptsFieldInfo = (~)(Ptr Pango.EngineScriptInfo.EngineScriptInfo)
        type AttrTransferType EngineInfoScriptsFieldInfo = (Ptr Pango.EngineScriptInfo.EngineScriptInfo)
        type AttrGetType EngineInfoScriptsFieldInfo = Maybe Pango.EngineScriptInfo.EngineScriptInfo
        type AttrLabel EngineInfoScriptsFieldInfo = "scripts"
        type AttrOrigin EngineInfoScriptsFieldInfo = EngineInfo
        attrGet = getEngineInfoScripts
        attrSet = setEngineInfoScripts
        attrConstruct = undefined
        attrClear = clearEngineInfoScripts
        attrTransfer _ v = do
            return v

    engineInfo_scripts :: AttrLabelProxy "scripts"
    engineInfo_scripts = AttrLabelProxy

    #endif

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

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

    #if defined(ENABLE_OVERLOADING)
    data EngineInfoNScriptsFieldInfo
    instance AttrInfo EngineInfoNScriptsFieldInfo where
        type AttrBaseTypeConstraint EngineInfoNScriptsFieldInfo = (~) EngineInfo
        type AttrAllowedOps EngineInfoNScriptsFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint EngineInfoNScriptsFieldInfo = (~) Int32
        type AttrTransferTypeConstraint EngineInfoNScriptsFieldInfo = (~)Int32
        type AttrTransferType EngineInfoNScriptsFieldInfo = Int32
        type AttrGetType EngineInfoNScriptsFieldInfo = Int32
        type AttrLabel EngineInfoNScriptsFieldInfo = "n_scripts"
        type AttrOrigin EngineInfoNScriptsFieldInfo = EngineInfo
        attrGet = getEngineInfoNScripts
        attrSet = setEngineInfoNScripts
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v

    engineInfo_nScripts :: AttrLabelProxy "nScripts"
    engineInfo_nScripts = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList EngineInfo
    type instance O.AttributeList EngineInfo = EngineInfoAttributeList
    type EngineInfoAttributeList = ('[ '("id", EngineInfoIdFieldInfo), '("engineType", EngineInfoEngineTypeFieldInfo), '("renderType", EngineInfoRenderTypeFieldInfo), '("scripts", EngineInfoScriptsFieldInfo), '("nScripts", EngineInfoNScriptsFieldInfo)] :: [(Symbol, *)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveEngineInfoMethod (t :: Symbol) (o :: *) :: * where
        ResolveEngineInfoMethod l o = O.MethodResolutionFailed l o

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

    #endif