    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- This struct defines a single action.  It is for use with
    -- 'GI.Gio.Interfaces.ActionMap.actionMapAddActionEntries'.
    --
    -- The order of the items in the structure are intended to reflect
    -- frequency of use.  It is permissible to use an incomplete initialiser
    -- in order to leave some of the later values as @NULL@.  All values
    -- after /@name@/ are optional.  Additional optional fields may be added in
    -- the future.
    --
    -- See 'GI.Gio.Interfaces.ActionMap.actionMapAddActionEntries' for an example.

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

    module GI.Gio.Structs.ActionEntry
        (

    -- * Exported types
        ActionEntry(..)                         ,
        newZeroActionEntry                      ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveActionEntryMethod                ,
    #endif

     -- * Properties

    -- ** activate #attr:activate#
    -- | the callback to connect to the \"activate\" signal of the action.
    --   Since GLib 2.40, this can be @NULL@ for stateful actions, in which case
    --   the default handler is used. For boolean-stated actions with no
    --   parameter, this is a toggle. For other state types (and parameter type
    --   equal to the state type) this will be a function that just calls
    --   /@changeState@/ (which you should provide).

    #if defined(ENABLE_OVERLOADING)
        actionEntry_activate                    ,
    #endif
        clearActionEntryActivate                ,
        getActionEntryActivate                  ,
        setActionEntryActivate                  ,

    -- ** changeState #attr:changeState#
    -- | the callback to connect to the \"change-state\" signal of the
    --   action.  All stateful actions should provide a handler here; stateless
    --   actions should not.

    #if defined(ENABLE_OVERLOADING)
        actionEntry_changeState                 ,
    #endif
        clearActionEntryChangeState             ,
        getActionEntryChangeState               ,
        setActionEntryChangeState               ,

    -- ** name #attr:name#
    -- | the name of the action

    #if defined(ENABLE_OVERLOADING)
        actionEntry_name                        ,
    #endif
        clearActionEntryName                    ,
        getActionEntryName                      ,
        setActionEntryName                      ,

    -- ** parameterType #attr:parameterType#
    -- | the type of the parameter that must be passed to the
    --   activate function for this action, given as a single GVariant type string
    --   (or @NULL@ for no parameter)

    #if defined(ENABLE_OVERLOADING)
        actionEntry_parameterType               ,
    #endif
        clearActionEntryParameterType           ,
        getActionEntryParameterType             ,
        setActionEntryParameterType             ,

    -- ** state #attr:state#
    -- | the initial state for this action, given in
    --   <http://developer.gnome.org/gio/stable/../glib/gvariant-text-format.html GVariant text format>.  The state is parsed
    --   with no extra type information, so type tags must be added to the string
    --   if they are necessary.  Stateless actions should give @NULL@ here.

    #if defined(ENABLE_OVERLOADING)
        actionEntry_state                       ,
    #endif
        clearActionEntryState                   ,
        getActionEntryState                     ,
        setActionEntryState                     ,

        ) 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.Gio.Callbacks as Gio.Callbacks

    #else
    import qualified GI.Gio.Callbacks as Gio.Callbacks

    #endif

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

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

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

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

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data ActionEntryNameFieldInfo
    instance AttrInfo ActionEntryNameFieldInfo where
        type AttrBaseTypeConstraint ActionEntryNameFieldInfo = (~) ActionEntry
        type AttrAllowedOps ActionEntryNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ActionEntryNameFieldInfo = (~) CString
        type AttrTransferTypeConstraint ActionEntryNameFieldInfo = (~)CString
        type AttrTransferType ActionEntryNameFieldInfo = CString
        type AttrGetType ActionEntryNameFieldInfo = Maybe T.Text
        type AttrLabel ActionEntryNameFieldInfo = "name"
        type AttrOrigin ActionEntryNameFieldInfo = ActionEntry
        attrGet = getActionEntryName
        attrSet = setActionEntryName
        attrConstruct = undefined
        attrClear = clearActionEntryName
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.name"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:name"
            })

    actionEntry_name :: AttrLabelProxy "name"
    actionEntry_name = AttrLabelProxy

    #endif

    -- | Get the value of the “@activate@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' actionEntry #activate
    -- @
    getActionEntryActivate :: MonadIO m => ActionEntry -> m (Maybe Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures)
    getActionEntryActivate :: forall (m :: * -> *).
    MonadIO m =>
    ActionEntry
    -> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
    getActionEntryActivate ActionEntry
    s = IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
    -> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
     -> m (Maybe ActionEntryActivateFieldCallback_WithClosures))
    -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
    -> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ ActionEntry
    -> (Ptr ActionEntry
        -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
    -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ActionEntry
    s ((Ptr ActionEntry
      -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
     -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
    -> (Ptr ActionEntry
        -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures))
    -> IO (Maybe ActionEntryActivateFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ActionEntry
    ptr -> do
        val <- Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    -> IO (FunPtr C_ActionEntryActivateFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ActionEntry
    ptr Ptr ActionEntry
    -> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) :: IO (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ActionEntryActivateFieldCallback
    val' -> do
            let val'' :: ActionEntryActivateFieldCallback_WithClosures
    val'' = FunPtr C_ActionEntryActivateFieldCallback
    -> ActionEntryActivateFieldCallback_WithClosures
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAction a) =>
    FunPtr C_ActionEntryActivateFieldCallback
    -> a -> Maybe GVariant -> Ptr () -> m ()
    Gio.Callbacks.dynamic_ActionEntryActivateFieldCallback FunPtr C_ActionEntryActivateFieldCallback
    val'
            ActionEntryActivateFieldCallback_WithClosures
    -> IO ActionEntryActivateFieldCallback_WithClosures
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ActionEntryActivateFieldCallback_WithClosures
    val''
        return result

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

    -- | Set the value of the “@activate@” 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' #activate
    -- @
    clearActionEntryActivate :: MonadIO m => ActionEntry -> m ()
    clearActionEntryActivate :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
    clearActionEntryActivate ActionEntry
    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
    $ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ActionEntry
    s ((Ptr ActionEntry -> IO ()) -> IO ())
    -> (Ptr ActionEntry -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ActionEntry
    ptr -> do
        Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    -> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ActionEntry
    ptr Ptr ActionEntry
    -> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (FunPtr C_ActionEntryActivateFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data ActionEntryActivateFieldInfo
    instance AttrInfo ActionEntryActivateFieldInfo where
        type AttrBaseTypeConstraint ActionEntryActivateFieldInfo = (~) ActionEntry
        type AttrAllowedOps ActionEntryActivateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ActionEntryActivateFieldInfo = (~) (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
        type AttrTransferTypeConstraint ActionEntryActivateFieldInfo = (~)Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures
        type AttrTransferType ActionEntryActivateFieldInfo = (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
        type AttrGetType ActionEntryActivateFieldInfo = Maybe Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures
        type AttrLabel ActionEntryActivateFieldInfo = "activate"
        type AttrOrigin ActionEntryActivateFieldInfo = ActionEntry
        attrGet = getActionEntryActivate
        attrSet = setActionEntryActivate
        attrConstruct = undefined
        attrClear = clearActionEntryActivate
        attrTransfer _ v = do
            Gio.Callbacks.mk_ActionEntryActivateFieldCallback (Gio.Callbacks.wrap_ActionEntryActivateFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.activate"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:activate"
            })

    actionEntry_activate :: AttrLabelProxy "activate"
    actionEntry_activate = AttrLabelProxy

    #endif

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data ActionEntryParameterTypeFieldInfo
    instance AttrInfo ActionEntryParameterTypeFieldInfo where
        type AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo = (~) ActionEntry
        type AttrAllowedOps ActionEntryParameterTypeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ActionEntryParameterTypeFieldInfo = (~) CString
        type AttrTransferTypeConstraint ActionEntryParameterTypeFieldInfo = (~)CString
        type AttrTransferType ActionEntryParameterTypeFieldInfo = CString
        type AttrGetType ActionEntryParameterTypeFieldInfo = Maybe T.Text
        type AttrLabel ActionEntryParameterTypeFieldInfo = "parameter_type"
        type AttrOrigin ActionEntryParameterTypeFieldInfo = ActionEntry
        attrGet = getActionEntryParameterType
        attrSet = setActionEntryParameterType
        attrConstruct = undefined
        attrClear = clearActionEntryParameterType
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.parameterType"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:parameterType"
            })

    actionEntry_parameterType :: AttrLabelProxy "parameterType"
    actionEntry_parameterType = AttrLabelProxy

    #endif

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

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

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

    #if defined(ENABLE_OVERLOADING)
    data ActionEntryStateFieldInfo
    instance AttrInfo ActionEntryStateFieldInfo where
        type AttrBaseTypeConstraint ActionEntryStateFieldInfo = (~) ActionEntry
        type AttrAllowedOps ActionEntryStateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ActionEntryStateFieldInfo = (~) CString
        type AttrTransferTypeConstraint ActionEntryStateFieldInfo = (~)CString
        type AttrTransferType ActionEntryStateFieldInfo = CString
        type AttrGetType ActionEntryStateFieldInfo = Maybe T.Text
        type AttrLabel ActionEntryStateFieldInfo = "state"
        type AttrOrigin ActionEntryStateFieldInfo = ActionEntry
        attrGet = getActionEntryState
        attrSet = setActionEntryState
        attrConstruct = undefined
        attrClear = clearActionEntryState
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.state"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:state"
            })

    actionEntry_state :: AttrLabelProxy "state"
    actionEntry_state = AttrLabelProxy

    #endif

    -- | Get the value of the “@change_state@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' actionEntry #changeState
    -- @
    getActionEntryChangeState :: MonadIO m => ActionEntry -> m (Maybe Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures)
    getActionEntryChangeState :: forall (m :: * -> *).
    MonadIO m =>
    ActionEntry
    -> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
    getActionEntryChangeState ActionEntry
    s = IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
    -> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
     -> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
    -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
    -> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ ActionEntry
    -> (Ptr ActionEntry
        -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
    -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ActionEntry
    s ((Ptr ActionEntry
      -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
     -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
    -> (Ptr ActionEntry
        -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures))
    -> IO (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \Ptr ActionEntry
    ptr -> do
        val <- Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    -> IO (FunPtr C_ActionEntryActivateFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr ActionEntry
    ptr Ptr ActionEntry
    -> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) :: IO (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
        result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_ActionEntryActivateFieldCallback
    val' -> do
            let val'' :: ActionEntryChangeStateFieldCallback_WithClosures
    val'' = FunPtr C_ActionEntryActivateFieldCallback
    -> ActionEntryChangeStateFieldCallback_WithClosures
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSimpleAction a) =>
    FunPtr C_ActionEntryActivateFieldCallback
    -> a -> GVariant -> Ptr () -> m ()
    Gio.Callbacks.dynamic_ActionEntryChangeStateFieldCallback FunPtr C_ActionEntryActivateFieldCallback
    val'
            ActionEntryChangeStateFieldCallback_WithClosures
    -> IO ActionEntryChangeStateFieldCallback_WithClosures
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ActionEntryChangeStateFieldCallback_WithClosures
    val''
        return result

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

    -- | Set the value of the “@change_state@” 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' #changeState
    -- @
    clearActionEntryChangeState :: MonadIO m => ActionEntry -> m ()
    clearActionEntryChangeState :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
    clearActionEntryChangeState ActionEntry
    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
    $ ActionEntry -> (Ptr ActionEntry -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr ActionEntry
    s ((Ptr ActionEntry -> IO ()) -> IO ())
    -> (Ptr ActionEntry -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr ActionEntry
    ptr -> do
        Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    -> FunPtr C_ActionEntryActivateFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr ActionEntry
    ptr Ptr ActionEntry
    -> Int -> Ptr (FunPtr C_ActionEntryActivateFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) (FunPtr C_ActionEntryActivateFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data ActionEntryChangeStateFieldInfo
    instance AttrInfo ActionEntryChangeStateFieldInfo where
        type AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo = (~) ActionEntry
        type AttrAllowedOps ActionEntryChangeStateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ActionEntryChangeStateFieldInfo = (~) (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
        type AttrTransferTypeConstraint ActionEntryChangeStateFieldInfo = (~)Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures
        type AttrTransferType ActionEntryChangeStateFieldInfo = (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
        type AttrGetType ActionEntryChangeStateFieldInfo = Maybe Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures
        type AttrLabel ActionEntryChangeStateFieldInfo = "change_state"
        type AttrOrigin ActionEntryChangeStateFieldInfo = ActionEntry
        attrGet = getActionEntryChangeState
        attrSet = setActionEntryChangeState
        attrConstruct = undefined
        attrClear = clearActionEntryChangeState
        attrTransfer _ v = do
            Gio.Callbacks.mk_ActionEntryChangeStateFieldCallback (Gio.Callbacks.wrap_ActionEntryChangeStateFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.changeState"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.38/docs/GI-Gio-Structs-ActionEntry.html#g:attr:changeState"
            })

    actionEntry_changeState :: AttrLabelProxy "changeState"
    actionEntry_changeState = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList ActionEntry
    type instance O.AttributeList ActionEntry = ActionEntryAttributeList
    type ActionEntryAttributeList = ('[ '("name", ActionEntryNameFieldInfo), '("activate", ActionEntryActivateFieldInfo), '("parameterType", ActionEntryParameterTypeFieldInfo), '("state", ActionEntryStateFieldInfo), '("changeState", ActionEntryChangeStateFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

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

    #endif

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

    #endif