    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The structure that holds various text properties of an t'GI.HarfBuzz.Structs.BufferT.BufferT'. Can be
    -- set and retrieved using 'GI.HarfBuzz.Functions.bufferSetSegmentProperties' and
    -- 'GI.HarfBuzz.Functions.bufferGetSegmentProperties', respectively.

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

    module GI.HarfBuzz.Structs.SegmentPropertiesT
        (

    -- * Exported types
        SegmentPropertiesT(..)                  ,
        newZeroSegmentPropertiesT               ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveSegmentPropertiesTMethod         ,
    #endif

     -- * Properties

    -- ** direction #attr:direction#
    -- | the t'GI.HarfBuzz.Enums.DirectionT' of the buffer, see 'GI.HarfBuzz.Functions.bufferSetDirection'.

        getSegmentPropertiesTDirection          ,
    #if defined(ENABLE_OVERLOADING)
        segmentPropertiesT_direction            ,
    #endif
        setSegmentPropertiesTDirection          ,

    -- ** language #attr:language#
    -- | the t'GI.HarfBuzz.Structs.LanguageT.LanguageT' of the buffer, see 'GI.HarfBuzz.Functions.bufferSetLanguage'.

        getSegmentPropertiesTLanguage           ,
    #if defined(ENABLE_OVERLOADING)
        segmentPropertiesT_language             ,
    #endif

    -- ** script #attr:script#
    -- | the t'GI.HarfBuzz.Enums.ScriptT' of the buffer, see 'GI.HarfBuzz.Functions.bufferSetScript'.

        getSegmentPropertiesTScript             ,
    #if defined(ENABLE_OVERLOADING)
        segmentPropertiesT_script               ,
    #endif
        setSegmentPropertiesTScript             ,

        ) 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 qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import {-# SOURCE #-} qualified GI.HarfBuzz.Enums as HarfBuzz.Enums
    import {-# SOURCE #-} qualified GI.HarfBuzz.Structs.LanguageT as HarfBuzz.LanguageT

    #else
    import {-# SOURCE #-} qualified GI.HarfBuzz.Enums as HarfBuzz.Enums
    import {-# SOURCE #-} qualified GI.HarfBuzz.Structs.LanguageT as HarfBuzz.LanguageT

    #endif

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

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

    foreign import ccall "hb_gobject_segment_properties_get_type" c_hb_gobject_segment_properties_get_type ::
        IO GType

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

    instance B.Types.TypedObject SegmentPropertiesT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_segment_properties_get_type

    instance B.Types.GBoxed SegmentPropertiesT

    -- | Convert 'SegmentPropertiesT' 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 SegmentPropertiesT) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_hb_gobject_segment_properties_get_type
        gvalueSet_ :: Ptr GValue -> Maybe SegmentPropertiesT -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe SegmentPropertiesT
    P.Nothing = Ptr GValue -> Ptr SegmentPropertiesT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr SegmentPropertiesT
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr SegmentPropertiesT)
        gvalueSet_ Ptr GValue
    gv (P.Just SegmentPropertiesT
    obj) = SegmentPropertiesT -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr SegmentPropertiesT
    obj (Ptr GValue -> Ptr SegmentPropertiesT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe SegmentPropertiesT)
    gvalueGet_ Ptr GValue
    gv = do
            Ptr SegmentPropertiesT
    ptr <- Ptr GValue -> IO (Ptr SegmentPropertiesT)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr SegmentPropertiesT)
            if Ptr SegmentPropertiesT
    ptr Ptr SegmentPropertiesT -> Ptr SegmentPropertiesT -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Ptr SegmentPropertiesT
    forall a. Ptr a
    FP.nullPtr
            then SegmentPropertiesT -> Maybe SegmentPropertiesT
    forall a. a -> Maybe a
    P.Just (SegmentPropertiesT -> Maybe SegmentPropertiesT)
    -> IO SegmentPropertiesT -> IO (Maybe SegmentPropertiesT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ManagedPtr SegmentPropertiesT -> SegmentPropertiesT)
    -> Ptr SegmentPropertiesT -> IO SegmentPropertiesT
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.newBoxed ManagedPtr SegmentPropertiesT -> SegmentPropertiesT
    SegmentPropertiesT Ptr SegmentPropertiesT
    ptr
            else Maybe SegmentPropertiesT -> IO (Maybe SegmentPropertiesT)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe SegmentPropertiesT
    forall a. Maybe a
    P.Nothing

    -- | Construct a `SegmentPropertiesT` struct initialized to zero.
    newZeroSegmentPropertiesT :: MonadIO m => m SegmentPropertiesT
    newZeroSegmentPropertiesT :: forall (m :: * -> *). MonadIO m => m SegmentPropertiesT
    newZeroSegmentPropertiesT = IO SegmentPropertiesT -> m SegmentPropertiesT
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SegmentPropertiesT -> m SegmentPropertiesT)
    -> IO SegmentPropertiesT -> m SegmentPropertiesT
    forall a b. (a -> b) -> a -> b
    $ Int -> IO (Ptr SegmentPropertiesT)
    forall a. GBoxed a => Int -> IO (Ptr a)
    callocBoxedBytes Int
    32 IO (Ptr SegmentPropertiesT)
    -> (Ptr SegmentPropertiesT -> IO SegmentPropertiesT)
    -> IO SegmentPropertiesT
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr SegmentPropertiesT -> SegmentPropertiesT)
    -> Ptr SegmentPropertiesT -> IO SegmentPropertiesT
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr SegmentPropertiesT -> SegmentPropertiesT
    SegmentPropertiesT

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

    -- | Get the value of the “@direction@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' segmentPropertiesT #direction
    -- @
    getSegmentPropertiesTDirection :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.Enums.DirectionT
    getSegmentPropertiesTDirection :: forall (m :: * -> *).
    MonadIO m =>
    SegmentPropertiesT -> m DirectionT
    getSegmentPropertiesTDirection SegmentPropertiesT
    s = IO DirectionT -> m DirectionT
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO DirectionT -> m DirectionT) -> IO DirectionT -> m DirectionT
    forall a b. (a -> b) -> a -> b
    $ SegmentPropertiesT
    -> (Ptr SegmentPropertiesT -> IO DirectionT) -> IO DirectionT
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SegmentPropertiesT
    s ((Ptr SegmentPropertiesT -> IO DirectionT) -> IO DirectionT)
    -> (Ptr SegmentPropertiesT -> IO DirectionT) -> IO DirectionT
    forall a b. (a -> b) -> a -> b
    $ \Ptr SegmentPropertiesT
    ptr -> do
        CUInt
    val <- Ptr CUInt -> IO CUInt
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SegmentPropertiesT
    ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO CUInt
        let val' :: DirectionT
    val' = (Int -> DirectionT
    forall a. Enum a => Int -> a
    toEnum (Int -> DirectionT) -> (CUInt -> Int) -> CUInt -> DirectionT
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    val
        DirectionT -> IO DirectionT
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return DirectionT
    val'

    -- | Set the value of the “@direction@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' segmentPropertiesT [ #direction 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSegmentPropertiesTDirection :: MonadIO m => SegmentPropertiesT -> HarfBuzz.Enums.DirectionT -> m ()
    setSegmentPropertiesTDirection :: forall (m :: * -> *).
    MonadIO m =>
    SegmentPropertiesT -> DirectionT -> m ()
    setSegmentPropertiesTDirection SegmentPropertiesT
    s DirectionT
    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
    $ SegmentPropertiesT -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SegmentPropertiesT
    s ((Ptr SegmentPropertiesT -> IO ()) -> IO ())
    -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SegmentPropertiesT
    ptr -> do
        let val' :: CUInt
    val' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (DirectionT -> Int) -> DirectionT -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . DirectionT -> Int
    forall a. Enum a => a -> Int
    fromEnum) DirectionT
    val
        Ptr CUInt -> CUInt -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SegmentPropertiesT
    ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) (CUInt
    val' :: CUInt)

    #if defined(ENABLE_OVERLOADING)
    data SegmentPropertiesTDirectionFieldInfo
    instance AttrInfo SegmentPropertiesTDirectionFieldInfo where
        type AttrBaseTypeConstraint SegmentPropertiesTDirectionFieldInfo = (~) SegmentPropertiesT
        type AttrAllowedOps SegmentPropertiesTDirectionFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint SegmentPropertiesTDirectionFieldInfo = (~) HarfBuzz.Enums.DirectionT
        type AttrTransferTypeConstraint SegmentPropertiesTDirectionFieldInfo = (~)HarfBuzz.Enums.DirectionT
        type AttrTransferType SegmentPropertiesTDirectionFieldInfo = HarfBuzz.Enums.DirectionT
        type AttrGetType SegmentPropertiesTDirectionFieldInfo = HarfBuzz.Enums.DirectionT
        type AttrLabel SegmentPropertiesTDirectionFieldInfo = "direction"
        type AttrOrigin SegmentPropertiesTDirectionFieldInfo = SegmentPropertiesT
        attrGet = getSegmentPropertiesTDirection
        attrSet = setSegmentPropertiesTDirection
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.HarfBuzz.Structs.SegmentPropertiesT.direction"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.10/docs/GI-HarfBuzz-Structs-SegmentPropertiesT.html#g:attr:direction"
            })

    segmentPropertiesT_direction :: AttrLabelProxy "direction"
    segmentPropertiesT_direction = AttrLabelProxy

    #endif

    -- | Get the value of the “@script@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' segmentPropertiesT #script
    -- @
    getSegmentPropertiesTScript :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.Enums.ScriptT
    getSegmentPropertiesTScript :: forall (m :: * -> *). MonadIO m => SegmentPropertiesT -> m ScriptT
    getSegmentPropertiesTScript SegmentPropertiesT
    s = IO ScriptT -> m ScriptT
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ScriptT -> m ScriptT) -> IO ScriptT -> m ScriptT
    forall a b. (a -> b) -> a -> b
    $ SegmentPropertiesT
    -> (Ptr SegmentPropertiesT -> IO ScriptT) -> IO ScriptT
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SegmentPropertiesT
    s ((Ptr SegmentPropertiesT -> IO ScriptT) -> IO ScriptT)
    -> (Ptr SegmentPropertiesT -> IO ScriptT) -> IO ScriptT
    forall a b. (a -> b) -> a -> b
    $ \Ptr SegmentPropertiesT
    ptr -> do
        CUInt
    val <- Ptr CUInt -> IO CUInt
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SegmentPropertiesT
    ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) :: IO CUInt
        let val' :: ScriptT
    val' = (Int -> ScriptT
    forall a. Enum a => Int -> a
    toEnum (Int -> ScriptT) -> (CUInt -> Int) -> CUInt -> ScriptT
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    val
        ScriptT -> IO ScriptT
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ScriptT
    val'

    -- | Set the value of the “@script@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' segmentPropertiesT [ #script 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSegmentPropertiesTScript :: MonadIO m => SegmentPropertiesT -> HarfBuzz.Enums.ScriptT -> m ()
    setSegmentPropertiesTScript :: forall (m :: * -> *).
    MonadIO m =>
    SegmentPropertiesT -> ScriptT -> m ()
    setSegmentPropertiesTScript SegmentPropertiesT
    s ScriptT
    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
    $ SegmentPropertiesT -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SegmentPropertiesT
    s ((Ptr SegmentPropertiesT -> IO ()) -> IO ())
    -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SegmentPropertiesT
    ptr -> do
        let val' :: CUInt
    val' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (ScriptT -> Int) -> ScriptT -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ScriptT -> Int
    forall a. Enum a => a -> Int
    fromEnum) ScriptT
    val
        Ptr CUInt -> CUInt -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SegmentPropertiesT
    ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    4) (CUInt
    val' :: CUInt)

    #if defined(ENABLE_OVERLOADING)
    data SegmentPropertiesTScriptFieldInfo
    instance AttrInfo SegmentPropertiesTScriptFieldInfo where
        type AttrBaseTypeConstraint SegmentPropertiesTScriptFieldInfo = (~) SegmentPropertiesT
        type AttrAllowedOps SegmentPropertiesTScriptFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint SegmentPropertiesTScriptFieldInfo = (~) HarfBuzz.Enums.ScriptT
        type AttrTransferTypeConstraint SegmentPropertiesTScriptFieldInfo = (~)HarfBuzz.Enums.ScriptT
        type AttrTransferType SegmentPropertiesTScriptFieldInfo = HarfBuzz.Enums.ScriptT
        type AttrGetType SegmentPropertiesTScriptFieldInfo = HarfBuzz.Enums.ScriptT
        type AttrLabel SegmentPropertiesTScriptFieldInfo = "script"
        type AttrOrigin SegmentPropertiesTScriptFieldInfo = SegmentPropertiesT
        attrGet = getSegmentPropertiesTScript
        attrSet = setSegmentPropertiesTScript
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.HarfBuzz.Structs.SegmentPropertiesT.script"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.10/docs/GI-HarfBuzz-Structs-SegmentPropertiesT.html#g:attr:script"
            })

    segmentPropertiesT_script :: AttrLabelProxy "script"
    segmentPropertiesT_script = AttrLabelProxy

    #endif

    -- | Get the value of the “@language@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' segmentPropertiesT #language
    -- @
    getSegmentPropertiesTLanguage :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.LanguageT.LanguageT
    getSegmentPropertiesTLanguage :: forall (m :: * -> *).
    MonadIO m =>
    SegmentPropertiesT -> m LanguageT
    getSegmentPropertiesTLanguage SegmentPropertiesT
    s = IO LanguageT -> m LanguageT
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO LanguageT -> m LanguageT) -> IO LanguageT -> m LanguageT
    forall a b. (a -> b) -> a -> b
    $ SegmentPropertiesT
    -> (Ptr SegmentPropertiesT -> IO LanguageT) -> IO LanguageT
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SegmentPropertiesT
    s ((Ptr SegmentPropertiesT -> IO LanguageT) -> IO LanguageT)
    -> (Ptr SegmentPropertiesT -> IO LanguageT) -> IO LanguageT
    forall a b. (a -> b) -> a -> b
    $ \Ptr SegmentPropertiesT
    ptr -> do
        let val :: Ptr LanguageT
    val = Ptr SegmentPropertiesT
    ptr Ptr SegmentPropertiesT -> Int -> Ptr LanguageT
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8 :: (Ptr HarfBuzz.LanguageT.LanguageT)
        LanguageT
    val' <- ((ManagedPtr LanguageT -> LanguageT)
    -> Ptr LanguageT -> IO LanguageT
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr LanguageT -> LanguageT
    HarfBuzz.LanguageT.LanguageT) Ptr LanguageT
    val
        LanguageT -> IO LanguageT
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return LanguageT
    val'

    #if defined(ENABLE_OVERLOADING)
    data SegmentPropertiesTLanguageFieldInfo
    instance AttrInfo SegmentPropertiesTLanguageFieldInfo where
        type AttrBaseTypeConstraint SegmentPropertiesTLanguageFieldInfo = (~) SegmentPropertiesT
        type AttrAllowedOps SegmentPropertiesTLanguageFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint SegmentPropertiesTLanguageFieldInfo = (~) (Ptr HarfBuzz.LanguageT.LanguageT)
        type AttrTransferTypeConstraint SegmentPropertiesTLanguageFieldInfo = (~)(Ptr HarfBuzz.LanguageT.LanguageT)
        type AttrTransferType SegmentPropertiesTLanguageFieldInfo = (Ptr HarfBuzz.LanguageT.LanguageT)
        type AttrGetType SegmentPropertiesTLanguageFieldInfo = HarfBuzz.LanguageT.LanguageT
        type AttrLabel SegmentPropertiesTLanguageFieldInfo = "language"
        type AttrOrigin SegmentPropertiesTLanguageFieldInfo = SegmentPropertiesT
        attrGet = getSegmentPropertiesTLanguage
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.HarfBuzz.Structs.SegmentPropertiesT.language"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.10/docs/GI-HarfBuzz-Structs-SegmentPropertiesT.html#g:attr:language"
            })

    segmentPropertiesT_language :: AttrLabelProxy "language"
    segmentPropertiesT_language = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList SegmentPropertiesT
    type instance O.AttributeList SegmentPropertiesT = SegmentPropertiesTAttributeList
    type SegmentPropertiesTAttributeList = ('[ '("direction", SegmentPropertiesTDirectionFieldInfo), '("script", SegmentPropertiesTScriptFieldInfo), '("language", SegmentPropertiesTLanguageFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveSegmentPropertiesTMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveSegmentPropertiesTMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveSegmentPropertiesTMethod t SegmentPropertiesT, O.OverloadedMethod info SegmentPropertiesT p) => OL.IsLabel t (SegmentPropertiesT -> 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 ~ ResolveSegmentPropertiesTMethod t SegmentPropertiesT, O.OverloadedMethod info SegmentPropertiesT p, R.HasField t SegmentPropertiesT p) => R.HasField t SegmentPropertiesT p where
        getField = O.overloadedMethod @info

    #endif

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

    #endif