diff --git a/include/libopenrazer.h b/include/libopenrazer.h
index 626e396..78d1e36 100644
--- a/include/libopenrazer.h
+++ b/include/libopenrazer.h
@@ -11,7 +11,7 @@
 #include "libopenrazer/manager.h"
 #include "libopenrazer/misc.h"
 #include "libopenrazer/openrazer.h"
-#include "libopenrazer/razercapability.h"
+#include "libopenrazer/capability.h"
 
 // NOTE: DBus types -> Qt/C++ types: http://doc.qt.io/qt-5/qdbustypesystem.html#primitive-types
 
@@ -25,42 +25,42 @@ namespace libopenrazer {
 /*!
  * List of effects provided by OpenRazer.
  */
-const QVector<RazerCapability> ledFxList {
-    RazerCapability(::openrazer::RazerEffect::Off, Led::tr("Off"), 0),
-    RazerCapability(::openrazer::RazerEffect::On, Led::tr("On"), 0),
-    RazerCapability(::openrazer::RazerEffect::Static, Led::tr("Static"), 1),
-    RazerCapability(::openrazer::RazerEffect::Breathing, Led::tr("Breathing"), 1),
-    RazerCapability(::openrazer::RazerEffect::BreathingDual, Led::tr("Breathing Dual"), 2),
-    RazerCapability(::openrazer::RazerEffect::BreathingRandom, Led::tr("Breathing Random"), 0),
-    RazerCapability(::openrazer::RazerEffect::BreathingMono, Led::tr("Breathing"), 0),
-    RazerCapability(::openrazer::RazerEffect::Blinking, Led::tr("Blinking"), 1),
-    RazerCapability(::openrazer::RazerEffect::Spectrum, Led::tr("Spectrum"), 0),
-    RazerCapability(::openrazer::RazerEffect::Wave, Led::tr("Wave"), 0),
-    RazerCapability(::openrazer::RazerEffect::Wheel, Led::tr("Wheel"), 0),
-    RazerCapability(::openrazer::RazerEffect::Reactive, Led::tr("Reactive"), 1),
-    RazerCapability(::openrazer::RazerEffect::Ripple, Led::tr("Ripple"), 1),
-    RazerCapability(::openrazer::RazerEffect::RippleRandom, Led::tr("Ripple Random"), 0),
+const QVector<Capability> ledFxList {
+    Capability(::openrazer::Effect::Off, Led::tr("Off"), 0),
+    Capability(::openrazer::Effect::On, Led::tr("On"), 0),
+    Capability(::openrazer::Effect::Static, Led::tr("Static"), 1),
+    Capability(::openrazer::Effect::Breathing, Led::tr("Breathing"), 1),
+    Capability(::openrazer::Effect::BreathingDual, Led::tr("Breathing Dual"), 2),
+    Capability(::openrazer::Effect::BreathingRandom, Led::tr("Breathing Random"), 0),
+    Capability(::openrazer::Effect::BreathingMono, Led::tr("Breathing"), 0),
+    Capability(::openrazer::Effect::Blinking, Led::tr("Blinking"), 1),
+    Capability(::openrazer::Effect::Spectrum, Led::tr("Spectrum"), 0),
+    Capability(::openrazer::Effect::Wave, Led::tr("Wave"), 0),
+    Capability(::openrazer::Effect::Wheel, Led::tr("Wheel"), 0),
+    Capability(::openrazer::Effect::Reactive, Led::tr("Reactive"), 1),
+    Capability(::openrazer::Effect::Ripple, Led::tr("Ripple"), 1),
+    Capability(::openrazer::Effect::RippleRandom, Led::tr("Ripple Random"), 0),
 };
 
 /*!
- * Mapping from openrazer::RazerLedId to a human readable string
+ * Mapping from openrazer::LedId to a human readable string
  */
-const QHash<::openrazer::RazerLedId, QString> ledIdToStringTable {
-    { ::openrazer::RazerLedId::Unspecified, "" },
-    { ::openrazer::RazerLedId::ScrollWheelLED, Led::tr("Scroll Wheel") },
-    { ::openrazer::RazerLedId::BatteryLED, Led::tr("Battery") },
-    { ::openrazer::RazerLedId::LogoLED, Led::tr("Logo") },
-    { ::openrazer::RazerLedId::BacklightLED, Led::tr("Backlight") },
-    { ::openrazer::RazerLedId::MacroRecordingLED, Led::tr("Macro Recording") },
-    { ::openrazer::RazerLedId::GameModeLED, Led::tr("Game Mode") },
-    { ::openrazer::RazerLedId::KeymapRedLED, Led::tr("Keymap Red") },
-    { ::openrazer::RazerLedId::KeymapGreenLED, Led::tr("Keymap Green") },
-    { ::openrazer::RazerLedId::KeymapBlueLED, Led::tr("Keymap Blue") },
-    { ::openrazer::RazerLedId::RightSideLED, Led::tr("Right Side") },
-    { ::openrazer::RazerLedId::LeftSideLED, Led::tr("Left Side") },
-    { ::openrazer::RazerLedId::ChargingLED, Led::tr("Charging") },
-    { ::openrazer::RazerLedId::FastChargingLED, Led::tr("Fast Charging") },
-    { ::openrazer::RazerLedId::FullyChargedLED, Led::tr("Fully Charged") },
+const QHash<::openrazer::LedId, QString> ledIdToStringTable {
+    { ::openrazer::LedId::Unspecified, "" },
+    { ::openrazer::LedId::ScrollWheelLED, Led::tr("Scroll Wheel") },
+    { ::openrazer::LedId::BatteryLED, Led::tr("Battery") },
+    { ::openrazer::LedId::LogoLED, Led::tr("Logo") },
+    { ::openrazer::LedId::BacklightLED, Led::tr("Backlight") },
+    { ::openrazer::LedId::MacroRecordingLED, Led::tr("Macro Recording") },
+    { ::openrazer::LedId::GameModeLED, Led::tr("Game Mode") },
+    { ::openrazer::LedId::KeymapRedLED, Led::tr("Keymap Red") },
+    { ::openrazer::LedId::KeymapGreenLED, Led::tr("Keymap Green") },
+    { ::openrazer::LedId::KeymapBlueLED, Led::tr("Keymap Blue") },
+    { ::openrazer::LedId::RightSideLED, Led::tr("Right Side") },
+    { ::openrazer::LedId::LeftSideLED, Led::tr("Left Side") },
+    { ::openrazer::LedId::ChargingLED, Led::tr("Charging") },
+    { ::openrazer::LedId::FastChargingLED, Led::tr("Fast Charging") },
+    { ::openrazer::LedId::FullyChargedLED, Led::tr("Fully Charged") },
 };
 
 }
diff --git a/include/libopenrazer/razercapability.h b/include/libopenrazer/capability.h
similarity index 65%
rename from include/libopenrazer/razercapability.h
rename to include/libopenrazer/capability.h
index c26e237..1601863 100644
--- a/include/libopenrazer/razercapability.h
+++ b/include/libopenrazer/capability.h
@@ -2,8 +2,8 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#ifndef RAZERCAPABILITY_H
-#define RAZERCAPABILITY_H
+#ifndef CAPABILITY_H
+#define CAPABILITY_H
 
 namespace libopenrazer {
 
@@ -12,15 +12,15 @@ namespace libopenrazer {
  *
  * Helper-class used by libopenrazer for providing lists of lighting effect capabilities that can be implemented e.g. in a combobox. It can contain the number of colors an effect needs, if the effect is the 'Wave' effect and a human readable string for displaying in the UI.
  */
-class RazerCapability
+class Capability
 {
 public:
     /// @cond
-    RazerCapability();
-    RazerCapability(::openrazer::RazerEffect identifier, QString displayString, int numColors);
-    RazerCapability(::openrazer::RazerEffect, QString displayString);
-    RazerCapability(const RazerCapability &other);
-    ~RazerCapability();
+    Capability();
+    Capability(::openrazer::Effect identifier, QString displayString, int numColors);
+    Capability(::openrazer::Effect, QString displayString);
+    Capability(const Capability &other);
+    ~Capability();
     /// @endcond
 
     /*!
@@ -33,7 +33,7 @@ class RazerCapability
      *
      * e.g. \c "lighting_logo_spectrum"
      */
-    ::openrazer::RazerEffect getIdentifier() const;
+    ::openrazer::Effect getIdentifier() const;
 
     /*!
      * Returns a human-readable string describing the capability
@@ -44,12 +44,12 @@ class RazerCapability
 
 private:
     int numColors;
-    ::openrazer::RazerEffect identifier;
+    ::openrazer::Effect identifier;
     QString displayString;
 };
 
 }
 
-Q_DECLARE_METATYPE(libopenrazer::RazerCapability)
+Q_DECLARE_METATYPE(libopenrazer::Capability)
 
-#endif // RAZERCAPABILITY_H
+#endif // CAPABILITY_H
diff --git a/include/libopenrazer/device.h b/include/libopenrazer/device.h
index 6ce93ed..26c33f4 100644
--- a/include/libopenrazer/device.h
+++ b/include/libopenrazer/device.h
@@ -97,14 +97,14 @@ class Device : public QObject
      *
      * \sa getDPI(), maxDPI(), getAllowedDPIValues()
      */
-    virtual void setDPI(::openrazer::RazerDPI dpi) = 0;
+    virtual void setDPI(::openrazer::DPI dpi) = 0;
 
     /*!
      * Returns the DPI of the mouse (e.g. `[800, 800]`).
      *
      * \sa setDPI()
      */
-    virtual ::openrazer::RazerDPI getDPI() = 0;
+    virtual ::openrazer::DPI getDPI() = 0;
 
     /*!
      * Sets the DPI stages of the mouse to the specified \a dpiStages and sets stage nr. \a activeStage active.
@@ -114,7 +114,7 @@ class Device : public QObject
      *
      * \sa getDPIStages(), maxDPI()
      */
-    virtual void setDPIStages(uchar activeStage, QVector<::openrazer::RazerDPI> dpiStages) = 0;
+    virtual void setDPIStages(uchar activeStage, QVector<::openrazer::DPI> dpiStages) = 0;
 
     /*!
      * Returns a pair of the active DPI stage and the configured DPI stages of the mouse.
@@ -124,7 +124,7 @@ class Device : public QObject
      *
      * \sa setDPIStages(), maxDPI()
      */
-    virtual QPair<uchar, QVector<::openrazer::RazerDPI>> getDPIStages() = 0;
+    virtual QPair<uchar, QVector<::openrazer::DPI>> getDPIStages() = 0;
 
     /*!
      * Returns the maximum DPI possible for the device.
@@ -232,10 +232,10 @@ class Device : public ::libopenrazer::Device
     ushort getPollRate() override;
     void setPollRate(ushort pollrate) override;
     QVector<ushort> getSupportedPollRates() override;
-    void setDPI(::openrazer::RazerDPI dpi) override;
-    ::openrazer::RazerDPI getDPI() override;
-    void setDPIStages(uchar activeStage, QVector<::openrazer::RazerDPI> dpiStages) override;
-    QPair<uchar, QVector<::openrazer::RazerDPI>> getDPIStages() override;
+    void setDPI(::openrazer::DPI dpi) override;
+    ::openrazer::DPI getDPI() override;
+    void setDPIStages(uchar activeStage, QVector<::openrazer::DPI> dpiStages) override;
+    QPair<uchar, QVector<::openrazer::DPI>> getDPIStages() override;
     ushort maxDPI() override;
     QVector<ushort> getAllowedDPI() override;
     double getBatteryPercent() override;
@@ -282,10 +282,10 @@ class Device : public ::libopenrazer::Device
     ushort getPollRate() override;
     void setPollRate(ushort pollrate) override;
     QVector<ushort> getSupportedPollRates() override;
-    void setDPI(::openrazer::RazerDPI dpi) override;
-    ::openrazer::RazerDPI getDPI() override;
-    void setDPIStages(uchar activeStage, QVector<::openrazer::RazerDPI> dpiStages) override;
-    QPair<uchar, QVector<::openrazer::RazerDPI>> getDPIStages() override;
+    void setDPI(::openrazer::DPI dpi) override;
+    ::openrazer::DPI getDPI() override;
+    void setDPIStages(uchar activeStage, QVector<::openrazer::DPI> dpiStages) override;
+    QPair<uchar, QVector<::openrazer::DPI>> getDPIStages() override;
     ushort maxDPI() override;
     QVector<ushort> getAllowedDPI() override;
     double getBatteryPercent() override;
diff --git a/include/libopenrazer/led.h b/include/libopenrazer/led.h
index 0a1062a..b51e05f 100644
--- a/include/libopenrazer/led.h
+++ b/include/libopenrazer/led.h
@@ -31,12 +31,12 @@ class Led : public QObject
     /*!
      * Returns if the device has the specified \a fx
      */
-    virtual bool hasFx(::openrazer::RazerEffect fx) = 0;
+    virtual bool hasFx(::openrazer::Effect fx) = 0;
 
     /*!
      * Returns the currently active effect
      */
-    virtual ::openrazer::RazerEffect getCurrentEffect() = 0;
+    virtual ::openrazer::Effect getCurrentEffect() = 0;
 
     /*!
      * Returns the currently active colors (the list will have at least 3 elements)
@@ -51,7 +51,7 @@ class Led : public QObject
     /*!
      * Returns the Led ID of this Led
      */
-    virtual ::openrazer::RazerLedId getLedId() = 0;
+    virtual ::openrazer::LedId getLedId() = 0;
 
     /*!
      * Sets the LED to none / off.
@@ -141,16 +141,16 @@ class LedPrivate;
 class Led : public ::libopenrazer::Led
 {
 public:
-    Led(Device *device, QDBusObjectPath objectPath, ::openrazer::RazerLedId ledId, QString lightingLocation);
+    Led(Device *device, QDBusObjectPath objectPath, ::openrazer::LedId ledId, QString lightingLocation);
     ~Led() override;
 
     QDBusObjectPath getObjectPath() override;
     bool hasBrightness() override;
-    bool hasFx(::openrazer::RazerEffect fx) override;
-    ::openrazer::RazerEffect getCurrentEffect() override;
+    bool hasFx(::openrazer::Effect fx) override;
+    ::openrazer::Effect getCurrentEffect() override;
     QVector<::openrazer::RGB> getCurrentColors() override;
     ::openrazer::WaveDirection getWaveDirection() override;
-    ::openrazer::RazerLedId getLedId() override;
+    ::openrazer::LedId getLedId() override;
     void setOff() override;
     void setOn() override;
     void setStatic(::openrazer::RGB color) override;
@@ -186,11 +186,11 @@ class Led : public ::libopenrazer::Led
 
     QDBusObjectPath getObjectPath() override;
     bool hasBrightness() override;
-    bool hasFx(::openrazer::RazerEffect fx) override;
-    ::openrazer::RazerEffect getCurrentEffect() override;
+    bool hasFx(::openrazer::Effect fx) override;
+    ::openrazer::Effect getCurrentEffect() override;
     QVector<::openrazer::RGB> getCurrentColors() override;
     ::openrazer::WaveDirection getWaveDirection() override;
-    ::openrazer::RazerLedId getLedId() override;
+    ::openrazer::LedId getLedId() override;
     void setOff() override;
     void setOn() override;
     void setStatic(::openrazer::RGB color) override;
diff --git a/include/libopenrazer/openrazer.h b/include/libopenrazer/openrazer.h
index c6111e2..b301a82 100644
--- a/include/libopenrazer/openrazer.h
+++ b/include/libopenrazer/openrazer.h
@@ -12,7 +12,7 @@
 namespace openrazer {
 Q_NAMESPACE
 
-enum class RazerLedId : uchar {
+enum class LedId : uchar {
     Unspecified = 0x00,
     ScrollWheelLED = 0x01,
     BatteryLED = 0x03,
@@ -29,10 +29,10 @@ enum class RazerLedId : uchar {
     FastChargingLED = 0x21,
     FullyChargedLED = 0x22,
 };
-Q_ENUM_NS(RazerLedId)
+Q_ENUM_NS(LedId)
 
-// Marshall the RazerLedId data into a D-Bus argument
-inline QDBusArgument &operator<<(QDBusArgument &argument, const RazerLedId &value)
+// Marshall the LedId data into a D-Bus argument
+inline QDBusArgument &operator<<(QDBusArgument &argument, const LedId &value)
 {
     argument.beginStructure();
     argument << static_cast<int>(value);
@@ -40,17 +40,17 @@ inline QDBusArgument &operator<<(QDBusArgument &argument, const RazerLedId &valu
     return argument;
 }
 
-// Retrieve the RazerLedId data from the D-Bus argument
-inline const QDBusArgument &operator>>(const QDBusArgument &argument, RazerLedId &value)
+// Retrieve the LedId data from the D-Bus argument
+inline const QDBusArgument &operator>>(const QDBusArgument &argument, LedId &value)
 {
     int a;
     argument.beginStructure();
     argument >> a;
     argument.endStructure();
-    value = static_cast<RazerLedId>(a);
+    value = static_cast<LedId>(a);
     return argument;
 }
-inline uint qHash(RazerLedId key, uint seed)
+inline uint qHash(LedId key, uint seed)
 {
     return ::qHash(static_cast<uchar>(key), seed);
 }
@@ -135,7 +135,7 @@ inline const QDBusArgument &operator>>(const QDBusArgument &argument, ReactiveSp
     return argument;
 }
 
-enum class RazerEffect {
+enum class Effect {
     Off,
     On,
     Static,
@@ -151,10 +151,10 @@ enum class RazerEffect {
     Ripple,
     RippleRandom,
 };
-Q_ENUM_NS(RazerEffect)
+Q_ENUM_NS(Effect)
 
-// Marshall the RazerEffect data into a D-Bus argument
-inline QDBusArgument &operator<<(QDBusArgument &argument, const RazerEffect &value)
+// Marshall the Effect data into a D-Bus argument
+inline QDBusArgument &operator<<(QDBusArgument &argument, const Effect &value)
 {
     argument.beginStructure();
     argument << static_cast<int>(value);
@@ -162,28 +162,28 @@ inline QDBusArgument &operator<<(QDBusArgument &argument, const RazerEffect &val
     return argument;
 }
 
-// Retrieve the RazerEffect data from the D-Bus argument
-inline const QDBusArgument &operator>>(const QDBusArgument &argument, RazerEffect &value)
+// Retrieve the Effect data from the D-Bus argument
+inline const QDBusArgument &operator>>(const QDBusArgument &argument, Effect &value)
 {
     int a;
     argument.beginStructure();
     argument >> a;
     argument.endStructure();
-    value = static_cast<RazerEffect>(a);
+    value = static_cast<Effect>(a);
     return argument;
 }
-inline uint qHash(RazerEffect key, uint seed)
+inline uint qHash(Effect key, uint seed)
 {
     return ::qHash(static_cast<uint>(key), seed);
 }
 
-struct RazerDPI {
+struct DPI {
     ushort dpi_x;
     ushort dpi_y;
 };
 
-// Marshall the RazerDPI data into a D-Bus argument
-inline QDBusArgument &operator<<(QDBusArgument &argument, const RazerDPI &value)
+// Marshall the DPI data into a D-Bus argument
+inline QDBusArgument &operator<<(QDBusArgument &argument, const DPI &value)
 {
     argument.beginStructure();
     argument << value.dpi_x << value.dpi_y;
@@ -191,8 +191,8 @@ inline QDBusArgument &operator<<(QDBusArgument &argument, const RazerDPI &value)
     return argument;
 }
 
-// Retrieve the RazerDPI data from the D-Bus argument
-inline const QDBusArgument &operator>>(const QDBusArgument &argument, RazerDPI &value)
+// Retrieve the DPI data from the D-Bus argument
+inline const QDBusArgument &operator>>(const QDBusArgument &argument, DPI &value)
 {
     argument.beginStructure();
     argument >> value.dpi_x >> value.dpi_y;
@@ -200,9 +200,9 @@ inline const QDBusArgument &operator>>(const QDBusArgument &argument, RazerDPI &
     return argument;
 }
 
-inline QDebug operator<<(QDebug dbg, const RazerDPI &value)
+inline QDebug operator<<(QDebug dbg, const DPI &value)
 {
-    dbg.nospace() << "RazerDPI(" << value.dpi_x << ", " << value.dpi_y << ")";
+    dbg.nospace() << "DPI(" << value.dpi_x << ", " << value.dpi_y << ")";
     return dbg.maybeSpace();
 }
 
@@ -267,12 +267,12 @@ inline QDebug operator<<(QDebug dbg, const RGB &value)
 
 }
 
-Q_DECLARE_METATYPE(openrazer::RazerLedId)
+Q_DECLARE_METATYPE(openrazer::LedId)
 Q_DECLARE_METATYPE(openrazer::WaveDirection)
 Q_DECLARE_METATYPE(openrazer::WheelDirection)
 Q_DECLARE_METATYPE(openrazer::ReactiveSpeed)
-Q_DECLARE_METATYPE(openrazer::RazerEffect)
-Q_DECLARE_METATYPE(openrazer::RazerDPI)
+Q_DECLARE_METATYPE(openrazer::Effect)
+Q_DECLARE_METATYPE(openrazer::DPI)
 Q_DECLARE_METATYPE(openrazer::MatrixDimensions)
 Q_DECLARE_METATYPE(openrazer::RGB)
 
@@ -280,8 +280,8 @@ namespace openrazer {
 
 inline void registerMetaTypes()
 {
-    qRegisterMetaType<RazerLedId>("RazerLedId");
-    qDBusRegisterMetaType<RazerLedId>();
+    qRegisterMetaType<LedId>("LedId");
+    qDBusRegisterMetaType<LedId>();
 
     qRegisterMetaType<WaveDirection>("WaveDirection");
     qDBusRegisterMetaType<WaveDirection>();
@@ -289,12 +289,12 @@ inline void registerMetaTypes()
     qRegisterMetaType<WheelDirection>("WheelDirection");
     qDBusRegisterMetaType<WheelDirection>();
 
-    qRegisterMetaType<RazerDPI>("RazerDPI");
-    qDBusRegisterMetaType<RazerDPI>();
-    qRegisterMetaType<QVector<RazerDPI>>("QVector<RazerDPI>");
-    qDBusRegisterMetaType<QVector<RazerDPI>>();
-    qRegisterMetaType<QPair<uchar, QVector<::openrazer::RazerDPI>>>("QPair<uchar, QVector<RazerDPI>>");
-    qDBusRegisterMetaType<QPair<uchar, QVector<::openrazer::RazerDPI>>>();
+    qRegisterMetaType<DPI>("DPI");
+    qDBusRegisterMetaType<DPI>();
+    qRegisterMetaType<QVector<DPI>>("QVector<DPI>");
+    qDBusRegisterMetaType<QVector<DPI>>();
+    qRegisterMetaType<QPair<uchar, QVector<::openrazer::DPI>>>("QPair<uchar, QVector<DPI>>");
+    qDBusRegisterMetaType<QPair<uchar, QVector<::openrazer::DPI>>>();
 
     qRegisterMetaType<ReactiveSpeed>("ReactiveSpeed");
     qDBusRegisterMetaType<ReactiveSpeed>();
@@ -307,8 +307,8 @@ inline void registerMetaTypes()
     qRegisterMetaType<QVector<RGB>>("QVector<RGB>");
     qDBusRegisterMetaType<QVector<RGB>>();
 
-    qRegisterMetaType<RazerEffect>("RazerEffect");
-    qDBusRegisterMetaType<RazerEffect>();
+    qRegisterMetaType<Effect>("Effect");
+    qDBusRegisterMetaType<Effect>();
 
     qDBusRegisterMetaType<QList<QDBusObjectPath>>();
 }
diff --git a/meson.build b/meson.build
index 6fdc2ef..cf312e9 100644
--- a/meson.build
+++ b/meson.build
@@ -9,7 +9,7 @@ qt_dep = dependency('qt5', modules : ['Core', 'DBus', 'Gui', 'Xml'])
 sources = [
     'src/dbusexception.cpp',
     'src/misc.cpp',
-    'src/razercapability.cpp',
+    'src/capability.cpp',
 
     'src/openrazer/device.cpp',
     'src/openrazer/led.cpp',
@@ -57,7 +57,7 @@ install_headers('include/libopenrazer/dbusexception.h',
                 'include/libopenrazer/manager.h',
                 'include/libopenrazer/misc.h',
                 'include/libopenrazer/openrazer.h',
-                'include/libopenrazer/razercapability.h',
+                'include/libopenrazer/capability.h',
                 subdir : 'libopenrazer')
 
 pkg = import('pkgconfig')
diff --git a/src/razercapability.cpp b/src/capability.cpp
similarity index 54%
rename from src/razercapability.cpp
rename to src/capability.cpp
index 4ce3b90..d56e555 100644
--- a/src/razercapability.cpp
+++ b/src/capability.cpp
@@ -6,39 +6,39 @@
 
 namespace libopenrazer {
 
-RazerCapability::RazerCapability()
+Capability::Capability()
 {
-    this->identifier = ::openrazer::RazerEffect::Off;
+    this->identifier = ::openrazer::Effect::Off;
     this->displayString = "";
     this->numColors = 0;
 }
-RazerCapability::RazerCapability(::openrazer::RazerEffect identifier, QString displayString, int numColors)
+Capability::Capability(::openrazer::Effect identifier, QString displayString, int numColors)
 {
     this->identifier = identifier;
     this->displayString = displayString;
     this->numColors = numColors;
 }
 
-RazerCapability::RazerCapability(const RazerCapability &other)
+Capability::Capability(const Capability &other)
 {
     this->identifier = other.identifier;
     this->displayString = other.displayString;
     this->numColors = other.numColors;
 }
 
-RazerCapability::~RazerCapability() = default;
+Capability::~Capability() = default;
 
-int RazerCapability::getNumColors() const
+int Capability::getNumColors() const
 {
     return numColors;
 }
 
-::openrazer::RazerEffect RazerCapability::getIdentifier() const
+::openrazer::Effect Capability::getIdentifier() const
 {
     return identifier;
 }
 
-QString RazerCapability::getDisplayString() const
+QString Capability::getDisplayString() const
 {
     return displayString;
 }
diff --git a/src/demo/libopenrazerdemo.cpp b/src/demo/libopenrazerdemo.cpp
index f87b213..c8e608f 100644
--- a/src/demo/libopenrazerdemo.cpp
+++ b/src/demo/libopenrazerdemo.cpp
@@ -10,7 +10,7 @@
 
 #include <stdexcept>
 
-void setEffect(libopenrazer::Led *led, openrazer::RazerEffect effect, QVector<::openrazer::RGB> colors)
+void setEffect(libopenrazer::Led *led, openrazer::Effect effect, QVector<::openrazer::RGB> colors)
 {
     if (colors.size() < 2)
         colors += ::openrazer::RGB { 50, 254, 100 };
@@ -18,59 +18,59 @@ void setEffect(libopenrazer::Led *led, openrazer::RazerEffect effect, QVector<::
         colors += ::openrazer::RGB { 173, 16, 160 };
 
     switch (effect) {
-    case openrazer::RazerEffect::Off: {
+    case openrazer::Effect::Off: {
         led->setOff();
         break;
     }
-    case openrazer::RazerEffect::On: {
+    case openrazer::Effect::On: {
         led->setOn();
         break;
     }
-    case openrazer::RazerEffect::Static: {
+    case openrazer::Effect::Static: {
         led->setStatic(colors[0]);
         break;
     }
-    case openrazer::RazerEffect::Breathing: {
+    case openrazer::Effect::Breathing: {
         led->setBreathing(colors[0]);
         break;
     }
-    case openrazer::RazerEffect::BreathingDual: {
+    case openrazer::Effect::BreathingDual: {
         led->setBreathingDual(colors[0], colors[1]);
         break;
     }
-    case openrazer::RazerEffect::BreathingRandom: {
+    case openrazer::Effect::BreathingRandom: {
         led->setBreathingRandom();
         break;
     }
-    case openrazer::RazerEffect::BreathingMono: {
+    case openrazer::Effect::BreathingMono: {
         led->setBreathingMono();
         break;
     }
-    case openrazer::RazerEffect::Blinking: {
+    case openrazer::Effect::Blinking: {
         led->setBlinking(colors[0]);
         break;
     }
-    case openrazer::RazerEffect::Spectrum: {
+    case openrazer::Effect::Spectrum: {
         led->setSpectrum();
         break;
     }
-    case openrazer::RazerEffect::Wave: {
+    case openrazer::Effect::Wave: {
         led->setWave(openrazer::WaveDirection::LEFT_TO_RIGHT);
         break;
     }
-    case openrazer::RazerEffect::Wheel: {
+    case openrazer::Effect::Wheel: {
         led->setWheel(openrazer::WheelDirection::CLOCKWISE);
         break;
     }
-    case openrazer::RazerEffect::Reactive: {
+    case openrazer::Effect::Reactive: {
         led->setReactive(colors[0], openrazer::ReactiveSpeed::_500MS);
         break;
     }
-    case openrazer::RazerEffect::Ripple: {
+    case openrazer::Effect::Ripple: {
         led->setRipple(colors[0]);
         break;
     }
-    case openrazer::RazerEffect::RippleRandom: {
+    case openrazer::Effect::RippleRandom: {
         led->setRippleRandom();
         break;
     }
@@ -124,7 +124,7 @@ int main(int argc, char *argv[])
         }
 
         if (device->hasFeature("dpi")) {
-            openrazer::RazerDPI dpi = device->getDPI();
+            openrazer::DPI dpi = device->getDPI();
             qDebug() << "DPI:" << dpi;
             if (device->hasFeature("restricted_dpi")) {
                 QVector<ushort> allowedDPI = device->getAllowedDPI();
@@ -135,7 +135,7 @@ int main(int argc, char *argv[])
                 device->setDPI({ 500, 500 });
             }
             if (device->hasFeature("dpi_stages")) {
-                QPair<uchar, QVector<openrazer::RazerDPI>> dpiStages = device->getDPIStages();
+                QPair<uchar, QVector<openrazer::DPI>> dpiStages = device->getDPIStages();
                 qDebug() << "DPI stages:" << dpiStages;
                 device->setDPIStages(2, { { 400, 500 }, { 600, 700 }, { 800, 900 } });
                 // restore DPI stages
@@ -187,14 +187,14 @@ int main(int argc, char *argv[])
             if (led->hasBrightness()) {
                 qDebug() << "  Brightness:" << led->getBrightness();
             }
-            openrazer::RazerEffect effect = led->getCurrentEffect();
+            openrazer::Effect effect = led->getCurrentEffect();
             qDebug() << "  Effect:" << effect;
             QVector<openrazer::RGB> colors = led->getCurrentColors();
             qDebug() << "  Colors:" << colors;
             openrazer::WaveDirection waveDirection = led->getWaveDirection();
             qDebug() << "  Wave direction:" << waveDirection;
 
-            for (const libopenrazer::RazerCapability &cap : libopenrazer::ledFxList) {
+            for (const libopenrazer::Capability &cap : libopenrazer::ledFxList) {
                 if (led->hasFx(cap.getIdentifier())) {
                     setEffect(led, cap.getIdentifier(), QVector<::openrazer::RGB>());
                 }
diff --git a/src/openrazer/device.cpp b/src/openrazer/device.cpp
index 5d402ec..f7565bb 100644
--- a/src/openrazer/device.cpp
+++ b/src/openrazer/device.cpp
@@ -25,7 +25,7 @@ Device::Device(QDBusObjectPath objectPath)
     d->introspect();
     d->setupCapabilities();
 
-    QMap<::openrazer::RazerLedId, QString>::const_iterator i = d->supportedLeds.constBegin();
+    QMap<::openrazer::LedId, QString>::const_iterator i = d->supportedLeds.constBegin();
     while (i != d->supportedLeds.constEnd()) {
         Led *led = new Led(this, d->mObjectPath, i.key(), i.value());
         d->leds.append(led);
@@ -97,29 +97,29 @@ void DevicePrivate::setupCapabilities()
         || hasCapabilityInternal("razer.device.lighting.chroma", "setStatic")
         || hasCapabilityInternal("razer.device.lighting.bw2013")
         || hasCapabilityInternal("razer.device.lighting.brightness"))
-        supportedLeds.insert(::openrazer::RazerLedId::Unspecified, "Chroma");
+        supportedLeds.insert(::openrazer::LedId::Unspecified, "Chroma");
     if (hasCapabilityInternal("razer.device.lighting.logo"))
-        supportedLeds.insert(::openrazer::RazerLedId::LogoLED, "Logo");
+        supportedLeds.insert(::openrazer::LedId::LogoLED, "Logo");
     if (hasCapabilityInternal("razer.device.lighting.scroll"))
-        supportedLeds.insert(::openrazer::RazerLedId::ScrollWheelLED, "Scroll");
+        supportedLeds.insert(::openrazer::LedId::ScrollWheelLED, "Scroll");
     if (hasCapabilityInternal("razer.device.lighting.backlight"))
-        supportedLeds.insert(::openrazer::RazerLedId::BacklightLED, "Backlight");
+        supportedLeds.insert(::openrazer::LedId::BacklightLED, "Backlight");
     if (hasCapabilityInternal("razer.device.lighting.left"))
-        supportedLeds.insert(::openrazer::RazerLedId::LeftSideLED, "Left");
+        supportedLeds.insert(::openrazer::LedId::LeftSideLED, "Left");
     if (hasCapabilityInternal("razer.device.lighting.right"))
-        supportedLeds.insert(::openrazer::RazerLedId::RightSideLED, "Right");
+        supportedLeds.insert(::openrazer::LedId::RightSideLED, "Right");
     if (hasCapabilityInternal("razer.device.lighting.profile_led", "setRedLED"))
-        supportedLeds.insert(::openrazer::RazerLedId::KeymapRedLED, "RedLED");
+        supportedLeds.insert(::openrazer::LedId::KeymapRedLED, "RedLED");
     if (hasCapabilityInternal("razer.device.lighting.profile_led", "setGreenLED"))
-        supportedLeds.insert(::openrazer::RazerLedId::KeymapGreenLED, "GreenLED");
+        supportedLeds.insert(::openrazer::LedId::KeymapGreenLED, "GreenLED");
     if (hasCapabilityInternal("razer.device.lighting.profile_led", "setBlueLED"))
-        supportedLeds.insert(::openrazer::RazerLedId::KeymapBlueLED, "BlueLED");
+        supportedLeds.insert(::openrazer::LedId::KeymapBlueLED, "BlueLED");
     if (hasCapabilityInternal("razer.device.lighting.charging"))
-        supportedLeds.insert(::openrazer::RazerLedId::ChargingLED, "Charging");
+        supportedLeds.insert(::openrazer::LedId::ChargingLED, "Charging");
     if (hasCapabilityInternal("razer.device.lighting.fast_charging"))
-        supportedLeds.insert(::openrazer::RazerLedId::FastChargingLED, "FastCharging");
+        supportedLeds.insert(::openrazer::LedId::FastChargingLED, "FastCharging");
     if (hasCapabilityInternal("razer.device.lighting.fully_charged"))
-        supportedLeds.insert(::openrazer::RazerLedId::FullyChargedLED, "FullyCharged");
+        supportedLeds.insert(::openrazer::LedId::FullyChargedLED, "FullyCharged");
 }
 
 /**
@@ -238,13 +238,13 @@ QVector<ushort> Device::getSupportedPollRates()
     return handleDBusReply(reply, Q_FUNC_INFO);
 }
 
-void Device::setDPI(::openrazer::RazerDPI dpi)
+void Device::setDPI(::openrazer::DPI dpi)
 {
     QDBusReply<void> reply = d->deviceDpiIface()->call("setDPI", QVariant::fromValue(dpi.dpi_x), QVariant::fromValue(dpi.dpi_y));
     handleDBusReply(reply, Q_FUNC_INFO);
 }
 
-::openrazer::RazerDPI Device::getDPI()
+::openrazer::DPI Device::getDPI()
 {
     QDBusReply<QList<int>> reply = d->deviceDpiIface()->call("getDPI");
     QList<int> dpi = handleDBusReply(reply, Q_FUNC_INFO);
@@ -257,15 +257,15 @@ ::openrazer::RazerDPI Device::getDPI()
     }
 }
 
-void Device::setDPIStages(uchar activeStage, QVector<::openrazer::RazerDPI> dpiStages)
+void Device::setDPIStages(uchar activeStage, QVector<::openrazer::DPI> dpiStages)
 {
     QDBusReply<void> reply = d->deviceDpiIface()->call("setDPIStages", QVariant::fromValue(activeStage), QVariant::fromValue(dpiStages));
     handleDBusReply(reply, Q_FUNC_INFO);
 }
 
-QPair<uchar, QVector<::openrazer::RazerDPI>> Device::getDPIStages()
+QPair<uchar, QVector<::openrazer::DPI>> Device::getDPIStages()
 {
-    QDBusReply<QPair<uchar, QVector<::openrazer::RazerDPI>>> reply = d->deviceDpiIface()->call("getDPIStages");
+    QDBusReply<QPair<uchar, QVector<::openrazer::DPI>>> reply = d->deviceDpiIface()->call("getDPIStages");
     return handleDBusReply(reply, Q_FUNC_INFO);
 }
 
diff --git a/src/openrazer/device_p.h b/src/openrazer/device_p.h
index c909c93..e1c088d 100644
--- a/src/openrazer/device_p.h
+++ b/src/openrazer/device_p.h
@@ -39,8 +39,8 @@ class DevicePrivate
     bool hasCapabilityInternal(const QString &interface, const QString &method = QString());
     QStringList introspection;
 
-    // Maps RazerLedId to "Chroma" or "Scroll" (the string put e.g. into setScrollSpectrum)
-    QMap<::openrazer::RazerLedId, QString> supportedLeds;
+    // Maps LedId to "Chroma" or "Scroll" (the string put e.g. into setScrollSpectrum)
+    QMap<::openrazer::LedId, QString> supportedLeds;
 };
 
 }
diff --git a/src/openrazer/led.cpp b/src/openrazer/led.cpp
index 3b3e725..aa0c005 100644
--- a/src/openrazer/led.cpp
+++ b/src/openrazer/led.cpp
@@ -18,7 +18,7 @@ namespace libopenrazer {
 
 namespace openrazer {
 
-Led::Led(Device *device, QDBusObjectPath objectPath, ::openrazer::RazerLedId ledId, QString lightingLocation)
+Led::Led(Device *device, QDBusObjectPath objectPath, ::openrazer::LedId ledId, QString lightingLocation)
 {
     d = new LedPrivate();
     d->mParent = this;
@@ -49,50 +49,50 @@ Led::~Led() = default;
 void LedPrivate::setupCapabilities()
 {
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "None"))
-        supportedFx.append(::openrazer::RazerEffect::Off);
+        supportedFx.append(::openrazer::Effect::Off);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "On"))
-        supportedFx.append(::openrazer::RazerEffect::On);
+        supportedFx.append(::openrazer::Effect::On);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "Static"))
-        supportedFx.append(::openrazer::RazerEffect::Static);
+        supportedFx.append(::openrazer::Effect::Static);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "Blinking"))
-        supportedFx.append(::openrazer::RazerEffect::Blinking);
+        supportedFx.append(::openrazer::Effect::Blinking);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "BreathSingle"))
-        supportedFx.append(::openrazer::RazerEffect::Breathing);
+        supportedFx.append(::openrazer::Effect::Breathing);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "BreathDual"))
-        supportedFx.append(::openrazer::RazerEffect::BreathingDual);
+        supportedFx.append(::openrazer::Effect::BreathingDual);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "BreathRandom"))
-        supportedFx.append(::openrazer::RazerEffect::BreathingRandom);
+        supportedFx.append(::openrazer::Effect::BreathingRandom);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "BreathMono"))
-        supportedFx.append(::openrazer::RazerEffect::BreathingMono);
+        supportedFx.append(::openrazer::Effect::BreathingMono);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "Spectrum"))
-        supportedFx.append(::openrazer::RazerEffect::Spectrum);
+        supportedFx.append(::openrazer::Effect::Spectrum);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "Wave"))
-        supportedFx.append(::openrazer::RazerEffect::Wave);
+        supportedFx.append(::openrazer::Effect::Wave);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "Wheel"))
-        supportedFx.append(::openrazer::RazerEffect::Wheel);
+        supportedFx.append(::openrazer::Effect::Wheel);
     if (device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "Reactive"))
-        supportedFx.append(::openrazer::RazerEffect::Reactive);
+        supportedFx.append(::openrazer::Effect::Reactive);
 
     if (supportedFx.isEmpty() && device->d->hasCapabilityInternal(interface, "set" + lightingLocationMethod + "Active")) {
-        supportedFx.append(::openrazer::RazerEffect::Off);
-        supportedFx.append(::openrazer::RazerEffect::On);
+        supportedFx.append(::openrazer::Effect::Off);
+        supportedFx.append(::openrazer::Effect::On);
     }
 
     if (device->d->hasCapabilityInternal("razer.device.lighting.profile_led", "set" + lightingLocationMethod)) {
-        supportedFx.append(::openrazer::RazerEffect::Off);
-        supportedFx.append(::openrazer::RazerEffect::On);
+        supportedFx.append(::openrazer::Effect::Off);
+        supportedFx.append(::openrazer::Effect::On);
     }
 
     // No-color static/breathing variants
     if (device->d->hasCapabilityInternal("razer.device.lighting.bw2013", "setStatic"))
-        supportedFx.append(::openrazer::RazerEffect::Static);
+        supportedFx.append(::openrazer::Effect::Static);
     if (device->d->hasCapabilityInternal("razer.device.lighting.bw2013", "setPulsate"))
-        supportedFx.append(::openrazer::RazerEffect::Breathing);
+        supportedFx.append(::openrazer::Effect::Breathing);
 
     if (device->d->hasCapabilityInternal("razer.device.lighting.custom", "setRipple"))
-        supportedFx.append(::openrazer::RazerEffect::Ripple);
+        supportedFx.append(::openrazer::Effect::Ripple);
     if (device->d->hasCapabilityInternal("razer.device.lighting.custom", "setRippleRandomColour"))
-        supportedFx.append(::openrazer::RazerEffect::RippleRandom);
+        supportedFx.append(::openrazer::Effect::RippleRandom);
 
     if (lightingLocation == "Chroma") {
         if (device->d->hasCapabilityInternal("razer.device.lighting.brightness", "setBrightness"))
@@ -113,22 +113,22 @@ bool Led::hasBrightness()
     return d->supportsBrightness;
 }
 
-bool Led::hasFx(::openrazer::RazerEffect fx)
+bool Led::hasFx(::openrazer::Effect fx)
 {
     return d->supportedFx.contains(fx);
 }
 
-::openrazer::RazerEffect Led::getCurrentEffect()
+::openrazer::Effect Led::getCurrentEffect()
 {
     // OpenRazer doesn't expose get*Effect when there's no effect supported.
     if (!d->hasFx()) {
-        return ::openrazer::RazerEffect::Off;
+        return ::openrazer::Effect::Off;
     }
 
     // Devices with On/Off effects need special handling, except for when
     // openrazer already supports the "On" effect. Then we can treat it
     // standard.
-    if (hasFx(::openrazer::RazerEffect::On) &&
+    if (hasFx(::openrazer::Effect::On) &&
             !d->device->d->hasCapabilityInternal(d->interface, "set" + d->lightingLocationMethod + "On")) {
         QDBusReply<bool> reply;
         if (d->isProfileLed())
@@ -136,7 +136,7 @@ ::openrazer::RazerEffect Led::getCurrentEffect()
         else
             reply = d->ledIface()->call("get" + d->lightingLocationMethod + "Active");
         bool on = handleDBusReply(reply, Q_FUNC_INFO);
-        return on ? ::openrazer::RazerEffect::On : ::openrazer::RazerEffect::Off;
+        return on ? ::openrazer::Effect::On : ::openrazer::Effect::Off;
     }
 
     QDBusReply<QString> reply = d->ledIface()->call("get" + d->lightingLocationMethod + "Effect");
@@ -147,36 +147,36 @@ ::openrazer::RazerEffect Led::getCurrentEffect()
     // * starlightDual
     // * starlightRandom
     if (effect == "none") {
-        return ::openrazer::RazerEffect::Off;
+        return ::openrazer::Effect::Off;
     } else if (effect == "on") {
-        return ::openrazer::RazerEffect::On;
+        return ::openrazer::Effect::On;
     } else if (effect == "static") {
-        return ::openrazer::RazerEffect::Static;
+        return ::openrazer::Effect::Static;
     } else if (effect == "breathSingle" || effect == "pulsate") {
-        return ::openrazer::RazerEffect::Breathing;
+        return ::openrazer::Effect::Breathing;
     } else if (effect == "breathDual") {
-        return ::openrazer::RazerEffect::BreathingDual;
+        return ::openrazer::Effect::BreathingDual;
     } else if (effect == "breathRandom") {
-        return ::openrazer::RazerEffect::BreathingRandom;
+        return ::openrazer::Effect::BreathingRandom;
     } else if (effect == "breathMono") {
-        return ::openrazer::RazerEffect::BreathingMono;
+        return ::openrazer::Effect::BreathingMono;
     } else if (effect == "blinking") {
-        return ::openrazer::RazerEffect::Blinking;
+        return ::openrazer::Effect::Blinking;
     } else if (effect == "spectrum") {
-        return ::openrazer::RazerEffect::Spectrum;
+        return ::openrazer::Effect::Spectrum;
     } else if (effect == "wave") {
-        return ::openrazer::RazerEffect::Wave;
+        return ::openrazer::Effect::Wave;
     } else if (effect == "wheel") {
-        return ::openrazer::RazerEffect::Wheel;
+        return ::openrazer::Effect::Wheel;
     } else if (effect == "reactive") {
-        return ::openrazer::RazerEffect::Reactive;
+        return ::openrazer::Effect::Reactive;
     } else if (effect == "ripple") {
-        return ::openrazer::RazerEffect::Ripple;
+        return ::openrazer::Effect::Ripple;
     } else if (effect == "rippleRandomColour") {
-        return ::openrazer::RazerEffect::RippleRandom;
+        return ::openrazer::Effect::RippleRandom;
     } else {
         qWarning("libopenrazer: Unhandled effect in getCurrentEffect: %s, defaulting to Spectrum", qUtf8Printable(effect));
-        return ::openrazer::RazerEffect::Spectrum;
+        return ::openrazer::Effect::Spectrum;
     }
 }
 
@@ -215,7 +215,7 @@ ::openrazer::WaveDirection Led::getWaveDirection()
     return static_cast<::openrazer::WaveDirection>(value);
 }
 
-::openrazer::RazerLedId Led::getLedId()
+::openrazer::LedId Led::getLedId()
 {
     return d->ledId;
 }
@@ -354,9 +354,9 @@ bool LedPrivate::hasFx()
 
 bool LedPrivate::isProfileLed()
 {
-    return ledId == ::openrazer::RazerLedId::KeymapRedLED
-            || ledId == ::openrazer::RazerLedId::KeymapGreenLED
-            || ledId == ::openrazer::RazerLedId::KeymapBlueLED;
+    return ledId == ::openrazer::LedId::KeymapRedLED
+            || ledId == ::openrazer::LedId::KeymapGreenLED
+            || ledId == ::openrazer::LedId::KeymapBlueLED;
 }
 
 QDBusInterface *LedPrivate::ledIface()
diff --git a/src/openrazer/led_p.h b/src/openrazer/led_p.h
index 9a53125..fa562d2 100644
--- a/src/openrazer/led_p.h
+++ b/src/openrazer/led_p.h
@@ -30,10 +30,10 @@ class LedPrivate
     Device *device;
     QDBusObjectPath mObjectPath;
 
-    QVector<::openrazer::RazerEffect> supportedFx;
+    QVector<::openrazer::Effect> supportedFx;
     bool supportsBrightness;
 
-    ::openrazer::RazerLedId ledId;
+    ::openrazer::LedId ledId;
     QString lightingLocation;
     QString lightingLocationMethod;
     QString interface;
diff --git a/src/razer_test/device.cpp b/src/razer_test/device.cpp
index 8202eed..abc4249 100644
--- a/src/razer_test/device.cpp
+++ b/src/razer_test/device.cpp
@@ -124,24 +124,24 @@ QVector<ushort> Device::getSupportedPollRates()
     return { 125, 500, 1000 };
 }
 
-void Device::setDPI(::openrazer::RazerDPI dpi)
+void Device::setDPI(::openrazer::DPI dpi)
 {
     QDBusReply<bool> reply = d->deviceIface()->call("setDPI", QVariant::fromValue(dpi));
     handleVoidDBusReply(reply, Q_FUNC_INFO);
 }
 
-::openrazer::RazerDPI Device::getDPI()
+::openrazer::DPI Device::getDPI()
 {
-    QDBusReply<::openrazer::RazerDPI> reply = d->deviceIface()->call("getDPI");
+    QDBusReply<::openrazer::DPI> reply = d->deviceIface()->call("getDPI");
     return handleDBusReply(reply, Q_FUNC_INFO);
 }
 
-void Device::setDPIStages(uchar activeStage, QVector<::openrazer::RazerDPI> dpiStages)
+void Device::setDPIStages(uchar activeStage, QVector<::openrazer::DPI> dpiStages)
 {
     // TODO Needs implementation
 }
 
-QPair<uchar, QVector<::openrazer::RazerDPI>> Device::getDPIStages()
+QPair<uchar, QVector<::openrazer::DPI>> Device::getDPIStages()
 {
     // TODO Needs implementation
     return { 0, {} };
diff --git a/src/razer_test/led.cpp b/src/razer_test/led.cpp
index 2cb9774..1faa2e2 100644
--- a/src/razer_test/led.cpp
+++ b/src/razer_test/led.cpp
@@ -31,54 +31,54 @@ bool Led::hasBrightness()
     return d->hasFx("brightness");
 }
 
-bool Led::hasFx(::openrazer::RazerEffect fx)
+bool Led::hasFx(::openrazer::Effect fx)
 {
     QString fxStr;
     switch (fx) {
-    case ::openrazer::RazerEffect::Off:
+    case ::openrazer::Effect::Off:
         fxStr = "off";
         break;
-    case ::openrazer::RazerEffect::On:
+    case ::openrazer::Effect::On:
         fxStr = "on";
         break;
-    case ::openrazer::RazerEffect::Static:
+    case ::openrazer::Effect::Static:
         fxStr = "static";
         break;
-    case ::openrazer::RazerEffect::Breathing:
+    case ::openrazer::Effect::Breathing:
         fxStr = "breathing";
         break;
-    case ::openrazer::RazerEffect::BreathingDual:
+    case ::openrazer::Effect::BreathingDual:
         fxStr = "breathing_dual";
         break;
-    case ::openrazer::RazerEffect::BreathingRandom:
+    case ::openrazer::Effect::BreathingRandom:
         fxStr = "breathing_random";
         break;
-    case ::openrazer::RazerEffect::Blinking:
+    case ::openrazer::Effect::Blinking:
         fxStr = "blinking";
         break;
-    case ::openrazer::RazerEffect::Spectrum:
+    case ::openrazer::Effect::Spectrum:
         fxStr = "spectrum";
         break;
-    case ::openrazer::RazerEffect::Wave:
+    case ::openrazer::Effect::Wave:
         fxStr = "wave";
         break;
-    case ::openrazer::RazerEffect::Reactive:
+    case ::openrazer::Effect::Reactive:
         fxStr = "reactive";
         break;
-    case ::openrazer::RazerEffect::Wheel:
-    case ::openrazer::RazerEffect::BreathingMono:
-    case ::openrazer::RazerEffect::Ripple:
-    case ::openrazer::RazerEffect::RippleRandom:
+    case ::openrazer::Effect::Wheel:
+    case ::openrazer::Effect::BreathingMono:
+    case ::openrazer::Effect::Ripple:
+    case ::openrazer::Effect::RippleRandom:
         // TODO Needs implementation
         return false;
     }
     return d->hasFx(fxStr);
 }
 
-::openrazer::RazerEffect Led::getCurrentEffect()
+::openrazer::Effect Led::getCurrentEffect()
 {
     QVariant reply = d->ledIface()->property("CurrentEffect");
-    return handleDBusVariant<::openrazer::RazerEffect>(reply, d->ledIface()->lastError(), Q_FUNC_INFO);
+    return handleDBusVariant<::openrazer::Effect>(reply, d->ledIface()->lastError(), Q_FUNC_INFO);
 }
 
 QVector<::openrazer::RGB> Led::getCurrentColors()
@@ -92,10 +92,10 @@ ::openrazer::WaveDirection Led::getWaveDirection()
     return ::openrazer::WaveDirection::RIGHT_TO_LEFT; // TODO Needs implementation
 }
 
-::openrazer::RazerLedId Led::getLedId()
+::openrazer::LedId Led::getLedId()
 {
     QVariant reply = d->ledIface()->property("LedId");
-    return handleDBusVariant<::openrazer::RazerLedId>(reply, d->ledIface()->lastError(), Q_FUNC_INFO);
+    return handleDBusVariant<::openrazer::LedId>(reply, d->ledIface()->lastError(), Q_FUNC_INFO);
 }
 
 void Led::setOff()