/*
 * This file was generated by qdbusxml2cpp version 0.8
 * Source file was org.kde.kwin.InputDevice.xml
 *
 * qdbusxml2cpp is Copyright (C) The Qt Company Ltd. and other contributors.
 *
 * This is an auto-generated file.
 * Do not edit! All changes made to it will be lost.
 */

#ifndef INPUTDEVICE_INTERFACE_H
#define INPUTDEVICE_INTERFACE_H

#include <QtCore/QObject>
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QVariant>
#include <QtDBus/QtDBus>

/*
 * Proxy class for interface org.kde.KWin.InputDevice
 */
class OrgKdeKWinInputDeviceInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.kde.KWin.InputDevice"; }

public:
    OrgKdeKWinInputDeviceInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgKdeKWinInputDeviceInterface();

    Q_PROPERTY(bool alphaNumericKeyboard READ alphaNumericKeyboard)
    inline bool alphaNumericKeyboard() const
    { return qvariant_cast< bool >(property("alphaNumericKeyboard")); }

    Q_PROPERTY(QString calibrationMatrix READ calibrationMatrix WRITE setCalibrationMatrix)
    inline QString calibrationMatrix() const
    { return qvariant_cast< QString >(property("calibrationMatrix")); }
    inline void setCalibrationMatrix(const QString &value)
    { setProperty("calibrationMatrix", QVariant::fromValue(value)); }

    Q_PROPERTY(bool clickMethodAreas READ clickMethodAreas WRITE setClickMethodAreas)
    inline bool clickMethodAreas() const
    { return qvariant_cast< bool >(property("clickMethodAreas")); }
    inline void setClickMethodAreas(bool value)
    { setProperty("clickMethodAreas", QVariant::fromValue(value)); }

    Q_PROPERTY(bool clickMethodClickfinger READ clickMethodClickfinger WRITE setClickMethodClickfinger)
    inline bool clickMethodClickfinger() const
    { return qvariant_cast< bool >(property("clickMethodClickfinger")); }
    inline void setClickMethodClickfinger(bool value)
    { setProperty("clickMethodClickfinger", QVariant::fromValue(value)); }

    Q_PROPERTY(QList<uint> currentModes READ currentModes)
    inline QList<uint> currentModes() const
    { return qvariant_cast< QList<uint> >(property("currentModes")); }

    Q_PROPERTY(QString defaultCalibrationMatrix READ defaultCalibrationMatrix)
    inline QString defaultCalibrationMatrix() const
    { return qvariant_cast< QString >(property("defaultCalibrationMatrix")); }

    Q_PROPERTY(bool defaultClickMethodAreas READ defaultClickMethodAreas)
    inline bool defaultClickMethodAreas() const
    { return qvariant_cast< bool >(property("defaultClickMethodAreas")); }

    Q_PROPERTY(bool defaultClickMethodClickfinger READ defaultClickMethodClickfinger)
    inline bool defaultClickMethodClickfinger() const
    { return qvariant_cast< bool >(property("defaultClickMethodClickfinger")); }

    Q_PROPERTY(QRectF defaultInputArea READ defaultInputArea)
    inline QRectF defaultInputArea() const
    { return qvariant_cast< QRectF >(property("defaultInputArea")); }

    Q_PROPERTY(bool defaultMapToWorkspace READ defaultMapToWorkspace)
    inline bool defaultMapToWorkspace() const
    { return qvariant_cast< bool >(property("defaultMapToWorkspace")); }

    Q_PROPERTY(QRectF defaultOutputArea READ defaultOutputArea)
    inline QRectF defaultOutputArea() const
    { return qvariant_cast< QRectF >(property("defaultOutputArea")); }

    Q_PROPERTY(double defaultPointerAcceleration READ defaultPointerAcceleration)
    inline double defaultPointerAcceleration() const
    { return qvariant_cast< double >(property("defaultPointerAcceleration")); }

    Q_PROPERTY(bool defaultPointerAccelerationProfileAdaptive READ defaultPointerAccelerationProfileAdaptive)
    inline bool defaultPointerAccelerationProfileAdaptive() const
    { return qvariant_cast< bool >(property("defaultPointerAccelerationProfileAdaptive")); }

    Q_PROPERTY(bool defaultPointerAccelerationProfileFlat READ defaultPointerAccelerationProfileFlat)
    inline bool defaultPointerAccelerationProfileFlat() const
    { return qvariant_cast< bool >(property("defaultPointerAccelerationProfileFlat")); }

    Q_PROPERTY(QString defaultPressureCurve READ defaultPressureCurve)
    inline QString defaultPressureCurve() const
    { return qvariant_cast< QString >(property("defaultPressureCurve")); }

    Q_PROPERTY(double defaultPressureRangeMax READ defaultPressureRangeMax)
    inline double defaultPressureRangeMax() const
    { return qvariant_cast< double >(property("defaultPressureRangeMax")); }

    Q_PROPERTY(double defaultPressureRangeMin READ defaultPressureRangeMin)
    inline double defaultPressureRangeMin() const
    { return qvariant_cast< double >(property("defaultPressureRangeMin")); }

    Q_PROPERTY(uint defaultScrollButton READ defaultScrollButton)
    inline uint defaultScrollButton() const
    { return qvariant_cast< uint >(property("defaultScrollButton")); }

    Q_PROPERTY(QString deviceGroupId READ deviceGroupId)
    inline QString deviceGroupId() const
    { return qvariant_cast< QString >(property("deviceGroupId")); }

    Q_PROPERTY(bool disableEventsOnExternalMouse READ disableEventsOnExternalMouse WRITE setDisableEventsOnExternalMouse)
    inline bool disableEventsOnExternalMouse() const
    { return qvariant_cast< bool >(property("disableEventsOnExternalMouse")); }
    inline void setDisableEventsOnExternalMouse(bool value)
    { setProperty("disableEventsOnExternalMouse", QVariant::fromValue(value)); }

    Q_PROPERTY(bool disableEventsOnExternalMouseEnabledByDefault READ disableEventsOnExternalMouseEnabledByDefault)
    inline bool disableEventsOnExternalMouseEnabledByDefault() const
    { return qvariant_cast< bool >(property("disableEventsOnExternalMouseEnabledByDefault")); }

    Q_PROPERTY(bool disableWhileTyping READ disableWhileTyping WRITE setDisableWhileTyping)
    inline bool disableWhileTyping() const
    { return qvariant_cast< bool >(property("disableWhileTyping")); }
    inline void setDisableWhileTyping(bool value)
    { setProperty("disableWhileTyping", QVariant::fromValue(value)); }

    Q_PROPERTY(bool disableWhileTypingEnabledByDefault READ disableWhileTypingEnabledByDefault)
    inline bool disableWhileTypingEnabledByDefault() const
    { return qvariant_cast< bool >(property("disableWhileTypingEnabledByDefault")); }

    Q_PROPERTY(bool enabled READ enabled WRITE setEnabled)
    inline bool enabled() const
    { return qvariant_cast< bool >(property("enabled")); }
    inline void setEnabled(bool value)
    { setProperty("enabled", QVariant::fromValue(value)); }

    Q_PROPERTY(bool enabledByDefault READ enabledByDefault)
    inline bool enabledByDefault() const
    { return qvariant_cast< bool >(property("enabledByDefault")); }

    Q_PROPERTY(bool gestureSupport READ gestureSupport)
    inline bool gestureSupport() const
    { return qvariant_cast< bool >(property("gestureSupport")); }

    Q_PROPERTY(QRectF inputArea READ inputArea WRITE setInputArea)
    inline QRectF inputArea() const
    { return qvariant_cast< QRectF >(property("inputArea")); }
    inline void setInputArea(const QRectF &value)
    { setProperty("inputArea", QVariant::fromValue(value)); }

    Q_PROPERTY(bool isVirtual READ isVirtual)
    inline bool isVirtual() const
    { return qvariant_cast< bool >(property("isVirtual")); }

    Q_PROPERTY(bool keyboard READ keyboard)
    inline bool keyboard() const
    { return qvariant_cast< bool >(property("keyboard")); }

    Q_PROPERTY(bool leftHanded READ leftHanded WRITE setLeftHanded)
    inline bool leftHanded() const
    { return qvariant_cast< bool >(property("leftHanded")); }
    inline void setLeftHanded(bool value)
    { setProperty("leftHanded", QVariant::fromValue(value)); }

    Q_PROPERTY(bool leftHandedEnabledByDefault READ leftHandedEnabledByDefault)
    inline bool leftHandedEnabledByDefault() const
    { return qvariant_cast< bool >(property("leftHandedEnabledByDefault")); }

    Q_PROPERTY(bool lidSwitch READ lidSwitch)
    inline bool lidSwitch() const
    { return qvariant_cast< bool >(property("lidSwitch")); }

    Q_PROPERTY(bool lmrTapButtonMap READ lmrTapButtonMap WRITE setLmrTapButtonMap)
    inline bool lmrTapButtonMap() const
    { return qvariant_cast< bool >(property("lmrTapButtonMap")); }
    inline void setLmrTapButtonMap(bool value)
    { setProperty("lmrTapButtonMap", QVariant::fromValue(value)); }

    Q_PROPERTY(bool lmrTapButtonMapEnabledByDefault READ lmrTapButtonMapEnabledByDefault)
    inline bool lmrTapButtonMapEnabledByDefault() const
    { return qvariant_cast< bool >(property("lmrTapButtonMapEnabledByDefault")); }

    Q_PROPERTY(bool mapToWorkspace READ mapToWorkspace WRITE setMapToWorkspace)
    inline bool mapToWorkspace() const
    { return qvariant_cast< bool >(property("mapToWorkspace")); }
    inline void setMapToWorkspace(bool value)
    { setProperty("mapToWorkspace", QVariant::fromValue(value)); }

    Q_PROPERTY(bool middleEmulation READ middleEmulation WRITE setMiddleEmulation)
    inline bool middleEmulation() const
    { return qvariant_cast< bool >(property("middleEmulation")); }
    inline void setMiddleEmulation(bool value)
    { setProperty("middleEmulation", QVariant::fromValue(value)); }

    Q_PROPERTY(bool middleEmulationEnabledByDefault READ middleEmulationEnabledByDefault)
    inline bool middleEmulationEnabledByDefault() const
    { return qvariant_cast< bool >(property("middleEmulationEnabledByDefault")); }

    Q_PROPERTY(QString name READ name)
    inline QString name() const
    { return qvariant_cast< QString >(property("name")); }

    Q_PROPERTY(bool naturalScroll READ naturalScroll WRITE setNaturalScroll)
    inline bool naturalScroll() const
    { return qvariant_cast< bool >(property("naturalScroll")); }
    inline void setNaturalScroll(bool value)
    { setProperty("naturalScroll", QVariant::fromValue(value)); }

    Q_PROPERTY(bool naturalScrollEnabledByDefault READ naturalScrollEnabledByDefault)
    inline bool naturalScrollEnabledByDefault() const
    { return qvariant_cast< bool >(property("naturalScrollEnabledByDefault")); }

    Q_PROPERTY(QList<uint> numModes READ numModes)
    inline QList<uint> numModes() const
    { return qvariant_cast< QList<uint> >(property("numModes")); }

    Q_PROPERTY(int orientationDBus READ orientationDBus WRITE setOrientationDBus)
    inline int orientationDBus() const
    { return qvariant_cast< int >(property("orientationDBus")); }
    inline void setOrientationDBus(int value)
    { setProperty("orientationDBus", QVariant::fromValue(value)); }

    Q_PROPERTY(QRectF outputArea READ outputArea WRITE setOutputArea)
    inline QRectF outputArea() const
    { return qvariant_cast< QRectF >(property("outputArea")); }
    inline void setOutputArea(const QRectF &value)
    { setProperty("outputArea", QVariant::fromValue(value)); }

    Q_PROPERTY(QString outputName READ outputName WRITE setOutputName)
    inline QString outputName() const
    { return qvariant_cast< QString >(property("outputName")); }
    inline void setOutputName(const QString &value)
    { setProperty("outputName", QVariant::fromValue(value)); }

    Q_PROPERTY(bool pointer READ pointer)
    inline bool pointer() const
    { return qvariant_cast< bool >(property("pointer")); }

    Q_PROPERTY(double pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration)
    inline double pointerAcceleration() const
    { return qvariant_cast< double >(property("pointerAcceleration")); }
    inline void setPointerAcceleration(double value)
    { setProperty("pointerAcceleration", QVariant::fromValue(value)); }

    Q_PROPERTY(bool pointerAccelerationProfileAdaptive READ pointerAccelerationProfileAdaptive WRITE setPointerAccelerationProfileAdaptive)
    inline bool pointerAccelerationProfileAdaptive() const
    { return qvariant_cast< bool >(property("pointerAccelerationProfileAdaptive")); }
    inline void setPointerAccelerationProfileAdaptive(bool value)
    { setProperty("pointerAccelerationProfileAdaptive", QVariant::fromValue(value)); }

    Q_PROPERTY(bool pointerAccelerationProfileFlat READ pointerAccelerationProfileFlat WRITE setPointerAccelerationProfileFlat)
    inline bool pointerAccelerationProfileFlat() const
    { return qvariant_cast< bool >(property("pointerAccelerationProfileFlat")); }
    inline void setPointerAccelerationProfileFlat(bool value)
    { setProperty("pointerAccelerationProfileFlat", QVariant::fromValue(value)); }

    Q_PROPERTY(QString pressureCurve READ pressureCurve WRITE setPressureCurve)
    inline QString pressureCurve() const
    { return qvariant_cast< QString >(property("pressureCurve")); }
    inline void setPressureCurve(const QString &value)
    { setProperty("pressureCurve", QVariant::fromValue(value)); }

    Q_PROPERTY(double pressureRangeMax READ pressureRangeMax WRITE setPressureRangeMax)
    inline double pressureRangeMax() const
    { return qvariant_cast< double >(property("pressureRangeMax")); }
    inline void setPressureRangeMax(double value)
    { setProperty("pressureRangeMax", QVariant::fromValue(value)); }

    Q_PROPERTY(double pressureRangeMin READ pressureRangeMin WRITE setPressureRangeMin)
    inline double pressureRangeMin() const
    { return qvariant_cast< double >(property("pressureRangeMin")); }
    inline void setPressureRangeMin(double value)
    { setProperty("pressureRangeMin", QVariant::fromValue(value)); }

    Q_PROPERTY(uint product READ product)
    inline uint product() const
    { return qvariant_cast< uint >(property("product")); }

    Q_PROPERTY(uint scrollButton READ scrollButton WRITE setScrollButton)
    inline uint scrollButton() const
    { return qvariant_cast< uint >(property("scrollButton")); }
    inline void setScrollButton(uint value)
    { setProperty("scrollButton", QVariant::fromValue(value)); }

    Q_PROPERTY(bool scrollEdge READ scrollEdge WRITE setScrollEdge)
    inline bool scrollEdge() const
    { return qvariant_cast< bool >(property("scrollEdge")); }
    inline void setScrollEdge(bool value)
    { setProperty("scrollEdge", QVariant::fromValue(value)); }

    Q_PROPERTY(bool scrollEdgeEnabledByDefault READ scrollEdgeEnabledByDefault)
    inline bool scrollEdgeEnabledByDefault() const
    { return qvariant_cast< bool >(property("scrollEdgeEnabledByDefault")); }

    Q_PROPERTY(double scrollFactor READ scrollFactor WRITE setScrollFactor)
    inline double scrollFactor() const
    { return qvariant_cast< double >(property("scrollFactor")); }
    inline void setScrollFactor(double value)
    { setProperty("scrollFactor", QVariant::fromValue(value)); }

    Q_PROPERTY(bool scrollOnButtonDown READ scrollOnButtonDown WRITE setScrollOnButtonDown)
    inline bool scrollOnButtonDown() const
    { return qvariant_cast< bool >(property("scrollOnButtonDown")); }
    inline void setScrollOnButtonDown(bool value)
    { setProperty("scrollOnButtonDown", QVariant::fromValue(value)); }

    Q_PROPERTY(bool scrollOnButtonDownEnabledByDefault READ scrollOnButtonDownEnabledByDefault)
    inline bool scrollOnButtonDownEnabledByDefault() const
    { return qvariant_cast< bool >(property("scrollOnButtonDownEnabledByDefault")); }

    Q_PROPERTY(bool scrollTwoFinger READ scrollTwoFinger WRITE setScrollTwoFinger)
    inline bool scrollTwoFinger() const
    { return qvariant_cast< bool >(property("scrollTwoFinger")); }
    inline void setScrollTwoFinger(bool value)
    { setProperty("scrollTwoFinger", QVariant::fromValue(value)); }

    Q_PROPERTY(bool scrollTwoFingerEnabledByDefault READ scrollTwoFingerEnabledByDefault)
    inline bool scrollTwoFingerEnabledByDefault() const
    { return qvariant_cast< bool >(property("scrollTwoFingerEnabledByDefault")); }

    Q_PROPERTY(QSizeF size READ size)
    inline QSizeF size() const
    { return qvariant_cast< QSizeF >(property("size")); }

    Q_PROPERTY(int supportedButtons READ supportedButtons)
    inline int supportedButtons() const
    { return qvariant_cast< int >(property("supportedButtons")); }

    Q_PROPERTY(bool supportsCalibrationMatrix READ supportsCalibrationMatrix)
    inline bool supportsCalibrationMatrix() const
    { return qvariant_cast< bool >(property("supportsCalibrationMatrix")); }

    Q_PROPERTY(bool supportsClickMethodAreas READ supportsClickMethodAreas)
    inline bool supportsClickMethodAreas() const
    { return qvariant_cast< bool >(property("supportsClickMethodAreas")); }

    Q_PROPERTY(bool supportsClickMethodClickfinger READ supportsClickMethodClickfinger)
    inline bool supportsClickMethodClickfinger() const
    { return qvariant_cast< bool >(property("supportsClickMethodClickfinger")); }

    Q_PROPERTY(bool supportsDisableEvents READ supportsDisableEvents)
    inline bool supportsDisableEvents() const
    { return qvariant_cast< bool >(property("supportsDisableEvents")); }

    Q_PROPERTY(bool supportsDisableEventsOnExternalMouse READ supportsDisableEventsOnExternalMouse)
    inline bool supportsDisableEventsOnExternalMouse() const
    { return qvariant_cast< bool >(property("supportsDisableEventsOnExternalMouse")); }

    Q_PROPERTY(bool supportsDisableWhileTyping READ supportsDisableWhileTyping)
    inline bool supportsDisableWhileTyping() const
    { return qvariant_cast< bool >(property("supportsDisableWhileTyping")); }

    Q_PROPERTY(bool supportsInputArea READ supportsInputArea)
    inline bool supportsInputArea() const
    { return qvariant_cast< bool >(property("supportsInputArea")); }

    Q_PROPERTY(bool supportsLeftHanded READ supportsLeftHanded)
    inline bool supportsLeftHanded() const
    { return qvariant_cast< bool >(property("supportsLeftHanded")); }

    Q_PROPERTY(bool supportsLmrTapButtonMap READ supportsLmrTapButtonMap)
    inline bool supportsLmrTapButtonMap() const
    { return qvariant_cast< bool >(property("supportsLmrTapButtonMap")); }

    Q_PROPERTY(bool supportsMiddleEmulation READ supportsMiddleEmulation)
    inline bool supportsMiddleEmulation() const
    { return qvariant_cast< bool >(property("supportsMiddleEmulation")); }

    Q_PROPERTY(bool supportsNaturalScroll READ supportsNaturalScroll)
    inline bool supportsNaturalScroll() const
    { return qvariant_cast< bool >(property("supportsNaturalScroll")); }

    Q_PROPERTY(bool supportsOutputArea READ supportsOutputArea)
    inline bool supportsOutputArea() const
    { return qvariant_cast< bool >(property("supportsOutputArea")); }

    Q_PROPERTY(bool supportsPointerAcceleration READ supportsPointerAcceleration)
    inline bool supportsPointerAcceleration() const
    { return qvariant_cast< bool >(property("supportsPointerAcceleration")); }

    Q_PROPERTY(bool supportsPointerAccelerationProfileAdaptive READ supportsPointerAccelerationProfileAdaptive)
    inline bool supportsPointerAccelerationProfileAdaptive() const
    { return qvariant_cast< bool >(property("supportsPointerAccelerationProfileAdaptive")); }

    Q_PROPERTY(bool supportsPointerAccelerationProfileFlat READ supportsPointerAccelerationProfileFlat)
    inline bool supportsPointerAccelerationProfileFlat() const
    { return qvariant_cast< bool >(property("supportsPointerAccelerationProfileFlat")); }

    Q_PROPERTY(bool supportsPressureRange READ supportsPressureRange)
    inline bool supportsPressureRange() const
    { return qvariant_cast< bool >(property("supportsPressureRange")); }

    Q_PROPERTY(bool supportsRotation READ supportsRotation)
    inline bool supportsRotation() const
    { return qvariant_cast< bool >(property("supportsRotation")); }

    Q_PROPERTY(bool supportsScrollEdge READ supportsScrollEdge)
    inline bool supportsScrollEdge() const
    { return qvariant_cast< bool >(property("supportsScrollEdge")); }

    Q_PROPERTY(bool supportsScrollOnButtonDown READ supportsScrollOnButtonDown)
    inline bool supportsScrollOnButtonDown() const
    { return qvariant_cast< bool >(property("supportsScrollOnButtonDown")); }

    Q_PROPERTY(bool supportsScrollTwoFinger READ supportsScrollTwoFinger)
    inline bool supportsScrollTwoFinger() const
    { return qvariant_cast< bool >(property("supportsScrollTwoFinger")); }

    Q_PROPERTY(bool switchDevice READ switchDevice)
    inline bool switchDevice() const
    { return qvariant_cast< bool >(property("switchDevice")); }

    Q_PROPERTY(QString sysName READ sysName)
    inline QString sysName() const
    { return qvariant_cast< QString >(property("sysName")); }

    Q_PROPERTY(bool tabletModeSwitch READ tabletModeSwitch)
    inline bool tabletModeSwitch() const
    { return qvariant_cast< bool >(property("tabletModeSwitch")); }

    Q_PROPERTY(bool tabletPad READ tabletPad)
    inline bool tabletPad() const
    { return qvariant_cast< bool >(property("tabletPad")); }

    Q_PROPERTY(uint tabletPadButtonCount READ tabletPadButtonCount)
    inline uint tabletPadButtonCount() const
    { return qvariant_cast< uint >(property("tabletPadButtonCount")); }

    Q_PROPERTY(uint tabletPadDialCount READ tabletPadDialCount)
    inline uint tabletPadDialCount() const
    { return qvariant_cast< uint >(property("tabletPadDialCount")); }

    Q_PROPERTY(uint tabletPadRingCount READ tabletPadRingCount)
    inline uint tabletPadRingCount() const
    { return qvariant_cast< uint >(property("tabletPadRingCount")); }

    Q_PROPERTY(uint tabletPadStripCount READ tabletPadStripCount)
    inline uint tabletPadStripCount() const
    { return qvariant_cast< uint >(property("tabletPadStripCount")); }

    Q_PROPERTY(bool tabletTool READ tabletTool)
    inline bool tabletTool() const
    { return qvariant_cast< bool >(property("tabletTool")); }

    Q_PROPERTY(bool tabletToolIsRelative READ tabletToolIsRelative WRITE setTabletToolIsRelative)
    inline bool tabletToolIsRelative() const
    { return qvariant_cast< bool >(property("tabletToolIsRelative")); }
    inline void setTabletToolIsRelative(bool value)
    { setProperty("tabletToolIsRelative", QVariant::fromValue(value)); }

    Q_PROPERTY(bool tapAndDrag READ tapAndDrag WRITE setTapAndDrag)
    inline bool tapAndDrag() const
    { return qvariant_cast< bool >(property("tapAndDrag")); }
    inline void setTapAndDrag(bool value)
    { setProperty("tapAndDrag", QVariant::fromValue(value)); }

    Q_PROPERTY(bool tapAndDragEnabledByDefault READ tapAndDragEnabledByDefault)
    inline bool tapAndDragEnabledByDefault() const
    { return qvariant_cast< bool >(property("tapAndDragEnabledByDefault")); }

    Q_PROPERTY(bool tapDragLock READ tapDragLock WRITE setTapDragLock)
    inline bool tapDragLock() const
    { return qvariant_cast< bool >(property("tapDragLock")); }
    inline void setTapDragLock(bool value)
    { setProperty("tapDragLock", QVariant::fromValue(value)); }

    Q_PROPERTY(bool tapDragLockEnabledByDefault READ tapDragLockEnabledByDefault)
    inline bool tapDragLockEnabledByDefault() const
    { return qvariant_cast< bool >(property("tapDragLockEnabledByDefault")); }

    Q_PROPERTY(int tapFingerCount READ tapFingerCount)
    inline int tapFingerCount() const
    { return qvariant_cast< int >(property("tapFingerCount")); }

    Q_PROPERTY(bool tapToClick READ tapToClick WRITE setTapToClick)
    inline bool tapToClick() const
    { return qvariant_cast< bool >(property("tapToClick")); }
    inline void setTapToClick(bool value)
    { setProperty("tapToClick", QVariant::fromValue(value)); }

    Q_PROPERTY(bool tapToClickEnabledByDefault READ tapToClickEnabledByDefault)
    inline bool tapToClickEnabledByDefault() const
    { return qvariant_cast< bool >(property("tapToClickEnabledByDefault")); }

    Q_PROPERTY(bool touch READ touch)
    inline bool touch() const
    { return qvariant_cast< bool >(property("touch")); }

    Q_PROPERTY(bool touchpad READ touchpad)
    inline bool touchpad() const
    { return qvariant_cast< bool >(property("touchpad")); }

    Q_PROPERTY(uint vendor READ vendor)
    inline uint vendor() const
    { return qvariant_cast< uint >(property("vendor")); }

public Q_SLOTS: // METHODS
Q_SIGNALS: // SIGNALS
    void calibrationMatrixChanged();
    void clickMethodChanged();
    void currentModesChanged();
    void disableEventsOnExternalMouseChanged();
    void disableWhileTypingChanged();
    void enabledChanged();
    void inputAreaChanged();
    void leftHandedChanged();
    void mapToWorkspaceChanged();
    void middleEmulationChanged();
    void naturalScrollChanged();
    void orientationChanged();
    void outputAreaChanged();
    void outputNameChanged();
    void pointerAccelerationChanged();
    void pointerAccelerationProfileChanged();
    void pressureCurveChanged();
    void pressureRangeMaxChanged();
    void pressureRangeMinChanged();
    void rotationChanged();
    void scrollButtonChanged();
    void scrollFactorChanged();
    void scrollMethodChanged();
    void supportsPressureRangeChanged();
    void tabletToolRelativeChanged();
    void tapAndDragChanged();
    void tapButtonMapChanged();
    void tapDragLockChanged();
    void tapToClickChanged();
};

namespace org {
  namespace kde {
    namespace KWin {
      using InputDevice = ::OrgKdeKWinInputDeviceInterface;
    }
  }
}

#endif
