    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    The 'GI.Gdk.Objects.Device.Device' object represents a single input device, such
    as a keyboard, a mouse, a touchpad, etc.

    See the 'GI.Gdk.Objects.DeviceManager.DeviceManager' documentation for more information
    about the various kinds of master and slave devices, and their
    relationships.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gdk.Objects.Device
        (

    -- * Exported types
        Device(..)                              ,
        IsDevice                                ,
        toDevice                                ,
        noDevice                                ,

     -- * Methods
    -- ** getAssociatedDevice #method:getAssociatedDevice#

    #if ENABLE_OVERLOADING
        DeviceGetAssociatedDeviceMethodInfo     ,
    #endif
        deviceGetAssociatedDevice               ,

    -- ** getAxes #method:getAxes#

    #if ENABLE_OVERLOADING
        DeviceGetAxesMethodInfo                 ,
    #endif
        deviceGetAxes                           ,

    -- ** getAxisUse #method:getAxisUse#

    #if ENABLE_OVERLOADING
        DeviceGetAxisUseMethodInfo              ,
    #endif
        deviceGetAxisUse                        ,

    -- ** getDeviceType #method:getDeviceType#

    #if ENABLE_OVERLOADING
        DeviceGetDeviceTypeMethodInfo           ,
    #endif
        deviceGetDeviceType                     ,

    -- ** getDisplay #method:getDisplay#

    #if ENABLE_OVERLOADING
        DeviceGetDisplayMethodInfo              ,
    #endif
        deviceGetDisplay                        ,

    -- ** getHasCursor #method:getHasCursor#

    #if ENABLE_OVERLOADING
        DeviceGetHasCursorMethodInfo            ,
    #endif
        deviceGetHasCursor                      ,

    -- ** getKey #method:getKey#

    #if ENABLE_OVERLOADING
        DeviceGetKeyMethodInfo                  ,
    #endif
        deviceGetKey                            ,

    -- ** getLastEventWindow #method:getLastEventWindow#

    #if ENABLE_OVERLOADING
        DeviceGetLastEventWindowMethodInfo      ,
    #endif
        deviceGetLastEventWindow                ,

    -- ** getMode #method:getMode#

    #if ENABLE_OVERLOADING
        DeviceGetModeMethodInfo                 ,
    #endif
        deviceGetMode                           ,

    -- ** getNAxes #method:getNAxes#

    #if ENABLE_OVERLOADING
        DeviceGetNAxesMethodInfo                ,
    #endif
        deviceGetNAxes                          ,

    -- ** getNKeys #method:getNKeys#

    #if ENABLE_OVERLOADING
        DeviceGetNKeysMethodInfo                ,
    #endif
        deviceGetNKeys                          ,

    -- ** getName #method:getName#

    #if ENABLE_OVERLOADING
        DeviceGetNameMethodInfo                 ,
    #endif
        deviceGetName                           ,

    -- ** getPosition #method:getPosition#

    #if ENABLE_OVERLOADING
        DeviceGetPositionMethodInfo             ,
    #endif
        deviceGetPosition                       ,

    -- ** getPositionDouble #method:getPositionDouble#

    #if ENABLE_OVERLOADING
        DeviceGetPositionDoubleMethodInfo       ,
    #endif
        deviceGetPositionDouble                 ,

    -- ** getProductId #method:getProductId#

    #if ENABLE_OVERLOADING
        DeviceGetProductIdMethodInfo            ,
    #endif
        deviceGetProductId                      ,

    -- ** getSeat #method:getSeat#

    #if ENABLE_OVERLOADING
        DeviceGetSeatMethodInfo                 ,
    #endif
        deviceGetSeat                           ,

    -- ** getSource #method:getSource#

    #if ENABLE_OVERLOADING
        DeviceGetSourceMethodInfo               ,
    #endif
        deviceGetSource                         ,

    -- ** getVendorId #method:getVendorId#

    #if ENABLE_OVERLOADING
        DeviceGetVendorIdMethodInfo             ,
    #endif
        deviceGetVendorId                       ,

    -- ** getWindowAtPosition #method:getWindowAtPosition#

    #if ENABLE_OVERLOADING
        DeviceGetWindowAtPositionMethodInfo     ,
    #endif
        deviceGetWindowAtPosition               ,

    -- ** getWindowAtPositionDouble #method:getWindowAtPositionDouble#

    #if ENABLE_OVERLOADING
        DeviceGetWindowAtPositionDoubleMethodInfo,
    #endif
        deviceGetWindowAtPositionDouble         ,

    -- ** grab #method:grab#

    #if ENABLE_OVERLOADING
        DeviceGrabMethodInfo                    ,
    #endif
        deviceGrab                              ,

    -- ** grabInfoLibgtkOnly #method:grabInfoLibgtkOnly#

        deviceGrabInfoLibgtkOnly                ,

    -- ** listAxes #method:listAxes#

    #if ENABLE_OVERLOADING
        DeviceListAxesMethodInfo                ,
    #endif
        deviceListAxes                          ,

    -- ** listSlaveDevices #method:listSlaveDevices#

    #if ENABLE_OVERLOADING
        DeviceListSlaveDevicesMethodInfo        ,
    #endif
        deviceListSlaveDevices                  ,

    -- ** setAxisUse #method:setAxisUse#

    #if ENABLE_OVERLOADING
        DeviceSetAxisUseMethodInfo              ,
    #endif
        deviceSetAxisUse                        ,

    -- ** setKey #method:setKey#

    #if ENABLE_OVERLOADING
        DeviceSetKeyMethodInfo                  ,
    #endif
        deviceSetKey                            ,

    -- ** setMode #method:setMode#

    #if ENABLE_OVERLOADING
        DeviceSetModeMethodInfo                 ,
    #endif
        deviceSetMode                           ,

    -- ** ungrab #method:ungrab#

    #if ENABLE_OVERLOADING
        DeviceUngrabMethodInfo                  ,
    #endif
        deviceUngrab                            ,

    -- ** warp #method:warp#

    #if ENABLE_OVERLOADING
        DeviceWarpMethodInfo                    ,
    #endif
        deviceWarp                              ,

     -- * Properties
    -- ** associatedDevice #attr:associatedDevice#
    {- | Associated pointer or keyboard with this device, if any. Devices of type @/GDK_DEVICE_TYPE_MASTER/@
    always come in keyboard\/pointer pairs. Other device types will have a 'Nothing' associated device.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceAssociatedDevicePropertyInfo      ,
    #endif
    #if ENABLE_OVERLOADING
        deviceAssociatedDevice                  ,
    #endif
        getDeviceAssociatedDevice               ,

    -- ** axes #attr:axes#
    {- | The axes currently available for this device.

    /Since: 3.22/
    -}
    #if ENABLE_OVERLOADING
        DeviceAxesPropertyInfo                  ,
    #endif
    #if ENABLE_OVERLOADING
        deviceAxes                              ,
    #endif
        getDeviceAxes                           ,

    -- ** deviceManager #attr:deviceManager#
    {- | The 'GI.Gdk.Objects.DeviceManager.DeviceManager' the 'GI.Gdk.Objects.Device.Device' pertains to.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceDeviceManagerPropertyInfo         ,
    #endif
        constructDeviceDeviceManager            ,
    #if ENABLE_OVERLOADING
        deviceDeviceManager                     ,
    #endif
        getDeviceDeviceManager                  ,

    -- ** display #attr:display#
    {- | The 'GI.Gdk.Objects.Display.Display' the 'GI.Gdk.Objects.Device.Device' pertains to.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceDisplayPropertyInfo               ,
    #endif
        constructDeviceDisplay                  ,
    #if ENABLE_OVERLOADING
        deviceDisplay                           ,
    #endif
        getDeviceDisplay                        ,

    -- ** hasCursor #attr:hasCursor#
    {- | Whether the device is represented by a cursor on the screen. Devices of type
    'GI.Gdk.Enums.DeviceTypeMaster' will have 'True' here.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceHasCursorPropertyInfo             ,
    #endif
        constructDeviceHasCursor                ,
    #if ENABLE_OVERLOADING
        deviceHasCursor                         ,
    #endif
        getDeviceHasCursor                      ,

    -- ** inputMode #attr:inputMode#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        DeviceInputModePropertyInfo             ,
    #endif
        constructDeviceInputMode                ,
    #if ENABLE_OVERLOADING
        deviceInputMode                         ,
    #endif
        getDeviceInputMode                      ,
        setDeviceInputMode                      ,

    -- ** inputSource #attr:inputSource#
    {- | Source type for the device.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceInputSourcePropertyInfo           ,
    #endif
        constructDeviceInputSource              ,
    #if ENABLE_OVERLOADING
        deviceInputSource                       ,
    #endif
        getDeviceInputSource                    ,

    -- ** nAxes #attr:nAxes#
    {- | Number of axes in the device.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceNAxesPropertyInfo                 ,
    #endif
    #if ENABLE_OVERLOADING
        deviceNAxes                             ,
    #endif
        getDeviceNAxes                          ,

    -- ** name #attr:name#
    {- | The device name.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceNamePropertyInfo                  ,
    #endif
        constructDeviceName                     ,
    #if ENABLE_OVERLOADING
        deviceName                              ,
    #endif
        getDeviceName                           ,

    -- ** numTouches #attr:numTouches#
    {- | The maximal number of concurrent touches on a touch device.
    Will be 0 if the device is not a touch device or if the number
    of touches is unknown.

    /Since: 3.20/
    -}
    #if ENABLE_OVERLOADING
        DeviceNumTouchesPropertyInfo            ,
    #endif
        constructDeviceNumTouches               ,
    #if ENABLE_OVERLOADING
        deviceNumTouches                        ,
    #endif
        getDeviceNumTouches                     ,

    -- ** productId #attr:productId#
    {- | Product ID of this device, see 'GI.Gdk.Objects.Device.deviceGetProductId'.

    /Since: 3.16/
    -}
    #if ENABLE_OVERLOADING
        DeviceProductIdPropertyInfo             ,
    #endif
        constructDeviceProductId                ,
    #if ENABLE_OVERLOADING
        deviceProductId                         ,
    #endif
        getDeviceProductId                      ,

    -- ** seat #attr:seat#
    {- | 'GI.Gdk.Objects.Seat.Seat' of this device.

    /Since: 3.20/
    -}
    #if ENABLE_OVERLOADING
        DeviceSeatPropertyInfo                  ,
    #endif
        clearDeviceSeat                         ,
        constructDeviceSeat                     ,
    #if ENABLE_OVERLOADING
        deviceSeat                              ,
    #endif
        getDeviceSeat                           ,
        setDeviceSeat                           ,

    -- ** tool #attr:tool#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        DeviceToolPropertyInfo                  ,
    #endif
    #if ENABLE_OVERLOADING
        deviceTool                              ,
    #endif
        getDeviceTool                           ,

    -- ** type #attr:type#
    {- | Device role in the device manager.

    /Since: 3.0/
    -}
    #if ENABLE_OVERLOADING
        DeviceTypePropertyInfo                  ,
    #endif
        constructDeviceType                     ,
    #if ENABLE_OVERLOADING
        deviceType                              ,
    #endif
        getDeviceType                           ,

    -- ** vendorId #attr:vendorId#
    {- | Vendor ID of this device, see 'GI.Gdk.Objects.Device.deviceGetVendorId'.

    /Since: 3.16/
    -}
    #if ENABLE_OVERLOADING
        DeviceVendorIdPropertyInfo              ,
    #endif
        constructDeviceVendorId                 ,
    #if ENABLE_OVERLOADING
        deviceVendorId                          ,
    #endif
        getDeviceVendorId                       ,

     -- * Signals
    -- ** changed #signal:changed#

        C_DeviceChangedCallback                 ,
        DeviceChangedCallback                   ,
    #if ENABLE_OVERLOADING
        DeviceChangedSignalInfo                 ,
    #endif
        afterDeviceChanged                      ,
        genClosure_DeviceChanged                ,
        mk_DeviceChangedCallback                ,
        noDeviceChangedCallback                 ,
        onDeviceChanged                         ,
        wrap_DeviceChangedCallback              ,

    -- ** toolChanged #signal:toolChanged#

        C_DeviceToolChangedCallback             ,
        DeviceToolChangedCallback               ,
    #if ENABLE_OVERLOADING
        DeviceToolChangedSignalInfo             ,
    #endif
        afterDeviceToolChanged                  ,
        genClosure_DeviceToolChanged            ,
        mk_DeviceToolChangedCallback            ,
        noDeviceToolChangedCallback             ,
        onDeviceToolChanged                     ,
        wrap_DeviceToolChangedCallback          ,

        ) 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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
    import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
    import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceManager as Gdk.DeviceManager
    import {-# SOURCE #-} qualified GI.Gdk.Objects.DeviceTool as Gdk.DeviceTool
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Screen as Gdk.Screen
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Seat as Gdk.Seat
    import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
    import {-# SOURCE #-} qualified GI.Gdk.Structs.Atom as Gdk.Atom

    -- | Memory-managed wrapper type.
    newtype Device = Device (ManagedPtr Device)
    foreign import ccall "gdk_device_get_type"
        c_gdk_device_get_type :: IO GType

    instance GObject Device where
        gobjectType _ = c_gdk_device_get_type

    -- | Type class for types which can be safely cast to `Device`, for instance with `toDevice`.
    class GObject o => IsDevice o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Device a) =>
        IsDevice a
    #endif
    instance IsDevice Device
    instance GObject.Object.IsObject Device

    -- | Cast to `Device`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toDevice :: (MonadIO m, IsDevice o) => o -> m Device
    toDevice = liftIO . unsafeCastTo Device

    -- | A convenience alias for `Nothing` :: `Maybe` `Device`.
    noDevice :: Maybe Device
    noDevice = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveDeviceMethod (t :: Symbol) (o :: *) :: * where
        ResolveDeviceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveDeviceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveDeviceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveDeviceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveDeviceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveDeviceMethod "grab" o = DeviceGrabMethodInfo
        ResolveDeviceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveDeviceMethod "listAxes" o = DeviceListAxesMethodInfo
        ResolveDeviceMethod "listSlaveDevices" o = DeviceListSlaveDevicesMethodInfo
        ResolveDeviceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveDeviceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveDeviceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveDeviceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveDeviceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveDeviceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveDeviceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveDeviceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveDeviceMethod "ungrab" o = DeviceUngrabMethodInfo
        ResolveDeviceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveDeviceMethod "warp" o = DeviceWarpMethodInfo
        ResolveDeviceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveDeviceMethod "getAssociatedDevice" o = DeviceGetAssociatedDeviceMethodInfo
        ResolveDeviceMethod "getAxes" o = DeviceGetAxesMethodInfo
        ResolveDeviceMethod "getAxisUse" o = DeviceGetAxisUseMethodInfo
        ResolveDeviceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveDeviceMethod "getDeviceType" o = DeviceGetDeviceTypeMethodInfo
        ResolveDeviceMethod "getDisplay" o = DeviceGetDisplayMethodInfo
        ResolveDeviceMethod "getHasCursor" o = DeviceGetHasCursorMethodInfo
        ResolveDeviceMethod "getKey" o = DeviceGetKeyMethodInfo
        ResolveDeviceMethod "getLastEventWindow" o = DeviceGetLastEventWindowMethodInfo
        ResolveDeviceMethod "getMode" o = DeviceGetModeMethodInfo
        ResolveDeviceMethod "getNAxes" o = DeviceGetNAxesMethodInfo
        ResolveDeviceMethod "getNKeys" o = DeviceGetNKeysMethodInfo
        ResolveDeviceMethod "getName" o = DeviceGetNameMethodInfo
        ResolveDeviceMethod "getPosition" o = DeviceGetPositionMethodInfo
        ResolveDeviceMethod "getPositionDouble" o = DeviceGetPositionDoubleMethodInfo
        ResolveDeviceMethod "getProductId" o = DeviceGetProductIdMethodInfo
        ResolveDeviceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveDeviceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveDeviceMethod "getSeat" o = DeviceGetSeatMethodInfo
        ResolveDeviceMethod "getSource" o = DeviceGetSourceMethodInfo
        ResolveDeviceMethod "getVendorId" o = DeviceGetVendorIdMethodInfo
        ResolveDeviceMethod "getWindowAtPosition" o = DeviceGetWindowAtPositionMethodInfo
        ResolveDeviceMethod "getWindowAtPositionDouble" o = DeviceGetWindowAtPositionDoubleMethodInfo
        ResolveDeviceMethod "setAxisUse" o = DeviceSetAxisUseMethodInfo
        ResolveDeviceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveDeviceMethod "setKey" o = DeviceSetKeyMethodInfo
        ResolveDeviceMethod "setMode" o = DeviceSetModeMethodInfo
        ResolveDeviceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveDeviceMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveDeviceMethod t Device, O.MethodInfo info Device p) => O.IsLabelProxy t (Device -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveDeviceMethod t Device, O.MethodInfo info Device p) => O.IsLabel t (Device -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif

    -- signal Device::changed
    {- |
    The ::changed signal is emitted either when the 'GI.Gdk.Objects.Device.Device'
    has changed the number of either axes or keys. For example
    In X this will normally happen when the slave device routing
    events through the master device changes (for example, user
    switches from the USB mouse to a tablet), in that case the
    master device will change to reflect the new slave device
    axes and keys.
    -}
    type DeviceChangedCallback =
        IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DeviceChangedCallback`@.
    noDeviceChangedCallback :: Maybe DeviceChangedCallback
    noDeviceChangedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_DeviceChangedCallback =
        Ptr () ->                               -- object
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_DeviceChangedCallback`.
    foreign import ccall "wrapper"
        mk_DeviceChangedCallback :: C_DeviceChangedCallback -> IO (FunPtr C_DeviceChangedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_DeviceChanged :: DeviceChangedCallback -> IO Closure
    genClosure_DeviceChanged cb = do
        let cb' = wrap_DeviceChangedCallback cb
        mk_DeviceChangedCallback cb' >>= newCClosure

    -- | Wrap a `DeviceChangedCallback` into a `C_DeviceChangedCallback`.
    wrap_DeviceChangedCallback ::
        DeviceChangedCallback ->
        C_DeviceChangedCallback
    wrap_DeviceChangedCallback _cb _ _ = do
        _cb

    {- |
    Connect a signal handler for the “@changed@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' device #changed callback
    @
    -}
    onDeviceChanged :: (IsDevice a, MonadIO m) => a -> DeviceChangedCallback -> m SignalHandlerId
    onDeviceChanged obj cb = liftIO $ do
        let cb' = wrap_DeviceChangedCallback cb
        cb'' <- mk_DeviceChangedCallback cb'
        connectSignalFunPtr obj "changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@changed@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' device #changed callback
    @
    -}
    afterDeviceChanged :: (IsDevice a, MonadIO m) => a -> DeviceChangedCallback -> m SignalHandlerId
    afterDeviceChanged obj cb = liftIO $ do
        let cb' = wrap_DeviceChangedCallback cb
        cb'' <- mk_DeviceChangedCallback cb'
        connectSignalFunPtr obj "changed" cb'' SignalConnectAfter

    -- signal Device::tool-changed
    {- |
    The ::tool-changed signal is emitted on pen\/eraser
    @/GdkDevices/@ whenever tools enter or leave proximity.

    /Since: 3.22/
    -}
    type DeviceToolChangedCallback =
        Gdk.DeviceTool.DeviceTool
        {- ^ /@tool@/: The new current tool -}
        -> IO ()

    -- | A convenience synonym for @`Nothing` :: `Maybe` `DeviceToolChangedCallback`@.
    noDeviceToolChangedCallback :: Maybe DeviceToolChangedCallback
    noDeviceToolChangedCallback = Nothing

    -- | Type for the callback on the (unwrapped) C side.
    type C_DeviceToolChangedCallback =
        Ptr () ->                               -- object
        Ptr Gdk.DeviceTool.DeviceTool ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_DeviceToolChangedCallback`.
    foreign import ccall "wrapper"
        mk_DeviceToolChangedCallback :: C_DeviceToolChangedCallback -> IO (FunPtr C_DeviceToolChangedCallback)

    -- | Wrap the callback into a `Closure`.
    genClosure_DeviceToolChanged :: DeviceToolChangedCallback -> IO Closure
    genClosure_DeviceToolChanged cb = do
        let cb' = wrap_DeviceToolChangedCallback cb
        mk_DeviceToolChangedCallback cb' >>= newCClosure

    -- | Wrap a `DeviceToolChangedCallback` into a `C_DeviceToolChangedCallback`.
    wrap_DeviceToolChangedCallback ::
        DeviceToolChangedCallback ->
        C_DeviceToolChangedCallback
    wrap_DeviceToolChangedCallback _cb _ tool _ = do
        tool' <- (newObject Gdk.DeviceTool.DeviceTool) tool
        _cb  tool'

    {- |
    Connect a signal handler for the “@tool-changed@” signal, to be run before the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.on' device #toolChanged callback
    @
    -}
    onDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> DeviceToolChangedCallback -> m SignalHandlerId
    onDeviceToolChanged obj cb = liftIO $ do
        let cb' = wrap_DeviceToolChangedCallback cb
        cb'' <- mk_DeviceToolChangedCallback cb'
        connectSignalFunPtr obj "tool-changed" cb'' SignalConnectBefore

    {- |
    Connect a signal handler for the “@tool-changed@” signal, to be run after the default handler.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Signals.after' device #toolChanged callback
    @
    -}
    afterDeviceToolChanged :: (IsDevice a, MonadIO m) => a -> DeviceToolChangedCallback -> m SignalHandlerId
    afterDeviceToolChanged obj cb = liftIO $ do
        let cb' = wrap_DeviceToolChangedCallback cb
        cb'' <- mk_DeviceToolChangedCallback cb'
        connectSignalFunPtr obj "tool-changed" cb'' SignalConnectAfter

    -- VVV Prop "associated-device"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Device"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Just True,Nothing)

    {- |
    Get the value of the “@associated-device@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #associatedDevice
    @
    -}
    getDeviceAssociatedDevice :: (MonadIO m, IsDevice o) => o -> m (Maybe Device)
    getDeviceAssociatedDevice obj = liftIO $ getObjectPropertyObject obj "associated-device" Device

    #if ENABLE_OVERLOADING
    data DeviceAssociatedDevicePropertyInfo
    instance AttrInfo DeviceAssociatedDevicePropertyInfo where
        type AttrAllowedOps DeviceAssociatedDevicePropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceAssociatedDevicePropertyInfo = (~) ()
        type AttrBaseTypeConstraint DeviceAssociatedDevicePropertyInfo = IsDevice
        type AttrGetType DeviceAssociatedDevicePropertyInfo = (Maybe Device)
        type AttrLabel DeviceAssociatedDevicePropertyInfo = "associated-device"
        type AttrOrigin DeviceAssociatedDevicePropertyInfo = Device
        attrGet _ = getDeviceAssociatedDevice
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "axes"
       -- Type: TInterface (Name {namespace = "Gdk", name = "AxisFlags"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@axes@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #axes
    @
    -}
    getDeviceAxes :: (MonadIO m, IsDevice o) => o -> m [Gdk.Flags.AxisFlags]
    getDeviceAxes obj = liftIO $ getObjectPropertyFlags obj "axes"

    #if ENABLE_OVERLOADING
    data DeviceAxesPropertyInfo
    instance AttrInfo DeviceAxesPropertyInfo where
        type AttrAllowedOps DeviceAxesPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint DeviceAxesPropertyInfo = (~) ()
        type AttrBaseTypeConstraint DeviceAxesPropertyInfo = IsDevice
        type AttrGetType DeviceAxesPropertyInfo = [Gdk.Flags.AxisFlags]
        type AttrLabel DeviceAxesPropertyInfo = "axes"
        type AttrOrigin DeviceAxesPropertyInfo = Device
        attrGet _ = getDeviceAxes
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "device-manager"
       -- Type: TInterface (Name {namespace = "Gdk", name = "DeviceManager"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@device-manager@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #deviceManager
    @
    -}
    getDeviceDeviceManager :: (MonadIO m, IsDevice o) => o -> m (Maybe Gdk.DeviceManager.DeviceManager)
    getDeviceDeviceManager obj = liftIO $ getObjectPropertyObject obj "device-manager" Gdk.DeviceManager.DeviceManager

    {- |
    Construct a `GValueConstruct` with valid value for the “@device-manager@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceDeviceManager :: (IsDevice o, Gdk.DeviceManager.IsDeviceManager a) => a -> IO (GValueConstruct o)
    constructDeviceDeviceManager val = constructObjectPropertyObject "device-manager" (Just val)

    #if ENABLE_OVERLOADING
    data DeviceDeviceManagerPropertyInfo
    instance AttrInfo DeviceDeviceManagerPropertyInfo where
        type AttrAllowedOps DeviceDeviceManagerPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceDeviceManagerPropertyInfo = Gdk.DeviceManager.IsDeviceManager
        type AttrBaseTypeConstraint DeviceDeviceManagerPropertyInfo = IsDevice
        type AttrGetType DeviceDeviceManagerPropertyInfo = (Maybe Gdk.DeviceManager.DeviceManager)
        type AttrLabel DeviceDeviceManagerPropertyInfo = "device-manager"
        type AttrOrigin DeviceDeviceManagerPropertyInfo = Device
        attrGet _ = getDeviceDeviceManager
        attrSet _ = undefined
        attrConstruct _ = constructDeviceDeviceManager
        attrClear _ = undefined
    #endif

    -- VVV Prop "display"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Display"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@display@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #display
    @
    -}
    getDeviceDisplay :: (MonadIO m, IsDevice o) => o -> m Gdk.Display.Display
    getDeviceDisplay obj = liftIO $ checkUnexpectedNothing "getDeviceDisplay" $ getObjectPropertyObject obj "display" Gdk.Display.Display

    {- |
    Construct a `GValueConstruct` with valid value for the “@display@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceDisplay :: (IsDevice o, Gdk.Display.IsDisplay a) => a -> IO (GValueConstruct o)
    constructDeviceDisplay val = constructObjectPropertyObject "display" (Just val)

    #if ENABLE_OVERLOADING
    data DeviceDisplayPropertyInfo
    instance AttrInfo DeviceDisplayPropertyInfo where
        type AttrAllowedOps DeviceDisplayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceDisplayPropertyInfo = Gdk.Display.IsDisplay
        type AttrBaseTypeConstraint DeviceDisplayPropertyInfo = IsDevice
        type AttrGetType DeviceDisplayPropertyInfo = Gdk.Display.Display
        type AttrLabel DeviceDisplayPropertyInfo = "display"
        type AttrOrigin DeviceDisplayPropertyInfo = Device
        attrGet _ = getDeviceDisplay
        attrSet _ = undefined
        attrConstruct _ = constructDeviceDisplay
        attrClear _ = undefined
    #endif

    -- VVV Prop "has-cursor"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@has-cursor@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #hasCursor
    @
    -}
    getDeviceHasCursor :: (MonadIO m, IsDevice o) => o -> m Bool
    getDeviceHasCursor obj = liftIO $ getObjectPropertyBool obj "has-cursor"

    {- |
    Construct a `GValueConstruct` with valid value for the “@has-cursor@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceHasCursor :: (IsDevice o) => Bool -> IO (GValueConstruct o)
    constructDeviceHasCursor val = constructObjectPropertyBool "has-cursor" val

    #if ENABLE_OVERLOADING
    data DeviceHasCursorPropertyInfo
    instance AttrInfo DeviceHasCursorPropertyInfo where
        type AttrAllowedOps DeviceHasCursorPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DeviceHasCursorPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint DeviceHasCursorPropertyInfo = IsDevice
        type AttrGetType DeviceHasCursorPropertyInfo = Bool
        type AttrLabel DeviceHasCursorPropertyInfo = "has-cursor"
        type AttrOrigin DeviceHasCursorPropertyInfo = Device
        attrGet _ = getDeviceHasCursor
        attrSet _ = undefined
        attrConstruct _ = constructDeviceHasCursor
        attrClear _ = undefined
    #endif

    -- VVV Prop "input-mode"
       -- Type: TInterface (Name {namespace = "Gdk", name = "InputMode"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@input-mode@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #inputMode
    @
    -}
    getDeviceInputMode :: (MonadIO m, IsDevice o) => o -> m Gdk.Enums.InputMode
    getDeviceInputMode obj = liftIO $ getObjectPropertyEnum obj "input-mode"

    {- |
    Set the value of the “@input-mode@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' device [ #inputMode 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDeviceInputMode :: (MonadIO m, IsDevice o) => o -> Gdk.Enums.InputMode -> m ()
    setDeviceInputMode obj val = liftIO $ setObjectPropertyEnum obj "input-mode" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@input-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceInputMode :: (IsDevice o) => Gdk.Enums.InputMode -> IO (GValueConstruct o)
    constructDeviceInputMode val = constructObjectPropertyEnum "input-mode" val

    #if ENABLE_OVERLOADING
    data DeviceInputModePropertyInfo
    instance AttrInfo DeviceInputModePropertyInfo where
        type AttrAllowedOps DeviceInputModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DeviceInputModePropertyInfo = (~) Gdk.Enums.InputMode
        type AttrBaseTypeConstraint DeviceInputModePropertyInfo = IsDevice
        type AttrGetType DeviceInputModePropertyInfo = Gdk.Enums.InputMode
        type AttrLabel DeviceInputModePropertyInfo = "input-mode"
        type AttrOrigin DeviceInputModePropertyInfo = Device
        attrGet _ = getDeviceInputMode
        attrSet _ = setDeviceInputMode
        attrConstruct _ = constructDeviceInputMode
        attrClear _ = undefined
    #endif

    -- VVV Prop "input-source"
       -- Type: TInterface (Name {namespace = "Gdk", name = "InputSource"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@input-source@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #inputSource
    @
    -}
    getDeviceInputSource :: (MonadIO m, IsDevice o) => o -> m Gdk.Enums.InputSource
    getDeviceInputSource obj = liftIO $ getObjectPropertyEnum obj "input-source"

    {- |
    Construct a `GValueConstruct` with valid value for the “@input-source@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceInputSource :: (IsDevice o) => Gdk.Enums.InputSource -> IO (GValueConstruct o)
    constructDeviceInputSource val = constructObjectPropertyEnum "input-source" val

    #if ENABLE_OVERLOADING
    data DeviceInputSourcePropertyInfo
    instance AttrInfo DeviceInputSourcePropertyInfo where
        type AttrAllowedOps DeviceInputSourcePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DeviceInputSourcePropertyInfo = (~) Gdk.Enums.InputSource
        type AttrBaseTypeConstraint DeviceInputSourcePropertyInfo = IsDevice
        type AttrGetType DeviceInputSourcePropertyInfo = Gdk.Enums.InputSource
        type AttrLabel DeviceInputSourcePropertyInfo = "input-source"
        type AttrOrigin DeviceInputSourcePropertyInfo = Device
        attrGet _ = getDeviceInputSource
        attrSet _ = undefined
        attrConstruct _ = constructDeviceInputSource
        attrClear _ = undefined
    #endif

    -- VVV Prop "n-axes"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@n-axes@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #nAxes
    @
    -}
    getDeviceNAxes :: (MonadIO m, IsDevice o) => o -> m Word32
    getDeviceNAxes obj = liftIO $ getObjectPropertyUInt32 obj "n-axes"

    #if ENABLE_OVERLOADING
    data DeviceNAxesPropertyInfo
    instance AttrInfo DeviceNAxesPropertyInfo where
        type AttrAllowedOps DeviceNAxesPropertyInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint DeviceNAxesPropertyInfo = (~) ()
        type AttrBaseTypeConstraint DeviceNAxesPropertyInfo = IsDevice
        type AttrGetType DeviceNAxesPropertyInfo = Word32
        type AttrLabel DeviceNAxesPropertyInfo = "n-axes"
        type AttrOrigin DeviceNAxesPropertyInfo = Device
        attrGet _ = getDeviceNAxes
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "name"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@name@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #name
    @
    -}
    getDeviceName :: (MonadIO m, IsDevice o) => o -> m T.Text
    getDeviceName obj = liftIO $ checkUnexpectedNothing "getDeviceName" $ getObjectPropertyString obj "name"

    {- |
    Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceName :: (IsDevice o) => T.Text -> IO (GValueConstruct o)
    constructDeviceName val = constructObjectPropertyString "name" (Just val)

    #if ENABLE_OVERLOADING
    data DeviceNamePropertyInfo
    instance AttrInfo DeviceNamePropertyInfo where
        type AttrAllowedOps DeviceNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceNamePropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint DeviceNamePropertyInfo = IsDevice
        type AttrGetType DeviceNamePropertyInfo = T.Text
        type AttrLabel DeviceNamePropertyInfo = "name"
        type AttrOrigin DeviceNamePropertyInfo = Device
        attrGet _ = getDeviceName
        attrSet _ = undefined
        attrConstruct _ = constructDeviceName
        attrClear _ = undefined
    #endif

    -- VVV Prop "num-touches"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@num-touches@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #numTouches
    @
    -}
    getDeviceNumTouches :: (MonadIO m, IsDevice o) => o -> m Word32
    getDeviceNumTouches obj = liftIO $ getObjectPropertyUInt32 obj "num-touches"

    {- |
    Construct a `GValueConstruct` with valid value for the “@num-touches@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceNumTouches :: (IsDevice o) => Word32 -> IO (GValueConstruct o)
    constructDeviceNumTouches val = constructObjectPropertyUInt32 "num-touches" val

    #if ENABLE_OVERLOADING
    data DeviceNumTouchesPropertyInfo
    instance AttrInfo DeviceNumTouchesPropertyInfo where
        type AttrAllowedOps DeviceNumTouchesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DeviceNumTouchesPropertyInfo = (~) Word32
        type AttrBaseTypeConstraint DeviceNumTouchesPropertyInfo = IsDevice
        type AttrGetType DeviceNumTouchesPropertyInfo = Word32
        type AttrLabel DeviceNumTouchesPropertyInfo = "num-touches"
        type AttrOrigin DeviceNumTouchesPropertyInfo = Device
        attrGet _ = getDeviceNumTouches
        attrSet _ = undefined
        attrConstruct _ = constructDeviceNumTouches
        attrClear _ = undefined
    #endif

    -- VVV Prop "product-id"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just True,Nothing)

    {- |
    Get the value of the “@product-id@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #productId
    @
    -}
    getDeviceProductId :: (MonadIO m, IsDevice o) => o -> m (Maybe T.Text)
    getDeviceProductId obj = liftIO $ getObjectPropertyString obj "product-id"

    {- |
    Construct a `GValueConstruct` with valid value for the “@product-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceProductId :: (IsDevice o) => T.Text -> IO (GValueConstruct o)
    constructDeviceProductId val = constructObjectPropertyString "product-id" (Just val)

    #if ENABLE_OVERLOADING
    data DeviceProductIdPropertyInfo
    instance AttrInfo DeviceProductIdPropertyInfo where
        type AttrAllowedOps DeviceProductIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceProductIdPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint DeviceProductIdPropertyInfo = IsDevice
        type AttrGetType DeviceProductIdPropertyInfo = (Maybe T.Text)
        type AttrLabel DeviceProductIdPropertyInfo = "product-id"
        type AttrOrigin DeviceProductIdPropertyInfo = Device
        attrGet _ = getDeviceProductId
        attrSet _ = undefined
        attrConstruct _ = constructDeviceProductId
        attrClear _ = undefined
    #endif

    -- VVV Prop "seat"
       -- Type: TInterface (Name {namespace = "Gdk", name = "Seat"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@seat@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #seat
    @
    -}
    getDeviceSeat :: (MonadIO m, IsDevice o) => o -> m Gdk.Seat.Seat
    getDeviceSeat obj = liftIO $ checkUnexpectedNothing "getDeviceSeat" $ getObjectPropertyObject obj "seat" Gdk.Seat.Seat

    {- |
    Set the value of the “@seat@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' device [ #seat 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setDeviceSeat :: (MonadIO m, IsDevice o, Gdk.Seat.IsSeat a) => o -> a -> m ()
    setDeviceSeat obj val = liftIO $ setObjectPropertyObject obj "seat" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@seat@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceSeat :: (IsDevice o, Gdk.Seat.IsSeat a) => a -> IO (GValueConstruct o)
    constructDeviceSeat val = constructObjectPropertyObject "seat" (Just val)

    {- |
    Set the value of the “@seat@” property to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #seat
    @
    -}
    clearDeviceSeat :: (MonadIO m, IsDevice o) => o -> m ()
    clearDeviceSeat obj = liftIO $ setObjectPropertyObject obj "seat" (Nothing :: Maybe Gdk.Seat.Seat)

    #if ENABLE_OVERLOADING
    data DeviceSeatPropertyInfo
    instance AttrInfo DeviceSeatPropertyInfo where
        type AttrAllowedOps DeviceSeatPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceSeatPropertyInfo = Gdk.Seat.IsSeat
        type AttrBaseTypeConstraint DeviceSeatPropertyInfo = IsDevice
        type AttrGetType DeviceSeatPropertyInfo = Gdk.Seat.Seat
        type AttrLabel DeviceSeatPropertyInfo = "seat"
        type AttrOrigin DeviceSeatPropertyInfo = Device
        attrGet _ = getDeviceSeat
        attrSet _ = setDeviceSeat
        attrConstruct _ = constructDeviceSeat
        attrClear _ = clearDeviceSeat
    #endif

    -- VVV Prop "tool"
       -- Type: TInterface (Name {namespace = "Gdk", name = "DeviceTool"})
       -- Flags: [PropertyReadable]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@tool@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #tool
    @
    -}
    getDeviceTool :: (MonadIO m, IsDevice o) => o -> m (Maybe Gdk.DeviceTool.DeviceTool)
    getDeviceTool obj = liftIO $ getObjectPropertyObject obj "tool" Gdk.DeviceTool.DeviceTool

    #if ENABLE_OVERLOADING
    data DeviceToolPropertyInfo
    instance AttrInfo DeviceToolPropertyInfo where
        type AttrAllowedOps DeviceToolPropertyInfo = '[ 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceToolPropertyInfo = (~) ()
        type AttrBaseTypeConstraint DeviceToolPropertyInfo = IsDevice
        type AttrGetType DeviceToolPropertyInfo = (Maybe Gdk.DeviceTool.DeviceTool)
        type AttrLabel DeviceToolPropertyInfo = "tool"
        type AttrOrigin DeviceToolPropertyInfo = Device
        attrGet _ = getDeviceTool
        attrSet _ = undefined
        attrConstruct _ = undefined
        attrClear _ = undefined
    #endif

    -- VVV Prop "type"
       -- Type: TInterface (Name {namespace = "Gdk", name = "DeviceType"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@type@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #type
    @
    -}
    getDeviceType :: (MonadIO m, IsDevice o) => o -> m Gdk.Enums.DeviceType
    getDeviceType obj = liftIO $ getObjectPropertyEnum obj "type"

    {- |
    Construct a `GValueConstruct` with valid value for the “@type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceType :: (IsDevice o) => Gdk.Enums.DeviceType -> IO (GValueConstruct o)
    constructDeviceType val = constructObjectPropertyEnum "type" val

    #if ENABLE_OVERLOADING
    data DeviceTypePropertyInfo
    instance AttrInfo DeviceTypePropertyInfo where
        type AttrAllowedOps DeviceTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint DeviceTypePropertyInfo = (~) Gdk.Enums.DeviceType
        type AttrBaseTypeConstraint DeviceTypePropertyInfo = IsDevice
        type AttrGetType DeviceTypePropertyInfo = Gdk.Enums.DeviceType
        type AttrLabel DeviceTypePropertyInfo = "type"
        type AttrOrigin DeviceTypePropertyInfo = Device
        attrGet _ = getDeviceType
        attrSet _ = undefined
        attrConstruct _ = constructDeviceType
        attrClear _ = undefined
    #endif

    -- VVV Prop "vendor-id"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just True,Nothing)

    {- |
    Get the value of the “@vendor-id@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' device #vendorId
    @
    -}
    getDeviceVendorId :: (MonadIO m, IsDevice o) => o -> m (Maybe T.Text)
    getDeviceVendorId obj = liftIO $ getObjectPropertyString obj "vendor-id"

    {- |
    Construct a `GValueConstruct` with valid value for the “@vendor-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructDeviceVendorId :: (IsDevice o) => T.Text -> IO (GValueConstruct o)
    constructDeviceVendorId val = constructObjectPropertyString "vendor-id" (Just val)

    #if ENABLE_OVERLOADING
    data DeviceVendorIdPropertyInfo
    instance AttrInfo DeviceVendorIdPropertyInfo where
        type AttrAllowedOps DeviceVendorIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint DeviceVendorIdPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint DeviceVendorIdPropertyInfo = IsDevice
        type AttrGetType DeviceVendorIdPropertyInfo = (Maybe T.Text)
        type AttrLabel DeviceVendorIdPropertyInfo = "vendor-id"
        type AttrOrigin DeviceVendorIdPropertyInfo = Device
        attrGet _ = getDeviceVendorId
        attrSet _ = undefined
        attrConstruct _ = constructDeviceVendorId
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Device
    type instance O.AttributeList Device = DeviceAttributeList
    type DeviceAttributeList = ('[ '("associatedDevice", DeviceAssociatedDevicePropertyInfo), '("axes", DeviceAxesPropertyInfo), '("deviceManager", DeviceDeviceManagerPropertyInfo), '("display", DeviceDisplayPropertyInfo), '("hasCursor", DeviceHasCursorPropertyInfo), '("inputMode", DeviceInputModePropertyInfo), '("inputSource", DeviceInputSourcePropertyInfo), '("nAxes", DeviceNAxesPropertyInfo), '("name", DeviceNamePropertyInfo), '("numTouches", DeviceNumTouchesPropertyInfo), '("productId", DeviceProductIdPropertyInfo), '("seat", DeviceSeatPropertyInfo), '("tool", DeviceToolPropertyInfo), '("type", DeviceTypePropertyInfo), '("vendorId", DeviceVendorIdPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    deviceAssociatedDevice :: AttrLabelProxy "associatedDevice"
    deviceAssociatedDevice = AttrLabelProxy

    deviceAxes :: AttrLabelProxy "axes"
    deviceAxes = AttrLabelProxy

    deviceDeviceManager :: AttrLabelProxy "deviceManager"
    deviceDeviceManager = AttrLabelProxy

    deviceDisplay :: AttrLabelProxy "display"
    deviceDisplay = AttrLabelProxy

    deviceHasCursor :: AttrLabelProxy "hasCursor"
    deviceHasCursor = AttrLabelProxy

    deviceInputMode :: AttrLabelProxy "inputMode"
    deviceInputMode = AttrLabelProxy

    deviceInputSource :: AttrLabelProxy "inputSource"
    deviceInputSource = AttrLabelProxy

    deviceNAxes :: AttrLabelProxy "nAxes"
    deviceNAxes = AttrLabelProxy

    deviceName :: AttrLabelProxy "name"
    deviceName = AttrLabelProxy

    deviceNumTouches :: AttrLabelProxy "numTouches"
    deviceNumTouches = AttrLabelProxy

    deviceProductId :: AttrLabelProxy "productId"
    deviceProductId = AttrLabelProxy

    deviceSeat :: AttrLabelProxy "seat"
    deviceSeat = AttrLabelProxy

    deviceTool :: AttrLabelProxy "tool"
    deviceTool = AttrLabelProxy

    deviceType :: AttrLabelProxy "type"
    deviceType = AttrLabelProxy

    deviceVendorId :: AttrLabelProxy "vendorId"
    deviceVendorId = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    data DeviceChangedSignalInfo
    instance SignalInfo DeviceChangedSignalInfo where
        type HaskellCallbackType DeviceChangedSignalInfo = DeviceChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DeviceChangedCallback cb
            cb'' <- mk_DeviceChangedCallback cb'
            connectSignalFunPtr obj "changed" cb'' connectMode

    data DeviceToolChangedSignalInfo
    instance SignalInfo DeviceToolChangedSignalInfo where
        type HaskellCallbackType DeviceToolChangedSignalInfo = DeviceToolChangedCallback
        connectSignal _ obj cb connectMode = do
            let cb' = wrap_DeviceToolChangedCallback cb
            cb'' <- mk_DeviceToolChangedCallback cb'
            connectSignalFunPtr obj "tool-changed" cb'' connectMode

    type instance O.SignalList Device = DeviceSignalList
    type DeviceSignalList = ('[ '("changed", DeviceChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("toolChanged", DeviceToolChangedSignalInfo)] :: [(Symbol, *)])

    #endif

    -- method Device::get_associated_device
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Device"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_associated_device" gdk_device_get_associated_device ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO (Ptr Device)

    {- |
    Returns the associated device to /@device@/, if /@device@/ is of type
    'GI.Gdk.Enums.DeviceTypeMaster', it will return the paired pointer or
    keyboard.

    If /@device@/ is of type 'GI.Gdk.Enums.DeviceTypeSlave', it will return
    the master device to which /@device@/ is attached to.

    If /@device@/ is of type 'GI.Gdk.Enums.DeviceTypeFloating', 'Nothing' will be
    returned, as there is no associated device.

    /Since: 3.0/
    -}
    deviceGetAssociatedDevice ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m (Maybe Device)
        {- ^ __Returns:__ The associated device, or
      'Nothing' -}
    deviceGetAssociatedDevice device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_associated_device device'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Device) result'
            return result''
        touchManagedPtr device
        return maybeResult

    #if ENABLE_OVERLOADING
    data DeviceGetAssociatedDeviceMethodInfo
    instance (signature ~ (m (Maybe Device)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetAssociatedDeviceMethodInfo a signature where
        overloadedMethod _ = deviceGetAssociatedDevice

    #endif

    -- method Device::get_axes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "AxisFlags"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_axes" gdk_device_get_axes ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CUInt

    {- |
    Returns the axes currently available on the device.

    /Since: 3.22/
    -}
    deviceGetAxes ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m [Gdk.Flags.AxisFlags]
    deviceGetAxes device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_axes device'
        let result' = wordToGFlags result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetAxesMethodInfo
    instance (signature ~ (m [Gdk.Flags.AxisFlags]), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetAxesMethodInfo a signature where
        overloadedMethod _ = deviceGetAxes

    #endif

    -- method Device::get_axis_use
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the axis.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "AxisUse"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_axis_use" gdk_device_get_axis_use ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Word32 ->                               -- index_ : TBasicType TUInt
        IO CUInt

    {- |
    Returns the axis use for /@index_@/.

    /Since: 2.20/
    -}
    deviceGetAxisUse ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device'. -}
        -> Word32
        {- ^ /@index_@/: the index of the axis. -}
        -> m Gdk.Enums.AxisUse
        {- ^ __Returns:__ a 'GI.Gdk.Enums.AxisUse' specifying how the axis is used. -}
    deviceGetAxisUse device index_ = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_axis_use device' index_
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetAxisUseMethodInfo
    instance (signature ~ (Word32 -> m Gdk.Enums.AxisUse), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetAxisUseMethodInfo a signature where
        overloadedMethod _ = deviceGetAxisUse

    #endif

    -- method Device::get_device_type
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "DeviceType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_device_type" gdk_device_get_device_type ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CUInt

    {- |
    Returns the device type for /@device@/.

    /Since: 3.0/
    -}
    deviceGetDeviceType ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m Gdk.Enums.DeviceType
        {- ^ __Returns:__ the 'GI.Gdk.Enums.DeviceType' for /@device@/. -}
    deviceGetDeviceType device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_device_type device'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetDeviceTypeMethodInfo
    instance (signature ~ (m Gdk.Enums.DeviceType), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetDeviceTypeMethodInfo a signature where
        overloadedMethod _ = deviceGetDeviceType

    #endif

    -- method Device::get_display
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Display"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_display" gdk_device_get_display ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO (Ptr Gdk.Display.Display)

    {- |
    Returns the 'GI.Gdk.Objects.Display.Display' to which /@device@/ pertains.

    /Since: 3.0/
    -}
    deviceGetDisplay ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m Gdk.Display.Display
        {- ^ __Returns:__ a 'GI.Gdk.Objects.Display.Display'. This memory is owned
             by GTK+, and must not be freed or unreffed. -}
    deviceGetDisplay device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_display device'
        checkUnexpectedReturnNULL "deviceGetDisplay" result
        result' <- (newObject Gdk.Display.Display) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetDisplayMethodInfo
    instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetDisplayMethodInfo a signature where
        overloadedMethod _ = deviceGetDisplay

    #endif

    -- method Device::get_has_cursor
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_has_cursor" gdk_device_get_has_cursor ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CInt

    {- |
    Determines whether the pointer follows device motion.
    This is not meaningful for keyboard devices, which don\'t have a pointer.

    /Since: 2.20/
    -}
    deviceGetHasCursor ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the pointer follows device motion -}
    deviceGetHasCursor device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_has_cursor device'
        let result' = (/= 0) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetHasCursorMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetHasCursorMethodInfo a signature where
        overloadedMethod _ = deviceGetHasCursor

    #endif

    -- method Device::get_key
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the macro button to get.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyval", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for the keyval.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "modifiers", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return value for modifiers.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_key" gdk_device_get_key ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Word32 ->                               -- index_ : TBasicType TUInt
        Ptr Word32 ->                           -- keyval : TBasicType TUInt
        Ptr CUInt ->                            -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
        IO CInt

    {- |
    If /@index_@/ has a valid keyval, this function will return 'True'
    and fill in /@keyval@/ and /@modifiers@/ with the keyval settings.

    /Since: 2.20/
    -}
    deviceGetKey ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device'. -}
        -> Word32
        {- ^ /@index_@/: the index of the macro button to get. -}
        -> m ((Bool, Word32, [Gdk.Flags.ModifierType]))
        {- ^ __Returns:__ 'True' if keyval is set for /@index@/. -}
    deviceGetKey device index_ = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        keyval <- allocMem :: IO (Ptr Word32)
        modifiers <- allocMem :: IO (Ptr CUInt)
        result <- gdk_device_get_key device' index_ keyval modifiers
        let result' = (/= 0) result
        keyval' <- peek keyval
        modifiers' <- peek modifiers
        let modifiers'' = wordToGFlags modifiers'
        touchManagedPtr device
        freeMem keyval
        freeMem modifiers
        return (result', keyval', modifiers'')

    #if ENABLE_OVERLOADING
    data DeviceGetKeyMethodInfo
    instance (signature ~ (Word32 -> m ((Bool, Word32, [Gdk.Flags.ModifierType]))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetKeyMethodInfo a signature where
        overloadedMethod _ = deviceGetKey

    #endif

    -- method Device::get_last_event_window
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice, with a source other than %GDK_SOURCE_KEYBOARD", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_last_event_window" gdk_device_get_last_event_window ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO (Ptr Gdk.Window.Window)

    {- |
    Gets information about which window the given pointer device is in, based on events
    that have been received so far from the display server. If another application
    has a pointer grab, or this application has a grab with owner_events = 'False',
    'Nothing' may be returned even if the pointer is physically over one of this
    application\'s windows.

    /Since: 3.12/
    -}
    deviceGetLastEventWindow ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device', with a source other than 'GI.Gdk.Enums.InputSourceKeyboard' -}
        -> m (Maybe Gdk.Window.Window)
        {- ^ __Returns:__ the last window the device -}
    deviceGetLastEventWindow device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_last_event_window device'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Gdk.Window.Window) result'
            return result''
        touchManagedPtr device
        return maybeResult

    #if ENABLE_OVERLOADING
    data DeviceGetLastEventWindowMethodInfo
    instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetLastEventWindowMethodInfo a signature where
        overloadedMethod _ = deviceGetLastEventWindow

    #endif

    -- method Device::get_mode
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "InputMode"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_mode" gdk_device_get_mode ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CUInt

    {- |
    Determines the mode of the device.

    /Since: 2.20/
    -}
    deviceGetMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m Gdk.Enums.InputMode
        {- ^ __Returns:__ a 'GI.Gdk.Enums.InputSource' -}
    deviceGetMode device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_mode device'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetModeMethodInfo
    instance (signature ~ (m Gdk.Enums.InputMode), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetModeMethodInfo a signature where
        overloadedMethod _ = deviceGetMode

    #endif

    -- method Device::get_n_axes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_n_axes" gdk_device_get_n_axes ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO Int32

    {- |
    Returns the number of axes the device currently has.

    /Since: 3.0/
    -}
    deviceGetNAxes ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device' -}
        -> m Int32
        {- ^ __Returns:__ the number of axes. -}
    deviceGetNAxes device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_n_axes device'
        touchManagedPtr device
        return result

    #if ENABLE_OVERLOADING
    data DeviceGetNAxesMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetNAxesMethodInfo a signature where
        overloadedMethod _ = deviceGetNAxes

    #endif

    -- method Device::get_n_keys
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_n_keys" gdk_device_get_n_keys ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO Int32

    {- |
    Returns the number of keys the device currently has.

    /Since: 2.24/
    -}
    deviceGetNKeys ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m Int32
        {- ^ __Returns:__ the number of keys. -}
    deviceGetNKeys device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_n_keys device'
        touchManagedPtr device
        return result

    #if ENABLE_OVERLOADING
    data DeviceGetNKeysMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetNKeysMethodInfo a signature where
        overloadedMethod _ = deviceGetNKeys

    #endif

    -- method Device::get_name
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_name" gdk_device_get_name ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CString

    {- |
    Determines the name of the device.

    /Since: 2.20/
    -}
    deviceGetName ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m T.Text
        {- ^ __Returns:__ a name -}
    deviceGetName device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_name device'
        checkUnexpectedReturnNULL "deviceGetName" result
        result' <- cstringToText result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetNameMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetNameMethodInfo a signature where
        overloadedMethod _ = deviceGetName

    #endif

    -- method Device::get_position
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer device to query status about.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the #GdkScreen\n         the @device is on, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window X coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window Y coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_position" gdk_device_get_position ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Ptr (Ptr Gdk.Screen.Screen) ->          -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Ptr Int32 ->                            -- x : TBasicType TInt
        Ptr Int32 ->                            -- y : TBasicType TInt
        IO ()

    {- |
    Gets the current location of /@device@/. As a slave device
    coordinates are those of its master pointer, This function
    may not be called on devices of type 'GI.Gdk.Enums.DeviceTypeSlave',
    unless there is an ongoing grab on them, see 'GI.Gdk.Objects.Device.deviceGrab'.

    /Since: 3.0/
    -}
    deviceGetPosition ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: pointer device to query status about. -}
        -> m ((Gdk.Screen.Screen, Int32, Int32))
    deviceGetPosition device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        screen <- allocMem :: IO (Ptr (Ptr Gdk.Screen.Screen))
        x <- allocMem :: IO (Ptr Int32)
        y <- allocMem :: IO (Ptr Int32)
        gdk_device_get_position device' screen x y
        screen' <- peek screen
        screen'' <- (newObject Gdk.Screen.Screen) screen'
        x' <- peek x
        y' <- peek y
        touchManagedPtr device
        freeMem screen
        freeMem x
        freeMem y
        return (screen'', x', y')

    #if ENABLE_OVERLOADING
    data DeviceGetPositionMethodInfo
    instance (signature ~ (m ((Gdk.Screen.Screen, Int32, Int32))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetPositionMethodInfo a signature where
        overloadedMethod _ = deviceGetPosition

    #endif

    -- method Device::get_position_double
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer device to query status about.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the #GdkScreen\n         the @device is on, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window X coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store root window Y coordinate of @device, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_position_double" gdk_device_get_position_double ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Ptr (Ptr Gdk.Screen.Screen) ->          -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Ptr CDouble ->                          -- x : TBasicType TDouble
        Ptr CDouble ->                          -- y : TBasicType TDouble
        IO ()

    {- |
    Gets the current location of /@device@/ in double precision. As a slave device\'s
    coordinates are those of its master pointer, this function
    may not be called on devices of type 'GI.Gdk.Enums.DeviceTypeSlave',
    unless there is an ongoing grab on them. See 'GI.Gdk.Objects.Device.deviceGrab'.

    /Since: 3.10/
    -}
    deviceGetPositionDouble ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: pointer device to query status about. -}
        -> m ((Gdk.Screen.Screen, Double, Double))
    deviceGetPositionDouble device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        screen <- allocMem :: IO (Ptr (Ptr Gdk.Screen.Screen))
        x <- allocMem :: IO (Ptr CDouble)
        y <- allocMem :: IO (Ptr CDouble)
        gdk_device_get_position_double device' screen x y
        screen' <- peek screen
        screen'' <- (newObject Gdk.Screen.Screen) screen'
        x' <- peek x
        let x'' = realToFrac x'
        y' <- peek y
        let y'' = realToFrac y'
        touchManagedPtr device
        freeMem screen
        freeMem x
        freeMem y
        return (screen'', x'', y'')

    #if ENABLE_OVERLOADING
    data DeviceGetPositionDoubleMethodInfo
    instance (signature ~ (m ((Gdk.Screen.Screen, Double, Double))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetPositionDoubleMethodInfo a signature where
        overloadedMethod _ = deviceGetPositionDouble

    #endif

    -- method Device::get_product_id
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a slave #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_product_id" gdk_device_get_product_id ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CString

    {- |
    Returns the product ID of this device, or 'Nothing' if this information couldn\'t
    be obtained. This ID is retrieved from the device, and is thus constant for
    it. See 'GI.Gdk.Objects.Device.deviceGetVendorId' for more information.

    /Since: 3.16/
    -}
    deviceGetProductId ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a slave 'GI.Gdk.Objects.Device.Device' -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ the product ID, or 'Nothing' -}
    deviceGetProductId device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_product_id device'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr device
        return maybeResult

    #if ENABLE_OVERLOADING
    data DeviceGetProductIdMethodInfo
    instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetProductIdMethodInfo a signature where
        overloadedMethod _ = deviceGetProductId

    #endif

    -- method Device::get_seat
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Seat"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_seat" gdk_device_get_seat ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO (Ptr Gdk.Seat.Seat)

    {- |
    Returns the 'GI.Gdk.Objects.Seat.Seat' the device belongs to.

    /Since: 3.20/
    -}
    deviceGetSeat ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: A 'GI.Gdk.Objects.Device.Device' -}
        -> m Gdk.Seat.Seat
        {- ^ __Returns:__ A 'GI.Gdk.Objects.Seat.Seat'. This memory is owned by GTK+ and
             must not be freed. -}
    deviceGetSeat device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_seat device'
        checkUnexpectedReturnNULL "deviceGetSeat" result
        result' <- (newObject Gdk.Seat.Seat) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetSeatMethodInfo
    instance (signature ~ (m Gdk.Seat.Seat), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetSeatMethodInfo a signature where
        overloadedMethod _ = deviceGetSeat

    #endif

    -- method Device::get_source
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "InputSource"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_source" gdk_device_get_source ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CUInt

    {- |
    Determines the type of the device.

    /Since: 2.20/
    -}
    deviceGetSource ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m Gdk.Enums.InputSource
        {- ^ __Returns:__ a 'GI.Gdk.Enums.InputSource' -}
    deviceGetSource device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_source device'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGetSourceMethodInfo
    instance (signature ~ (m Gdk.Enums.InputSource), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetSourceMethodInfo a signature where
        overloadedMethod _ = deviceGetSource

    #endif

    -- method Device::get_vendor_id
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a slave #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_vendor_id" gdk_device_get_vendor_id ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO CString

    {- |
    Returns the vendor ID of this device, or 'Nothing' if this information couldn\'t
    be obtained. This ID is retrieved from the device, and is thus constant for
    it.

    This function, together with 'GI.Gdk.Objects.Device.deviceGetProductId', can be used to eg.
    compose 'GI.Gio.Objects.Settings.Settings' paths to store settings for this device.

    === /C code/
    >
    > static GSettings *
    > get_device_settings (GdkDevice *device)
    > {
    >   const gchar *vendor, *product;
    >   GSettings *settings;
    >   GdkDevice *device;
    >   gchar *path;
    >
    >   vendor = gdk_device_get_vendor_id (device);
    >   product = gdk_device_get_product_id (device);
    >
    >   path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product);
    >   settings = g_settings_new_with_path (DEVICE_SCHEMA, path);
    >   g_free (path);
    >
    >   return settings;
    > }

    /Since: 3.16/
    -}
    deviceGetVendorId ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a slave 'GI.Gdk.Objects.Device.Device' -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ the vendor ID, or 'Nothing' -}
    deviceGetVendorId device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_get_vendor_id device'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr device
        return maybeResult

    #if ENABLE_OVERLOADING
    data DeviceGetVendorIdMethodInfo
    instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetVendorIdMethodInfo a signature where
        overloadedMethod _ = deviceGetVendorId

    #endif

    -- method Device::get_window_at_position
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer #GdkDevice to query info to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "win_x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "win_y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the Y coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_window_at_position" gdk_device_get_window_at_position ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Ptr Int32 ->                            -- win_x : TBasicType TInt
        Ptr Int32 ->                            -- win_y : TBasicType TInt
        IO (Ptr Gdk.Window.Window)

    {- |
    Obtains the window underneath /@device@/, returning the location of the device in /@winX@/ and /@winY@/. Returns
    'Nothing' if the window tree under /@device@/ is not known to GDK (for example, belongs to another application).

    As a slave device coordinates are those of its master pointer, This
    function may not be called on devices of type 'GI.Gdk.Enums.DeviceTypeSlave',
    unless there is an ongoing grab on them, see 'GI.Gdk.Objects.Device.deviceGrab'.

    /Since: 3.0/
    -}
    deviceGetWindowAtPosition ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: pointer 'GI.Gdk.Objects.Device.Device' to query info to. -}
        -> m ((Maybe Gdk.Window.Window, Int32, Int32))
        {- ^ __Returns:__ the 'GI.Gdk.Objects.Window.Window' under the
    device position, or 'Nothing'. -}
    deviceGetWindowAtPosition device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        winX <- allocMem :: IO (Ptr Int32)
        winY <- allocMem :: IO (Ptr Int32)
        result <- gdk_device_get_window_at_position device' winX winY
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Gdk.Window.Window) result'
            return result''
        winX' <- peek winX
        winY' <- peek winY
        touchManagedPtr device
        freeMem winX
        freeMem winY
        return (maybeResult, winX', winY')

    #if ENABLE_OVERLOADING
    data DeviceGetWindowAtPositionMethodInfo
    instance (signature ~ (m ((Maybe Gdk.Window.Window, Int32, Int32))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetWindowAtPositionMethodInfo a signature where
        overloadedMethod _ = deviceGetWindowAtPosition

    #endif

    -- method Device::get_window_at_position_double
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer #GdkDevice to query info to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "win_x", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "win_y", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the Y coordinate of the device location,\n        relative to the window origin, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_get_window_at_position_double" gdk_device_get_window_at_position_double ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Ptr CDouble ->                          -- win_x : TBasicType TDouble
        Ptr CDouble ->                          -- win_y : TBasicType TDouble
        IO (Ptr Gdk.Window.Window)

    {- |
    Obtains the window underneath /@device@/, returning the location of the device in /@winX@/ and /@winY@/ in
    double precision. Returns 'Nothing' if the window tree under /@device@/ is not known to GDK (for example,
    belongs to another application).

    As a slave device coordinates are those of its master pointer, This
    function may not be called on devices of type 'GI.Gdk.Enums.DeviceTypeSlave',
    unless there is an ongoing grab on them, see 'GI.Gdk.Objects.Device.deviceGrab'.

    /Since: 3.0/
    -}
    deviceGetWindowAtPositionDouble ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: pointer 'GI.Gdk.Objects.Device.Device' to query info to. -}
        -> m ((Maybe Gdk.Window.Window, Double, Double))
        {- ^ __Returns:__ the 'GI.Gdk.Objects.Window.Window' under the
      device position, or 'Nothing'. -}
    deviceGetWindowAtPositionDouble device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        winX <- allocMem :: IO (Ptr CDouble)
        winY <- allocMem :: IO (Ptr CDouble)
        result <- gdk_device_get_window_at_position_double device' winX winY
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Gdk.Window.Window) result'
            return result''
        winX' <- peek winX
        let winX'' = realToFrac winX'
        winY' <- peek winY
        let winY'' = realToFrac winY'
        touchManagedPtr device
        freeMem winX
        freeMem winY
        return (maybeResult, winX'', winY'')

    #if ENABLE_OVERLOADING
    data DeviceGetWindowAtPositionDoubleMethodInfo
    instance (signature ~ (m ((Maybe Gdk.Window.Window, Double, Double))), MonadIO m, IsDevice a) => O.MethodInfo DeviceGetWindowAtPositionDoubleMethodInfo a signature where
        overloadedMethod _ = deviceGetWindowAtPositionDouble

    #endif

    -- method Device::grab
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice. To get the device you can use gtk_get_current_event_device()\n  or gdk_event_get_device() if the grab is in reaction to an event. Also, you can use\n  gdk_device_manager_get_client_pointer() but only in code that isn\8217t triggered by a\n  #GdkEvent and there aren\8217t other means to get a meaningful #GdkDevice to operate on.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkWindow which will own the grab (the grab window)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "grab_ownership", argType = TInterface (Name {namespace = "Gdk", name = "GrabOwnership"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies the grab ownership.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner_events", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %FALSE then all device events are reported with respect to\n               @window and are only reported if selected by @event_mask. If\n               %TRUE then pointer events for this application are reported\n               as normal, but pointer events outside this application are\n               reported with respect to @window and only if selected by\n               @event_mask. In either mode, unreported events are discarded.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event_mask", argType = TInterface (Name {namespace = "Gdk", name = "EventMask"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies the event mask, which is used in accordance with\n             @owner_events.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor", argType = TInterface (Name {namespace = "Gdk", name = "Cursor"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the cursor to display while the grab is active if the device is\n         a pointer. If this is %NULL then the normal cursors are used for\n         @window and its descendants, and the cursor for @window is used\n         elsewhere.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the timestamp of the event which led to this pointer grab. This\n        usually comes from the #GdkEvent struct, though %GDK_CURRENT_TIME\n        can be used if the time isn\8217t known.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gdk", name = "GrabStatus"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_grab" gdk_device_grab ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
        CUInt ->                                -- grab_ownership : TInterface (Name {namespace = "Gdk", name = "GrabOwnership"})
        CInt ->                                 -- owner_events : TBasicType TBoolean
        CUInt ->                                -- event_mask : TInterface (Name {namespace = "Gdk", name = "EventMask"})
        Ptr Gdk.Cursor.Cursor ->                -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
        Word32 ->                               -- time_ : TBasicType TUInt32
        IO CUInt

    {-# DEPRECATED deviceGrab ["(Since version 3.20.)","Use 'GI.Gdk.Objects.Seat.seatGrab' instead."] #-}
    {- |
    Grabs the device so that all events coming from this device are passed to
    this application until the device is ungrabbed with 'GI.Gdk.Objects.Device.deviceUngrab',
    or the window becomes unviewable. This overrides any previous grab on the device
    by this client.

    Note that /@device@/ and /@window@/ need to be on the same display.

    Device grabs are used for operations which need complete control over the
    given device events (either pointer or keyboard). For example in GTK+ this
    is used for Drag and Drop operations, popup menus and such.

    Note that if the event mask of an X window has selected both button press
    and button release events, then a button press event will cause an automatic
    pointer grab until the button is released. X does this automatically since
    most applications expect to receive button press and release events in pairs.
    It is equivalent to a pointer grab on the window with /@ownerEvents@/ set to
    'True'.

    If you set up anything at the time you take the grab that needs to be
    cleaned up when the grab ends, you should handle the 'GI.Gdk.Structs.EventGrabBroken.EventGrabBroken'
    events that are emitted when the grab ends unvoluntarily.

    /Since: 3.0/
    -}
    deviceGrab ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a, Gdk.Window.IsWindow b, Gdk.Cursor.IsCursor c) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device'. To get the device you can use @/gtk_get_current_event_device()/@
      or 'GI.Gdk.Unions.Event.eventGetDevice' if the grab is in reaction to an event. Also, you can use
      'GI.Gdk.Objects.DeviceManager.deviceManagerGetClientPointer' but only in code that isn’t triggered by a
      'GI.Gdk.Unions.Event.Event' and there aren’t other means to get a meaningful 'GI.Gdk.Objects.Device.Device' to operate on. -}
        -> b
        {- ^ /@window@/: the 'GI.Gdk.Objects.Window.Window' which will own the grab (the grab window) -}
        -> Gdk.Enums.GrabOwnership
        {- ^ /@grabOwnership@/: specifies the grab ownership. -}
        -> Bool
        {- ^ /@ownerEvents@/: if 'False' then all device events are reported with respect to
                   /@window@/ and are only reported if selected by /@eventMask@/. If
                   'True' then pointer events for this application are reported
                   as normal, but pointer events outside this application are
                   reported with respect to /@window@/ and only if selected by
                   /@eventMask@/. In either mode, unreported events are discarded. -}
        -> [Gdk.Flags.EventMask]
        {- ^ /@eventMask@/: specifies the event mask, which is used in accordance with
                 /@ownerEvents@/. -}
        -> Maybe (c)
        {- ^ /@cursor@/: the cursor to display while the grab is active if the device is
             a pointer. If this is 'Nothing' then the normal cursors are used for
             /@window@/ and its descendants, and the cursor for /@window@/ is used
             elsewhere. -}
        -> Word32
        {- ^ /@time_@/: the timestamp of the event which led to this pointer grab. This
            usually comes from the 'GI.Gdk.Unions.Event.Event' struct, though 'GI.Gdk.Constants.CURRENT_TIME'
            can be used if the time isn’t known. -}
        -> m Gdk.Enums.GrabStatus
        {- ^ __Returns:__ 'GI.Gdk.Enums.GrabStatusSuccess' if the grab was successful. -}
    deviceGrab device window grabOwnership ownerEvents eventMask cursor time_ = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        window' <- unsafeManagedPtrCastPtr window
        let grabOwnership' = (fromIntegral . fromEnum) grabOwnership
        let ownerEvents' = (fromIntegral . fromEnum) ownerEvents
        let eventMask' = gflagsToWord eventMask
        maybeCursor <- case cursor of
            Nothing -> return nullPtr
            Just jCursor -> do
                jCursor' <- unsafeManagedPtrCastPtr jCursor
                return jCursor'
        result <- gdk_device_grab device' window' grabOwnership' ownerEvents' eventMask' maybeCursor time_
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr device
        touchManagedPtr window
        whenJust cursor touchManagedPtr
        return result'

    #if ENABLE_OVERLOADING
    data DeviceGrabMethodInfo
    instance (signature ~ (b -> Gdk.Enums.GrabOwnership -> Bool -> [Gdk.Flags.EventMask] -> Maybe (c) -> Word32 -> m Gdk.Enums.GrabStatus), MonadIO m, IsDevice a, Gdk.Window.IsWindow b, Gdk.Cursor.IsCursor c) => O.MethodInfo DeviceGrabMethodInfo a signature where
        overloadedMethod _ = deviceGrab

    #endif

    -- method Device::list_axes
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Atom"})))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_list_axes" gdk_device_list_axes ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO (Ptr (GList (Ptr Gdk.Atom.Atom)))

    {- |
    Returns a 'GI.GLib.Structs.List.List' of @/GdkAtoms/@, containing the labels for
    the axes that /@device@/ currently has.

    /Since: 3.0/
    -}
    deviceListAxes ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device' -}
        -> m [Gdk.Atom.Atom]
        {- ^ __Returns:__
        A 'GI.GLib.Structs.List.List' of @/GdkAtoms/@, free with @/g_list_free()/@. -}
    deviceListAxes device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_list_axes device'
        result' <- unpackGList result
        result'' <- mapM (newPtr Gdk.Atom.Atom) result'
        g_list_free result
        touchManagedPtr device
        return result''

    #if ENABLE_OVERLOADING
    data DeviceListAxesMethodInfo
    instance (signature ~ (m [Gdk.Atom.Atom]), MonadIO m, IsDevice a) => O.MethodInfo DeviceListAxesMethodInfo a signature where
        overloadedMethod _ = deviceListAxes

    #endif

    -- method Device::list_slave_devices
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Device"})))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_list_slave_devices" gdk_device_list_slave_devices ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        IO (Ptr (GList (Ptr Device)))

    {- |
    If the device if of type 'GI.Gdk.Enums.DeviceTypeMaster', it will return
    the list of slave devices attached to it, otherwise it will return
    'Nothing'
    -}
    deviceListSlaveDevices ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> m [Device]
        {- ^ __Returns:__
             the list of slave devices, or 'Nothing'. The list must be
             freed with @/g_list_free()/@, the contents of the list are
             owned by GTK+ and should not be freed. -}
    deviceListSlaveDevices device = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        result <- gdk_device_list_slave_devices device'
        result' <- unpackGList result
        result'' <- mapM (newObject Device) result'
        g_list_free result
        touchManagedPtr device
        return result''

    #if ENABLE_OVERLOADING
    data DeviceListSlaveDevicesMethodInfo
    instance (signature ~ (m [Device]), MonadIO m, IsDevice a) => O.MethodInfo DeviceListSlaveDevicesMethodInfo a signature where
        overloadedMethod _ = deviceListSlaveDevices

    #endif

    -- method Device::set_axis_use
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the axis", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use", argType = TInterface (Name {namespace = "Gdk", name = "AxisUse"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "specifies how the axis is used", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_set_axis_use" gdk_device_set_axis_use ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Word32 ->                               -- index_ : TBasicType TUInt
        CUInt ->                                -- use : TInterface (Name {namespace = "Gdk", name = "AxisUse"})
        IO ()

    {- |
    Specifies how an axis of a device is used.
    -}
    deviceSetAxisUse ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a pointer 'GI.Gdk.Objects.Device.Device' -}
        -> Word32
        {- ^ /@index_@/: the index of the axis -}
        -> Gdk.Enums.AxisUse
        {- ^ /@use@/: specifies how the axis is used -}
        -> m ()
    deviceSetAxisUse device index_ use = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        let use' = (fromIntegral . fromEnum) use
        gdk_device_set_axis_use device' index_ use'
        touchManagedPtr device
        return ()

    #if ENABLE_OVERLOADING
    data DeviceSetAxisUseMethodInfo
    instance (signature ~ (Word32 -> Gdk.Enums.AxisUse -> m ()), MonadIO m, IsDevice a) => O.MethodInfo DeviceSetAxisUseMethodInfo a signature where
        overloadedMethod _ = deviceSetAxisUse

    #endif

    -- method Device::set_key
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the macro button to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keyval", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the keyval to generate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modifiers", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the modifiers to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_set_key" gdk_device_set_key ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Word32 ->                               -- index_ : TBasicType TUInt
        Word32 ->                               -- keyval : TBasicType TUInt
        CUInt ->                                -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
        IO ()

    {- |
    Specifies the X key event to generate when a macro button of a device
    is pressed.
    -}
    deviceSetKey ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> Word32
        {- ^ /@index_@/: the index of the macro button to set -}
        -> Word32
        {- ^ /@keyval@/: the keyval to generate -}
        -> [Gdk.Flags.ModifierType]
        {- ^ /@modifiers@/: the modifiers to set -}
        -> m ()
    deviceSetKey device index_ keyval modifiers = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        let modifiers' = gflagsToWord modifiers
        gdk_device_set_key device' index_ keyval modifiers'
        touchManagedPtr device
        return ()

    #if ENABLE_OVERLOADING
    data DeviceSetKeyMethodInfo
    instance (signature ~ (Word32 -> Word32 -> [Gdk.Flags.ModifierType] -> m ()), MonadIO m, IsDevice a) => O.MethodInfo DeviceSetKeyMethodInfo a signature where
        overloadedMethod _ = deviceSetKey

    #endif

    -- method Device::set_mode
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gdk", name = "InputMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the input mode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_set_mode" gdk_device_set_mode ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        CUInt ->                                -- mode : TInterface (Name {namespace = "Gdk", name = "InputMode"})
        IO CInt

    {- |
    Sets a the mode of an input device. The mode controls if the
    device is active and whether the device’s range is mapped to the
    entire screen or to a single window.

    Note: This is only meaningful for floating devices, master devices (and
    slaves connected to these) drive the pointer cursor, which is not limited
    by the input mode.
    -}
    deviceSetMode ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device'. -}
        -> Gdk.Enums.InputMode
        {- ^ /@mode@/: the input mode. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the mode was successfully changed. -}
    deviceSetMode device mode = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        let mode' = (fromIntegral . fromEnum) mode
        result <- gdk_device_set_mode device' mode'
        let result' = (/= 0) result
        touchManagedPtr device
        return result'

    #if ENABLE_OVERLOADING
    data DeviceSetModeMethodInfo
    instance (signature ~ (Gdk.Enums.InputMode -> m Bool), MonadIO m, IsDevice a) => O.MethodInfo DeviceSetModeMethodInfo a signature where
        overloadedMethod _ = deviceSetMode

    #endif

    -- method Device::ungrab
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timestap (e.g. %GDK_CURRENT_TIME).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_ungrab" gdk_device_ungrab ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Word32 ->                               -- time_ : TBasicType TUInt32
        IO ()

    {-# DEPRECATED deviceUngrab ["(Since version 3.20.)","Use 'GI.Gdk.Objects.Seat.seatUngrab' instead."] #-}
    {- |
    Release any grab on /@device@/.

    /Since: 3.0/
    -}
    deviceUngrab ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a) =>
        a
        {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
        -> Word32
        {- ^ /@time_@/: a timestap (e.g. 'GI.Gdk.Constants.CURRENT_TIME'). -}
        -> m ()
    deviceUngrab device time_ = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        gdk_device_ungrab device' time_
        touchManagedPtr device
        return ()

    #if ENABLE_OVERLOADING
    data DeviceUngrabMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsDevice a) => O.MethodInfo DeviceUngrabMethodInfo a signature where
        overloadedMethod _ = deviceUngrab

    #endif

    -- method Device::warp
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the device to warp.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the screen to warp @device to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X coordinate of the destination.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the Y coordinate of the destination.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_warp" gdk_device_warp ::
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Ptr Gdk.Screen.Screen ->                -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        IO ()

    {- |
    Warps /@device@/ in /@display@/ to the point /@x@/,/@y@/ on
    the screen /@screen@/, unless the device is confined
    to a window by a grab, in which case it will be moved
    as far as allowed by the grab. Warping the pointer
    creates events as if the user had moved the mouse
    instantaneously to the destination.

    Note that the pointer should normally be under the
    control of the user. This function was added to cover
    some rare use cases like keyboard navigation support
    for the color picker in the @/GtkColorSelectionDialog/@.

    /Since: 3.0/
    -}
    deviceWarp ::
        (B.CallStack.HasCallStack, MonadIO m, IsDevice a, Gdk.Screen.IsScreen b) =>
        a
        {- ^ /@device@/: the device to warp. -}
        -> b
        {- ^ /@screen@/: the screen to warp /@device@/ to. -}
        -> Int32
        {- ^ /@x@/: the X coordinate of the destination. -}
        -> Int32
        {- ^ /@y@/: the Y coordinate of the destination. -}
        -> m ()
    deviceWarp device screen x y = liftIO $ do
        device' <- unsafeManagedPtrCastPtr device
        screen' <- unsafeManagedPtrCastPtr screen
        gdk_device_warp device' screen' x y
        touchManagedPtr device
        touchManagedPtr screen
        return ()

    #if ENABLE_OVERLOADING
    data DeviceWarpMethodInfo
    instance (signature ~ (b -> Int32 -> Int32 -> m ()), MonadIO m, IsDevice a, Gdk.Screen.IsScreen b) => O.MethodInfo DeviceWarpMethodInfo a signature where
        overloadedMethod _ = deviceWarp

    #endif

    -- method Device::grab_info_libgtk_only
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the display for which to get the grab information", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "device to get the grab information from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "grab_window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store current grab window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner_events", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store boolean indicating whether\n  the @owner_events flag to gdk_keyboard_grab() or\n  gdk_pointer_grab() was %TRUE.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gdk_device_grab_info_libgtk_only" gdk_device_grab_info_libgtk_only ::
        Ptr Gdk.Display.Display ->              -- display : TInterface (Name {namespace = "Gdk", name = "Display"})
        Ptr Device ->                           -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
        Ptr (Ptr Gdk.Window.Window) ->          -- grab_window : TInterface (Name {namespace = "Gdk", name = "Window"})
        Ptr CInt ->                             -- owner_events : TBasicType TBoolean
        IO CInt

    {-# DEPRECATED deviceGrabInfoLibgtkOnly ["(Since version 3.16)","The symbol was never meant to be used outside","  of GTK+"] #-}
    {- |
    Determines information about the current keyboard grab.
    This is not public API and must not be used by applications.
    -}
    deviceGrabInfoLibgtkOnly ::
        (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a, IsDevice b) =>
        a
        {- ^ /@display@/: the display for which to get the grab information -}
        -> b
        {- ^ /@device@/: device to get the grab information from -}
        -> m ((Bool, Gdk.Window.Window, Bool))
        {- ^ __Returns:__ 'True' if this application currently has the
     keyboard grabbed. -}
    deviceGrabInfoLibgtkOnly display device = liftIO $ do
        display' <- unsafeManagedPtrCastPtr display
        device' <- unsafeManagedPtrCastPtr device
        grabWindow <- allocMem :: IO (Ptr (Ptr Gdk.Window.Window))
        ownerEvents <- allocMem :: IO (Ptr CInt)
        result <- gdk_device_grab_info_libgtk_only display' device' grabWindow ownerEvents
        let result' = (/= 0) result
        grabWindow' <- peek grabWindow
        grabWindow'' <- (newObject Gdk.Window.Window) grabWindow'
        ownerEvents' <- peek ownerEvents
        let ownerEvents'' = (/= 0) ownerEvents'
        touchManagedPtr display
        touchManagedPtr device
        freeMem grabWindow
        freeMem ownerEvents
        return (result', grabWindow'', ownerEvents'')

    #if ENABLE_OVERLOADING
    #endif