    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- /No description available in the introspection data./

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

    module GI.Gtk.Structs.AccelGroupEntry
        (

    -- * Exported types
        AccelGroupEntry(..)                     ,
        newZeroAccelGroupEntry                  ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveAccelGroupEntryMethod            ,
    #endif

     -- * Properties

    -- ** accelPathQuark #attr:accelPathQuark#
    -- | /No description available in the introspection data./

    #if defined(ENABLE_OVERLOADING)
        accelGroupEntry_accelPathQuark          ,
    #endif
        getAccelGroupEntryAccelPathQuark        ,
        setAccelGroupEntryAccelPathQuark        ,

    -- ** closure #attr:closure#
    -- | /No description available in the introspection data./

    #if defined(ENABLE_OVERLOADING)
        accelGroupEntry_closure                 ,
    #endif
        clearAccelGroupEntryClosure             ,
        getAccelGroupEntryClosure               ,
        setAccelGroupEntryClosure               ,

    -- ** key #attr:key#
    -- | /No description available in the introspection data./

    #if defined(ENABLE_OVERLOADING)
        accelGroupEntry_key                     ,
    #endif
        getAccelGroupEntryKey                   ,

        ) 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 qualified GI.Gdk.Flags as Gdk.Flags
    import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelKey as Gtk.AccelKey

    #else
    import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelKey as Gtk.AccelKey

    #endif

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data AccelGroupEntryKeyFieldInfo
    instance AttrInfo AccelGroupEntryKeyFieldInfo where
        type AttrBaseTypeConstraint AccelGroupEntryKeyFieldInfo = (~) AccelGroupEntry
        type AttrAllowedOps AccelGroupEntryKeyFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint AccelGroupEntryKeyFieldInfo = (~) (Ptr Gtk.AccelKey.AccelKey)
        type AttrTransferTypeConstraint AccelGroupEntryKeyFieldInfo = (~)(Ptr Gtk.AccelKey.AccelKey)
        type AttrTransferType AccelGroupEntryKeyFieldInfo = (Ptr Gtk.AccelKey.AccelKey)
        type AttrGetType AccelGroupEntryKeyFieldInfo = Gtk.AccelKey.AccelKey
        type AttrLabel AccelGroupEntryKeyFieldInfo = "key"
        type AttrOrigin AccelGroupEntryKeyFieldInfo = AccelGroupEntry
        attrGet = getAccelGroupEntryKey
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.AccelGroupEntry.key"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-AccelGroupEntry.html#g:attr:key"
            })

    accelGroupEntry_key :: AttrLabelProxy "key"
    accelGroupEntry_key = AttrLabelProxy

    #endif

    -- | Get the value of the “@closure@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' accelGroupEntry #closure
    -- @
    getAccelGroupEntryClosure :: MonadIO m => AccelGroupEntry -> m (Maybe (GClosure ()))
    getAccelGroupEntryClosure :: forall (m :: * -> *).
    MonadIO m =>
    AccelGroupEntry -> m (Maybe (GClosure ()))
    getAccelGroupEntryClosure AccelGroupEntry
    s = IO (Maybe (GClosure ())) -> m (Maybe (GClosure ()))
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe (GClosure ())) -> m (Maybe (GClosure ())))
    -> IO (Maybe (GClosure ())) -> m (Maybe (GClosure ()))
    forall a b. (a -> b) -> a -> b
    $ AccelGroupEntry
    -> (Ptr AccelGroupEntry -> IO (Maybe (GClosure ())))
    -> IO (Maybe (GClosure ()))
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AccelGroupEntry
    s ((Ptr AccelGroupEntry -> IO (Maybe (GClosure ())))
     -> IO (Maybe (GClosure ())))
    -> (Ptr AccelGroupEntry -> IO (Maybe (GClosure ())))
    -> IO (Maybe (GClosure ()))
    forall a b. (a -> b) -> a -> b
    $ \Ptr AccelGroupEntry
    ptr -> do
        val <- Ptr (Ptr (GClosure ())) -> IO (Ptr (GClosure ()))
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr AccelGroupEntry
    ptr Ptr AccelGroupEntry -> Int -> Ptr (Ptr (GClosure ()))
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) :: IO (Ptr (GClosure ()))
        result <- SP.convertIfNonNull val $ \Ptr (GClosure ())
    val' -> do
            val'' <- (Ptr (GClosure ()) -> IO (GClosure ())
    forall a. Ptr (GClosure a) -> IO (GClosure a)
    B.GClosure.newGClosureFromPtr (Ptr (GClosure ()) -> IO (GClosure ()))
    -> (Ptr (GClosure ()) -> Ptr (GClosure ()))
    -> Ptr (GClosure ())
    -> IO (GClosure ())
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Ptr (GClosure ()) -> Ptr (GClosure ())
    forall a b. Ptr a -> Ptr b
    FP.castPtr) Ptr (GClosure ())
    val'
            return val''
        return result

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

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

    #if defined(ENABLE_OVERLOADING)
    data AccelGroupEntryClosureFieldInfo
    instance AttrInfo AccelGroupEntryClosureFieldInfo where
        type AttrBaseTypeConstraint AccelGroupEntryClosureFieldInfo = (~) AccelGroupEntry
        type AttrAllowedOps AccelGroupEntryClosureFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint AccelGroupEntryClosureFieldInfo = (~) (Ptr (GClosure ()))
        type AttrTransferTypeConstraint AccelGroupEntryClosureFieldInfo = (~)(Ptr (GClosure ()))
        type AttrTransferType AccelGroupEntryClosureFieldInfo = (Ptr (GClosure ()))
        type AttrGetType AccelGroupEntryClosureFieldInfo = Maybe (GClosure ())
        type AttrLabel AccelGroupEntryClosureFieldInfo = "closure"
        type AttrOrigin AccelGroupEntryClosureFieldInfo = AccelGroupEntry
        attrGet = getAccelGroupEntryClosure
        attrSet = setAccelGroupEntryClosure
        attrConstruct = undefined
        attrClear = clearAccelGroupEntryClosure
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.AccelGroupEntry.closure"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-AccelGroupEntry.html#g:attr:closure"
            })

    accelGroupEntry_closure :: AttrLabelProxy "closure"
    accelGroupEntry_closure = AttrLabelProxy

    #endif

    -- | Get the value of the “@accel_path_quark@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' accelGroupEntry #accelPathQuark
    -- @
    getAccelGroupEntryAccelPathQuark :: MonadIO m => AccelGroupEntry -> m Word32
    getAccelGroupEntryAccelPathQuark :: forall (m :: * -> *). MonadIO m => AccelGroupEntry -> m Word32
    getAccelGroupEntryAccelPathQuark AccelGroupEntry
    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
    $ AccelGroupEntry -> (Ptr AccelGroupEntry -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AccelGroupEntry
    s ((Ptr AccelGroupEntry -> IO Word32) -> IO Word32)
    -> (Ptr AccelGroupEntry -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr AccelGroupEntry
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr AccelGroupEntry
    ptr Ptr AccelGroupEntry -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) :: IO Word32
        return val

    -- | Set the value of the “@accel_path_quark@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' accelGroupEntry [ #accelPathQuark 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setAccelGroupEntryAccelPathQuark :: MonadIO m => AccelGroupEntry -> Word32 -> m ()
    setAccelGroupEntryAccelPathQuark :: forall (m :: * -> *).
    MonadIO m =>
    AccelGroupEntry -> Word32 -> m ()
    setAccelGroupEntryAccelPathQuark AccelGroupEntry
    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
    $ AccelGroupEntry -> (Ptr AccelGroupEntry -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr AccelGroupEntry
    s ((Ptr AccelGroupEntry -> IO ()) -> IO ())
    -> (Ptr AccelGroupEntry -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr AccelGroupEntry
    ptr -> do
        Ptr Word32 -> Word32 -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr AccelGroupEntry
    ptr Ptr AccelGroupEntry -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (Word32
    val :: Word32)

    #if defined(ENABLE_OVERLOADING)
    data AccelGroupEntryAccelPathQuarkFieldInfo
    instance AttrInfo AccelGroupEntryAccelPathQuarkFieldInfo where
        type AttrBaseTypeConstraint AccelGroupEntryAccelPathQuarkFieldInfo = (~) AccelGroupEntry
        type AttrAllowedOps AccelGroupEntryAccelPathQuarkFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint AccelGroupEntryAccelPathQuarkFieldInfo = (~) Word32
        type AttrTransferTypeConstraint AccelGroupEntryAccelPathQuarkFieldInfo = (~)Word32
        type AttrTransferType AccelGroupEntryAccelPathQuarkFieldInfo = Word32
        type AttrGetType AccelGroupEntryAccelPathQuarkFieldInfo = Word32
        type AttrLabel AccelGroupEntryAccelPathQuarkFieldInfo = "accel_path_quark"
        type AttrOrigin AccelGroupEntryAccelPathQuarkFieldInfo = AccelGroupEntry
        attrGet = getAccelGroupEntryAccelPathQuark
        attrSet = setAccelGroupEntryAccelPathQuark
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Structs.AccelGroupEntry.accelPathQuark"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-AccelGroupEntry.html#g:attr:accelPathQuark"
            })

    accelGroupEntry_accelPathQuark :: AttrLabelProxy "accelPathQuark"
    accelGroupEntry_accelPathQuark = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList AccelGroupEntry
    type instance O.AttributeList AccelGroupEntry = AccelGroupEntryAttributeList
    type AccelGroupEntryAttributeList = ('[ '("key", AccelGroupEntryKeyFieldInfo), '("closure", AccelGroupEntryClosureFieldInfo), '("accelPathQuark", AccelGroupEntryAccelPathQuarkFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

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

    #endif

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

    #endif