{-# LANGUAGE TypeApplications #-}


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

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Poppler.Structs.ActionNamed
    ( 

-- * Exported types
    ActionNamed(..)                         ,
    newZeroActionNamed                      ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveActionNamedMethod                ,
#endif




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

#if defined(ENABLE_OVERLOADING)
    actionNamed_namedDest                   ,
#endif
    clearActionNamedNamedDest               ,
    getActionNamedNamedDest                 ,
    setActionNamedNamedDest                 ,


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

#if defined(ENABLE_OVERLOADING)
    actionNamed_title                       ,
#endif
    clearActionNamedTitle                   ,
    getActionNamedTitle                     ,
    setActionNamedTitle                     ,


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

#if defined(ENABLE_OVERLOADING)
    actionNamed_type                        ,
#endif
    getActionNamedType                      ,
    setActionNamedType                      ,




    ) 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.ManagedPtr as B.ManagedPtr
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.Poppler.Enums as Poppler.Enums

-- | Memory-managed wrapper type.
newtype ActionNamed = ActionNamed (ManagedPtr ActionNamed)
    deriving (ActionNamed -> ActionNamed -> Bool
(ActionNamed -> ActionNamed -> Bool)
-> (ActionNamed -> ActionNamed -> Bool) -> Eq ActionNamed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionNamed -> ActionNamed -> Bool
$c/= :: ActionNamed -> ActionNamed -> Bool
== :: ActionNamed -> ActionNamed -> Bool
$c== :: ActionNamed -> ActionNamed -> Bool
Eq)
instance WrappedPtr ActionNamed where
    wrappedPtrCalloc :: IO (Ptr ActionNamed)
wrappedPtrCalloc = Int -> IO (Ptr ActionNamed)
forall a. Int -> IO (Ptr a)
callocBytes Int
24
    wrappedPtrCopy :: ActionNamed -> IO ActionNamed
wrappedPtrCopy = \ActionNamed
p -> ActionNamed
-> (Ptr ActionNamed -> IO ActionNamed) -> IO ActionNamed
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
p (Int -> Ptr ActionNamed -> IO (Ptr ActionNamed)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 (Ptr ActionNamed -> IO (Ptr ActionNamed))
-> (Ptr ActionNamed -> IO ActionNamed)
-> Ptr ActionNamed
-> IO ActionNamed
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ActionNamed -> ActionNamed)
-> Ptr ActionNamed -> IO ActionNamed
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ActionNamed -> ActionNamed
ActionNamed)
    wrappedPtrFree :: Maybe (GDestroyNotify ActionNamed)
wrappedPtrFree = GDestroyNotify ActionNamed -> Maybe (GDestroyNotify ActionNamed)
forall a. a -> Maybe a
Just GDestroyNotify ActionNamed
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `ActionNamed` struct initialized to zero.
newZeroActionNamed :: MonadIO m => m ActionNamed
newZeroActionNamed :: m ActionNamed
newZeroActionNamed = IO ActionNamed -> m ActionNamed
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ActionNamed -> m ActionNamed)
-> IO ActionNamed -> m ActionNamed
forall a b. (a -> b) -> a -> b
$ IO (Ptr ActionNamed)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr ActionNamed)
-> (Ptr ActionNamed -> IO ActionNamed) -> IO ActionNamed
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ActionNamed -> ActionNamed)
-> Ptr ActionNamed -> IO ActionNamed
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ActionNamed -> ActionNamed
ActionNamed

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


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

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

#if defined(ENABLE_OVERLOADING)
data ActionNamedTypeFieldInfo
instance AttrInfo ActionNamedTypeFieldInfo where
    type AttrBaseTypeConstraint ActionNamedTypeFieldInfo = (~) ActionNamed
    type AttrAllowedOps ActionNamedTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ActionNamedTypeFieldInfo = (~) Poppler.Enums.ActionType
    type AttrTransferTypeConstraint ActionNamedTypeFieldInfo = (~)Poppler.Enums.ActionType
    type AttrTransferType ActionNamedTypeFieldInfo = Poppler.Enums.ActionType
    type AttrGetType ActionNamedTypeFieldInfo = Poppler.Enums.ActionType
    type AttrLabel ActionNamedTypeFieldInfo = "type"
    type AttrOrigin ActionNamedTypeFieldInfo = ActionNamed
    attrGet = getActionNamedType
    attrSet = setActionNamedType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

actionNamed_type :: AttrLabelProxy "type"
actionNamed_type = AttrLabelProxy

#endif


-- | Get the value of the “@title@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionNamed #title
-- @
getActionNamedTitle :: MonadIO m => ActionNamed -> m (Maybe T.Text)
getActionNamedTitle :: ActionNamed -> m (Maybe Text)
getActionNamedTitle ActionNamed
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
$ ActionNamed
-> (Ptr ActionNamed -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ActionNamed -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionNamed
ptr Ptr ActionNamed -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
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
$ \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 “@title@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionNamed [ #title 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionNamedTitle :: MonadIO m => ActionNamed -> CString -> m ()
setActionNamedTitle :: ActionNamed -> CString -> m ()
setActionNamedTitle ActionNamed
s 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
$ ActionNamed -> (Ptr ActionNamed -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO ()) -> IO ())
-> (Ptr ActionNamed -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionNamed
ptr Ptr ActionNamed -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
val :: CString)

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

#if defined(ENABLE_OVERLOADING)
data ActionNamedTitleFieldInfo
instance AttrInfo ActionNamedTitleFieldInfo where
    type AttrBaseTypeConstraint ActionNamedTitleFieldInfo = (~) ActionNamed
    type AttrAllowedOps ActionNamedTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionNamedTitleFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionNamedTitleFieldInfo = (~)CString
    type AttrTransferType ActionNamedTitleFieldInfo = CString
    type AttrGetType ActionNamedTitleFieldInfo = Maybe T.Text
    type AttrLabel ActionNamedTitleFieldInfo = "title"
    type AttrOrigin ActionNamedTitleFieldInfo = ActionNamed
    attrGet = getActionNamedTitle
    attrSet = setActionNamedTitle
    attrConstruct = undefined
    attrClear = clearActionNamedTitle
    attrTransfer _ v = do
        return v

actionNamed_title :: AttrLabelProxy "title"
actionNamed_title = AttrLabelProxy

#endif


-- | Get the value of the “@named_dest@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' actionNamed #namedDest
-- @
getActionNamedNamedDest :: MonadIO m => ActionNamed -> m (Maybe T.Text)
getActionNamedNamedDest :: ActionNamed -> m (Maybe Text)
getActionNamedNamedDest ActionNamed
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
$ ActionNamed
-> (Ptr ActionNamed -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr ActionNamed -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionNamed
ptr Ptr ActionNamed -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
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
$ \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 “@named_dest@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionNamed [ #namedDest 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionNamedNamedDest :: MonadIO m => ActionNamed -> CString -> m ()
setActionNamedNamedDest :: ActionNamed -> CString -> m ()
setActionNamedNamedDest ActionNamed
s 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
$ ActionNamed -> (Ptr ActionNamed -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO ()) -> IO ())
-> (Ptr ActionNamed -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionNamed
ptr Ptr ActionNamed -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
val :: CString)

-- | Set the value of the “@named_dest@” 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' #namedDest
-- @
clearActionNamedNamedDest :: MonadIO m => ActionNamed -> m ()
clearActionNamedNamedDest :: ActionNamed -> m ()
clearActionNamedNamedDest ActionNamed
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ActionNamed -> (Ptr ActionNamed -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ActionNamed
s ((Ptr ActionNamed -> IO ()) -> IO ())
-> (Ptr ActionNamed -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ActionNamed
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionNamed
ptr Ptr ActionNamed -> 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 ActionNamedNamedDestFieldInfo
instance AttrInfo ActionNamedNamedDestFieldInfo where
    type AttrBaseTypeConstraint ActionNamedNamedDestFieldInfo = (~) ActionNamed
    type AttrAllowedOps ActionNamedNamedDestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ActionNamedNamedDestFieldInfo = (~) CString
    type AttrTransferTypeConstraint ActionNamedNamedDestFieldInfo = (~)CString
    type AttrTransferType ActionNamedNamedDestFieldInfo = CString
    type AttrGetType ActionNamedNamedDestFieldInfo = Maybe T.Text
    type AttrLabel ActionNamedNamedDestFieldInfo = "named_dest"
    type AttrOrigin ActionNamedNamedDestFieldInfo = ActionNamed
    attrGet = getActionNamedNamedDest
    attrSet = setActionNamedNamedDest
    attrConstruct = undefined
    attrClear = clearActionNamedNamedDest
    attrTransfer _ v = do
        return v

actionNamed_namedDest :: AttrLabelProxy "namedDest"
actionNamed_namedDest = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ActionNamed
type instance O.AttributeList ActionNamed = ActionNamedAttributeList
type ActionNamedAttributeList = ('[ '("type", ActionNamedTypeFieldInfo), '("title", ActionNamedTitleFieldInfo), '("namedDest", ActionNamedNamedDestFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif