{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- IBuProcessKeyEventData properties.

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

module GI.IBus.Structs.ProcessKeyEventData
    ( 

-- * Exported types
    ProcessKeyEventData(..)                 ,
    newZeroProcessKeyEventData              ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveProcessKeyEventDataMethod        ,
#endif



 -- * Properties


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

    getProcessKeyEventDataKeycode           ,
#if defined(ENABLE_OVERLOADING)
    processKeyEventData_keycode             ,
#endif
    setProcessKeyEventDataKeycode           ,


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

    getProcessKeyEventDataKeyval            ,
#if defined(ENABLE_OVERLOADING)
    processKeyEventData_keyval              ,
#endif
    setProcessKeyEventDataKeyval            ,


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

    getProcessKeyEventDataState             ,
#if defined(ENABLE_OVERLOADING)
    processKeyEventData_state               ,
#endif
    setProcessKeyEventDataState             ,




    ) 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.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


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

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

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


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

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


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

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

#if defined(ENABLE_OVERLOADING)
data ProcessKeyEventDataKeyvalFieldInfo
instance AttrInfo ProcessKeyEventDataKeyvalFieldInfo where
    type AttrBaseTypeConstraint ProcessKeyEventDataKeyvalFieldInfo = (~) ProcessKeyEventData
    type AttrAllowedOps ProcessKeyEventDataKeyvalFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ProcessKeyEventDataKeyvalFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ProcessKeyEventDataKeyvalFieldInfo = (~)Word32
    type AttrTransferType ProcessKeyEventDataKeyvalFieldInfo = Word32
    type AttrGetType ProcessKeyEventDataKeyvalFieldInfo = Word32
    type AttrLabel ProcessKeyEventDataKeyvalFieldInfo = "keyval"
    type AttrOrigin ProcessKeyEventDataKeyvalFieldInfo = ProcessKeyEventData
    attrGet = getProcessKeyEventDataKeyval
    attrSet = setProcessKeyEventDataKeyval
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Structs.ProcessKeyEventData.keyval"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.5/docs/GI-IBus-Structs-ProcessKeyEventData.html#g:attr:keyval"
        })

processKeyEventData_keyval :: AttrLabelProxy "keyval"
processKeyEventData_keyval = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data ProcessKeyEventDataKeycodeFieldInfo
instance AttrInfo ProcessKeyEventDataKeycodeFieldInfo where
    type AttrBaseTypeConstraint ProcessKeyEventDataKeycodeFieldInfo = (~) ProcessKeyEventData
    type AttrAllowedOps ProcessKeyEventDataKeycodeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ProcessKeyEventDataKeycodeFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ProcessKeyEventDataKeycodeFieldInfo = (~)Word32
    type AttrTransferType ProcessKeyEventDataKeycodeFieldInfo = Word32
    type AttrGetType ProcessKeyEventDataKeycodeFieldInfo = Word32
    type AttrLabel ProcessKeyEventDataKeycodeFieldInfo = "keycode"
    type AttrOrigin ProcessKeyEventDataKeycodeFieldInfo = ProcessKeyEventData
    attrGet = getProcessKeyEventDataKeycode
    attrSet = setProcessKeyEventDataKeycode
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Structs.ProcessKeyEventData.keycode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.5/docs/GI-IBus-Structs-ProcessKeyEventData.html#g:attr:keycode"
        })

processKeyEventData_keycode :: AttrLabelProxy "keycode"
processKeyEventData_keycode = 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' processKeyEventData #state
-- @
getProcessKeyEventDataState :: MonadIO m => ProcessKeyEventData -> m Word32
getProcessKeyEventDataState :: forall (m :: * -> *). MonadIO m => ProcessKeyEventData -> m Word32
getProcessKeyEventDataState ProcessKeyEventData
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
$ ProcessKeyEventData
-> (Ptr ProcessKeyEventData -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ProcessKeyEventData
s ((Ptr ProcessKeyEventData -> IO Word32) -> IO Word32)
-> (Ptr ProcessKeyEventData -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr ProcessKeyEventData
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ProcessKeyEventData
ptr Ptr ProcessKeyEventData -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | 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' processKeyEventData [ #state 'Data.GI.Base.Attributes.:=' value ]
-- @
setProcessKeyEventDataState :: MonadIO m => ProcessKeyEventData -> Word32 -> m ()
setProcessKeyEventDataState :: forall (m :: * -> *).
MonadIO m =>
ProcessKeyEventData -> Word32 -> m ()
setProcessKeyEventDataState ProcessKeyEventData
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
$ ProcessKeyEventData -> (Ptr ProcessKeyEventData -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ProcessKeyEventData
s ((Ptr ProcessKeyEventData -> IO ()) -> IO ())
-> (Ptr ProcessKeyEventData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ProcessKeyEventData
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ProcessKeyEventData
ptr Ptr ProcessKeyEventData -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data ProcessKeyEventDataStateFieldInfo
instance AttrInfo ProcessKeyEventDataStateFieldInfo where
    type AttrBaseTypeConstraint ProcessKeyEventDataStateFieldInfo = (~) ProcessKeyEventData
    type AttrAllowedOps ProcessKeyEventDataStateFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ProcessKeyEventDataStateFieldInfo = (~) Word32
    type AttrTransferTypeConstraint ProcessKeyEventDataStateFieldInfo = (~)Word32
    type AttrTransferType ProcessKeyEventDataStateFieldInfo = Word32
    type AttrGetType ProcessKeyEventDataStateFieldInfo = Word32
    type AttrLabel ProcessKeyEventDataStateFieldInfo = "state"
    type AttrOrigin ProcessKeyEventDataStateFieldInfo = ProcessKeyEventData
    attrGet = getProcessKeyEventDataState
    attrSet = setProcessKeyEventDataState
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Structs.ProcessKeyEventData.state"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.5/docs/GI-IBus-Structs-ProcessKeyEventData.html#g:attr:state"
        })

processKeyEventData_state :: AttrLabelProxy "state"
processKeyEventData_state = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ProcessKeyEventData
type instance O.AttributeList ProcessKeyEventData = ProcessKeyEventDataAttributeList
type ProcessKeyEventDataAttributeList = ('[ '("keyval", ProcessKeyEventDataKeyvalFieldInfo), '("keycode", ProcessKeyEventDataKeycodeFieldInfo), '("state", ProcessKeyEventDataStateFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif

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

#endif