PiPedal 1.2.33 initial commit

2024-08-08 12:53:02 -04:00
parent 0e378997a5
commit a3847c8184
255 changed files with 22008 additions and 1791 deletions
@@ -0,0 +1,92 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_f1_w1_wpa_supplicant1_Group_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_f1_w1_wpa_supplicant1_Group_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace fi {
+namespace w1 {
+namespace wpa_supplicant1 {
+
+class Group_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "fi.w1.wpa_supplicant1.Group";
+
+protected:
+    Group_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("PeerJoined").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerJoined(peer); });
+        proxy_.uponSignal("PeerDisconnected").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerDisconnected(peer); });
+    }
+
+    ~Group_proxy() = default;
+
+    virtual void onPeerJoined(const sdbus::ObjectPath& peer) = 0;
+    virtual void onPeerDisconnected(const sdbus::ObjectPath& peer) = 0;
+
+public:
+    std::vector<sdbus::ObjectPath> Members()
+    {
+        return proxy_.getProperty("Members").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Group()
+    {
+        return proxy_.getProperty("Group").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Role()
+    {
+        return proxy_.getProperty("Role").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> SSID()
+    {
+        return proxy_.getProperty("SSID").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> BSSID()
+    {
+        return proxy_.getProperty("BSSID").onInterface(INTERFACE_NAME);
+    }
+
+    uint16_t Frequency()
+    {
+        return proxy_.getProperty("Frequency").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Passphrase()
+    {
+        return proxy_.getProperty("Passphrase").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> PSK()
+    {
+        return proxy_.getProperty("PSK").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::vector<uint8_t>> WPSVendorExtensions()
+    {
+        return proxy_.getProperty("WPSVendorExtensions").onInterface(INTERFACE_NAME);
+    }
+
+    void WPSVendorExtensions(const std::vector<std::vector<uint8_t>>& value)
+    {
+        proxy_.setProperty("WPSVendorExtensions").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,120 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_f1_w1_wpa_supplicant1_Peer_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_f1_w1_wpa_supplicant1_Peer_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace fi {
+namespace w1 {
+namespace wpa_supplicant1 {
+
+class Peer_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "fi.w1.wpa_supplicant1.Peer";
+
+protected:
+    Peer_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("PropertiesChanged").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onPropertiesChanged(properties); });
+    }
+
+    ~Peer_proxy() = default;
+
+    virtual void onPropertiesChanged(const std::map<std::string, sdbus::Variant>& properties) = 0;
+
+public:
+    std::string DeviceName()
+    {
+        return proxy_.getProperty("DeviceName").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Manufacturer()
+    {
+        return proxy_.getProperty("Manufacturer").onInterface(INTERFACE_NAME);
+    }
+
+    std::string ModelName()
+    {
+        return proxy_.getProperty("ModelName").onInterface(INTERFACE_NAME);
+    }
+
+    std::string ModelNumber()
+    {
+        return proxy_.getProperty("ModelNumber").onInterface(INTERFACE_NAME);
+    }
+
+    std::string SerialNumber()
+    {
+        return proxy_.getProperty("SerialNumber").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> PrimaryDeviceType()
+    {
+        return proxy_.getProperty("PrimaryDeviceType").onInterface(INTERFACE_NAME);
+    }
+
+    uint16_t config_method()
+    {
+        return proxy_.getProperty("config_method").onInterface(INTERFACE_NAME);
+    }
+
+    int32_t level()
+    {
+        return proxy_.getProperty("level").onInterface(INTERFACE_NAME);
+    }
+
+    uint8_t devicecapability()
+    {
+        return proxy_.getProperty("devicecapability").onInterface(INTERFACE_NAME);
+    }
+
+    uint8_t groupcapability()
+    {
+        return proxy_.getProperty("groupcapability").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::vector<uint8_t>> SecondaryDeviceTypes()
+    {
+        return proxy_.getProperty("SecondaryDeviceTypes").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::vector<uint8_t>> VendorExtension()
+    {
+        return proxy_.getProperty("VendorExtension").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> IEs()
+    {
+        return proxy_.getProperty("IEs").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> DeviceAddress()
+    {
+        return proxy_.getProperty("DeviceAddress").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> Groups()
+    {
+        return proxy_.getProperty("Groups").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> VSIE()
+    {
+        return proxy_.getProperty("VSIE").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,123 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_fi_w1_wpa_supplicant1_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_fi_w1_wpa_supplicant1_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace fi {
+namespace w1 {
+
+class wpa_supplicant1_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "fi.w1.wpa_supplicant1";
+
+protected:
+    wpa_supplicant1_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("InterfaceAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties){ this->onInterfaceAdded(path, properties); });
+        proxy_.uponSignal("InterfaceRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onInterfaceRemoved(path); });
+        proxy_.uponSignal("PropertiesChanged").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onPropertiesChanged(properties); });
+    }
+
+    ~wpa_supplicant1_proxy() = default;
+
+    virtual void onInterfaceAdded(const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties) = 0;
+    virtual void onInterfaceRemoved(const sdbus::ObjectPath& path) = 0;
+    virtual void onPropertiesChanged(const std::map<std::string, sdbus::Variant>& properties) = 0;
+
+public:
+    sdbus::ObjectPath CreateInterface(const std::map<std::string, sdbus::Variant>& args)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("CreateInterface").onInterface(INTERFACE_NAME).withArguments(args).storeResultsTo(result);
+        return result;
+    }
+
+    void RemoveInterface(const sdbus::ObjectPath& path)
+    {
+        proxy_.callMethod("RemoveInterface").onInterface(INTERFACE_NAME).withArguments(path);
+    }
+
+    sdbus::ObjectPath GetInterface(const std::string& ifname)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("GetInterface").onInterface(INTERFACE_NAME).withArguments(ifname).storeResultsTo(result);
+        return result;
+    }
+
+    void ExpectDisconnect()
+    {
+        proxy_.callMethod("ExpectDisconnect").onInterface(INTERFACE_NAME);
+    }
+
+public:
+    std::string DebugLevel()
+    {
+        return proxy_.getProperty("DebugLevel").onInterface(INTERFACE_NAME);
+    }
+
+    void DebugLevel(const std::string& value)
+    {
+        proxy_.setProperty("DebugLevel").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool DebugTimestamp()
+    {
+        return proxy_.getProperty("DebugTimestamp").onInterface(INTERFACE_NAME);
+    }
+
+    void DebugTimestamp(const bool& value)
+    {
+        proxy_.setProperty("DebugTimestamp").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool DebugShowKeys()
+    {
+        return proxy_.getProperty("DebugShowKeys").onInterface(INTERFACE_NAME);
+    }
+
+    void DebugShowKeys(const bool& value)
+    {
+        proxy_.setProperty("DebugShowKeys").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    std::vector<sdbus::ObjectPath> Interfaces()
+    {
+        return proxy_.getProperty("Interfaces").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> EapMethods()
+    {
+        return proxy_.getProperty("EapMethods").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> Capabilities()
+    {
+        return proxy_.getProperty("Capabilities").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> WFDIEs()
+    {
+        return proxy_.getProperty("WFDIEs").onInterface(INTERFACE_NAME);
+    }
+
+    void WFDIEs(const std::vector<uint8_t>& value)
+    {
+        proxy_.setProperty("WFDIEs").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}} // namespaces
+
+#endif
@@ -0,0 +1,56 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_DBus_Properties_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_DBus_Properties_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace DBus {
+
+class Properties_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.Properties";
+
+protected:
+    Properties_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Properties_proxy() = default;
+
+public:
+    sdbus::Variant Get(const std::string& interface, const std::string& propname)
+    {
+        sdbus::Variant result;
+        proxy_.callMethod("Get").onInterface(INTERFACE_NAME).withArguments(interface, propname).storeResultsTo(result);
+        return result;
+    }
+
+    std::map<std::string, sdbus::Variant> GetAll(const std::string& interface)
+    {
+        std::map<std::string, sdbus::Variant> result;
+        proxy_.callMethod("GetAll").onInterface(INTERFACE_NAME).withArguments(interface).storeResultsTo(result);
+        return result;
+    }
+
+    void Set(const std::string& interface, const std::string& propname, const sdbus::Variant& value)
+    {
+        proxy_.callMethod("Set").onInterface(INTERFACE_NAME).withArguments(interface, propname, value);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,87 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_AccessPoint_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_AccessPoint_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class AccessPoint_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.AccessPoint";
+
+protected:
+    AccessPoint_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~AccessPoint_proxy() = default;
+
+public:
+    uint32_t Flags()
+    {
+        return proxy_.getProperty("Flags").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t WpaFlags()
+    {
+        return proxy_.getProperty("WpaFlags").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t RsnFlags()
+    {
+        return proxy_.getProperty("RsnFlags").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> Ssid()
+    {
+        return proxy_.getProperty("Ssid").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Frequency()
+    {
+        return proxy_.getProperty("Frequency").onInterface(INTERFACE_NAME);
+    }
+
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Mode()
+    {
+        return proxy_.getProperty("Mode").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t MaxBitrate()
+    {
+        return proxy_.getProperty("MaxBitrate").onInterface(INTERFACE_NAME);
+    }
+
+    uint8_t Strength()
+    {
+        return proxy_.getProperty("Strength").onInterface(INTERFACE_NAME);
+    }
+
+    int32_t LastSeen()
+    {
+        return proxy_.getProperty("LastSeen").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,52 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_AgentManager_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_AgentManager_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class AgentManager_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.AgentManager";
+
+protected:
+    AgentManager_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~AgentManager_proxy() = default;
+
+public:
+    void Register(const std::string& identifier)
+    {
+        proxy_.callMethod("Register").onInterface(INTERFACE_NAME).withArguments(identifier);
+    }
+
+    void RegisterWithCapabilities(const std::string& identifier, const uint32_t& capabilities)
+    {
+        proxy_.callMethod("RegisterWithCapabilities").onInterface(INTERFACE_NAME).withArguments(identifier, capabilities);
+    }
+
+    void Unregister()
+    {
+        proxy_.callMethod("Unregister").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,52 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Checkpoint_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Checkpoint_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class Checkpoint_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Checkpoint";
+
+protected:
+    Checkpoint_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Checkpoint_proxy() = default;
+
+public:
+    std::vector<sdbus::ObjectPath> Devices()
+    {
+        return proxy_.getProperty("Devices").onInterface(INTERFACE_NAME);
+    }
+
+    int64_t Created()
+    {
+        return proxy_.getProperty("Created").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t RollbackTimeout()
+    {
+        return proxy_.getProperty("RollbackTimeout").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,126 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Connection_Active_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Connection_Active_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Connection {
+
+class Active_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Connection.Active";
+
+protected:
+    Active_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state, const uint32_t& reason){ this->onStateChanged(state, reason); });
+    }
+
+    ~Active_proxy() = default;
+
+    virtual void onStateChanged(const uint32_t& state, const uint32_t& reason) = 0;
+
+public:
+    sdbus::ObjectPath Connection()
+    {
+        return proxy_.getProperty("Connection").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath SpecificObject()
+    {
+        return proxy_.getProperty("SpecificObject").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Id()
+    {
+        return proxy_.getProperty("Id").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Uuid()
+    {
+        return proxy_.getProperty("Uuid").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Type()
+    {
+        return proxy_.getProperty("Type").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> Devices()
+    {
+        return proxy_.getProperty("Devices").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t State()
+    {
+        return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t StateFlags()
+    {
+        return proxy_.getProperty("StateFlags").onInterface(INTERFACE_NAME);
+    }
+
+    bool Default()
+    {
+        return proxy_.getProperty("Default").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Ip4Config()
+    {
+        return proxy_.getProperty("Ip4Config").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Dhcp4Config()
+    {
+        return proxy_.getProperty("Dhcp4Config").onInterface(INTERFACE_NAME);
+    }
+
+    bool Default6()
+    {
+        return proxy_.getProperty("Default6").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Ip6Config()
+    {
+        return proxy_.getProperty("Ip6Config").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Dhcp6Config()
+    {
+        return proxy_.getProperty("Dhcp6Config").onInterface(INTERFACE_NAME);
+    }
+
+    bool Vpn()
+    {
+        return proxy_.getProperty("Vpn").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Controller()
+    {
+        return proxy_.getProperty("Controller").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Master()
+    {
+        return proxy_.getProperty("Master").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,42 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_DHCP4Config_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_DHCP4Config_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class DHCP4Config_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.DHCP4Config";
+
+protected:
+    DHCP4Config_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~DHCP4Config_proxy() = default;
+
+public:
+    std::map<std::string, sdbus::Variant> Options()
+    {
+        return proxy_.getProperty("Options").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,42 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_DHCP6Config_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_DHCP6Config_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class DHCP6Config_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.DHCP6Config";
+
+protected:
+    DHCP6Config_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~DHCP6Config_proxy() = default;
+
+public:
+    std::map<std::string, sdbus::Variant> Options()
+    {
+        return proxy_.getProperty("Options").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,53 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Bond_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Bond_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Bond_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Bond";
+
+protected:
+    Bond_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Bond_proxy() = default;
+
+public:
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    bool Carrier()
+    {
+        return proxy_.getProperty("Carrier").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> Slaves()
+    {
+        return proxy_.getProperty("Slaves").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,43 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Dummy_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Dummy_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Dummy_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Dummy";
+
+protected:
+    Dummy_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Dummy_proxy() = default;
+
+public:
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,48 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Generic_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Generic_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Generic_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Generic";
+
+protected:
+    Generic_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Generic_proxy() = default;
+
+public:
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    std::string TypeDescription()
+    {
+        return proxy_.getProperty("TypeDescription").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,37 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Loopback_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Loopback_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Loopback_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Loopback";
+
+protected:
+    Loopback_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Loopback_proxy() = default;
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,63 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Modem_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Modem_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Modem_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Modem";
+
+protected:
+    Modem_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Modem_proxy() = default;
+
+public:
+    uint32_t ModemCapabilities()
+    {
+        return proxy_.getProperty("ModemCapabilities").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t CurrentCapabilities()
+    {
+        return proxy_.getProperty("CurrentCapabilities").onInterface(INTERFACE_NAME);
+    }
+
+    std::string DeviceId()
+    {
+        return proxy_.getProperty("DeviceId").onInterface(INTERFACE_NAME);
+    }
+
+    std::string OperatorCode()
+    {
+        return proxy_.getProperty("OperatorCode").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Apn()
+    {
+        return proxy_.getProperty("Apn").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,58 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Statistics_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Statistics_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Statistics_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Statistics";
+
+protected:
+    Statistics_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Statistics_proxy() = default;
+
+public:
+    uint32_t RefreshRateMs()
+    {
+        return proxy_.getProperty("RefreshRateMs").onInterface(INTERFACE_NAME);
+    }
+
+    void RefreshRateMs(const uint32_t& value)
+    {
+        proxy_.setProperty("RefreshRateMs").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    uint64_t TxBytes()
+    {
+        return proxy_.getProperty("TxBytes").onInterface(INTERFACE_NAME);
+    }
+
+    uint64_t RxBytes()
+    {
+        return proxy_.getProperty("RxBytes").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,64 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_WifiP2P_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_WifiP2P_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class WifiP2P_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.WifiP2P";
+
+protected:
+    WifiP2P_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("PeerAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerAdded(peer); });
+        proxy_.uponSignal("PeerRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer){ this->onPeerRemoved(peer); });
+    }
+
+    ~WifiP2P_proxy() = default;
+
+    virtual void onPeerAdded(const sdbus::ObjectPath& peer) = 0;
+    virtual void onPeerRemoved(const sdbus::ObjectPath& peer) = 0;
+
+public:
+    void StartFind(const std::map<std::string, sdbus::Variant>& options)
+    {
+        proxy_.callMethod("StartFind").onInterface(INTERFACE_NAME).withArguments(options);
+    }
+
+    void StopFind()
+    {
+        proxy_.callMethod("StopFind").onInterface(INTERFACE_NAME);
+    }
+
+public:
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> Peers()
+    {
+        return proxy_.getProperty("Peers").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,53 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_WireGuard_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_WireGuard_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class WireGuard_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.WireGuard";
+
+protected:
+    WireGuard_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~WireGuard_proxy() = default;
+
+public:
+    std::vector<uint8_t> PublicKey()
+    {
+        return proxy_.getProperty("PublicKey").onInterface(INTERFACE_NAME);
+    }
+
+    uint16_t ListenPort()
+    {
+        return proxy_.getProperty("ListenPort").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t FwMark()
+    {
+        return proxy_.getProperty("FwMark").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,63 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Wired_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Wired_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Wired_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Wired";
+
+protected:
+    Wired_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Wired_proxy() = default;
+
+public:
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    std::string PermHwAddress()
+    {
+        return proxy_.getProperty("PermHwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Speed()
+    {
+        return proxy_.getProperty("Speed").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> S390Subchannels()
+    {
+        return proxy_.getProperty("S390Subchannels").onInterface(INTERFACE_NAME);
+    }
+
+    bool Carrier()
+    {
+        return proxy_.getProperty("Carrier").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,103 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Wireless_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Wireless_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Wireless_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Wireless";
+
+protected:
+    Wireless_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("AccessPointAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& access_point){ this->onAccessPointAdded(access_point); });
+        proxy_.uponSignal("AccessPointRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& access_point){ this->onAccessPointRemoved(access_point); });
+    }
+
+    ~Wireless_proxy() = default;
+
+    virtual void onAccessPointAdded(const sdbus::ObjectPath& access_point) = 0;
+    virtual void onAccessPointRemoved(const sdbus::ObjectPath& access_point) = 0;
+
+public:
+    std::vector<sdbus::ObjectPath> GetAccessPoints()
+    {
+        std::vector<sdbus::ObjectPath> result;
+        proxy_.callMethod("GetAccessPoints").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    std::vector<sdbus::ObjectPath> GetAllAccessPoints()
+    {
+        std::vector<sdbus::ObjectPath> result;
+        proxy_.callMethod("GetAllAccessPoints").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    void RequestScan(const std::map<std::string, sdbus::Variant>& options)
+    {
+        proxy_.callMethod("RequestScan").onInterface(INTERFACE_NAME).withArguments(options);
+    }
+
+public:
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    std::string PermHwAddress()
+    {
+        return proxy_.getProperty("PermHwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Mode()
+    {
+        return proxy_.getProperty("Mode").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Bitrate()
+    {
+        return proxy_.getProperty("Bitrate").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> AccessPoints()
+    {
+        return proxy_.getProperty("AccessPoints").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath ActiveAccessPoint()
+    {
+        return proxy_.getProperty("ActiveAccessPoint").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t WirelessCapabilities()
+    {
+        return proxy_.getProperty("WirelessCapabilities").onInterface(INTERFACE_NAME);
+    }
+
+    int64_t LastScan()
+    {
+        return proxy_.getProperty("LastScan").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,43 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Wpan_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_Wpan_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Device {
+
+class Wpan_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device.Wpan";
+
+protected:
+    Wpan_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Wpan_proxy() = default;
+
+public:
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,233 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Device_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class Device_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Device";
+
+protected:
+    Device_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& new_state, const uint32_t& old_state, const uint32_t& reason){ this->onStateChanged(new_state, old_state, reason); });
+    }
+
+    ~Device_proxy() = default;
+
+    virtual void onStateChanged(const uint32_t& new_state, const uint32_t& old_state, const uint32_t& reason) = 0;
+
+public:
+    void Reapply(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const uint64_t& version_id, const uint32_t& flags)
+    {
+        proxy_.callMethod("Reapply").onInterface(INTERFACE_NAME).withArguments(connection, version_id, flags);
+    }
+
+    std::tuple<std::map<std::string, std::map<std::string, sdbus::Variant>>, uint64_t> GetAppliedConnection(const uint32_t& flags)
+    {
+        std::tuple<std::map<std::string, std::map<std::string, sdbus::Variant>>, uint64_t> result;
+        proxy_.callMethod("GetAppliedConnection").onInterface(INTERFACE_NAME).withArguments(flags).storeResultsTo(result);
+        return result;
+    }
+
+    void Disconnect()
+    {
+        proxy_.callMethod("Disconnect").onInterface(INTERFACE_NAME);
+    }
+
+    void Delete()
+    {
+        proxy_.callMethod("Delete").onInterface(INTERFACE_NAME);
+    }
+
+public:
+    std::string Udi()
+    {
+        return proxy_.getProperty("Udi").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Path()
+    {
+        return proxy_.getProperty("Path").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Interface()
+    {
+        return proxy_.getProperty("Interface").onInterface(INTERFACE_NAME);
+    }
+
+    std::string IpInterface()
+    {
+        return proxy_.getProperty("IpInterface").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Driver()
+    {
+        return proxy_.getProperty("Driver").onInterface(INTERFACE_NAME);
+    }
+
+    std::string DriverVersion()
+    {
+        return proxy_.getProperty("DriverVersion").onInterface(INTERFACE_NAME);
+    }
+
+    std::string FirmwareVersion()
+    {
+        return proxy_.getProperty("FirmwareVersion").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Capabilities()
+    {
+        return proxy_.getProperty("Capabilities").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Ip4Address()
+    {
+        return proxy_.getProperty("Ip4Address").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t State()
+    {
+        return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::Struct<uint32_t, uint32_t> StateReason()
+    {
+        return proxy_.getProperty("StateReason").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath ActiveConnection()
+    {
+        return proxy_.getProperty("ActiveConnection").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Ip4Config()
+    {
+        return proxy_.getProperty("Ip4Config").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Dhcp4Config()
+    {
+        return proxy_.getProperty("Dhcp4Config").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Ip6Config()
+    {
+        return proxy_.getProperty("Ip6Config").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath Dhcp6Config()
+    {
+        return proxy_.getProperty("Dhcp6Config").onInterface(INTERFACE_NAME);
+    }
+
+    bool Managed()
+    {
+        return proxy_.getProperty("Managed").onInterface(INTERFACE_NAME);
+    }
+
+    void Managed(const bool& value)
+    {
+        proxy_.setProperty("Managed").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool Autoconnect()
+    {
+        return proxy_.getProperty("Autoconnect").onInterface(INTERFACE_NAME);
+    }
+
+    void Autoconnect(const bool& value)
+    {
+        proxy_.setProperty("Autoconnect").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool FirmwareMissing()
+    {
+        return proxy_.getProperty("FirmwareMissing").onInterface(INTERFACE_NAME);
+    }
+
+    bool NmPluginMissing()
+    {
+        return proxy_.getProperty("NmPluginMissing").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t DeviceType()
+    {
+        return proxy_.getProperty("DeviceType").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> AvailableConnections()
+    {
+        return proxy_.getProperty("AvailableConnections").onInterface(INTERFACE_NAME);
+    }
+
+    std::string PhysicalPortId()
+    {
+        return proxy_.getProperty("PhysicalPortId").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Mtu()
+    {
+        return proxy_.getProperty("Mtu").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Metered()
+    {
+        return proxy_.getProperty("Metered").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::map<std::string, sdbus::Variant>> LldpNeighbors()
+    {
+        return proxy_.getProperty("LldpNeighbors").onInterface(INTERFACE_NAME);
+    }
+
+    bool Real()
+    {
+        return proxy_.getProperty("Real").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Ip4Connectivity()
+    {
+        return proxy_.getProperty("Ip4Connectivity").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Ip6Connectivity()
+    {
+        return proxy_.getProperty("Ip6Connectivity").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t InterfaceFlags()
+    {
+        return proxy_.getProperty("InterfaceFlags").onInterface(INTERFACE_NAME);
+    }
+
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> Ports()
+    {
+        return proxy_.getProperty("Ports").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,52 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_DnsManager_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_DnsManager_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class DnsManager_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.DnsManager";
+
+protected:
+    DnsManager_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~DnsManager_proxy() = default;
+
+public:
+    std::string Mode()
+    {
+        return proxy_.getProperty("Mode").onInterface(INTERFACE_NAME);
+    }
+
+    std::string RcManager()
+    {
+        return proxy_.getProperty("RcManager").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::map<std::string, sdbus::Variant>> Configuration()
+    {
+        return proxy_.getProperty("Configuration").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,102 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_IP4Config_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_IP4Config_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class IP4Config_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.IP4Config";
+
+protected:
+    IP4Config_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~IP4Config_proxy() = default;
+
+public:
+    std::vector<std::vector<uint32_t>> Addresses()
+    {
+        return proxy_.getProperty("Addresses").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::map<std::string, sdbus::Variant>> AddressData()
+    {
+        return proxy_.getProperty("AddressData").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Gateway()
+    {
+        return proxy_.getProperty("Gateway").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::vector<uint32_t>> Routes()
+    {
+        return proxy_.getProperty("Routes").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::map<std::string, sdbus::Variant>> RouteData()
+    {
+        return proxy_.getProperty("RouteData").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint32_t> Nameservers()
+    {
+        return proxy_.getProperty("Nameservers").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::map<std::string, sdbus::Variant>> NameserverData()
+    {
+        return proxy_.getProperty("NameserverData").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> Domains()
+    {
+        return proxy_.getProperty("Domains").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> Searches()
+    {
+        return proxy_.getProperty("Searches").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> DnsOptions()
+    {
+        return proxy_.getProperty("DnsOptions").onInterface(INTERFACE_NAME);
+    }
+
+    int32_t DnsPriority()
+    {
+        return proxy_.getProperty("DnsPriority").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint32_t> WinsServers()
+    {
+        return proxy_.getProperty("WinsServers").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> WinsServerData()
+    {
+        return proxy_.getProperty("WinsServerData").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,87 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_IP6Config_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_IP6Config_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class IP6Config_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.IP6Config";
+
+protected:
+    IP6Config_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~IP6Config_proxy() = default;
+
+public:
+    std::vector<sdbus::Struct<std::vector<uint8_t>, uint32_t, std::vector<uint8_t>>> Addresses()
+    {
+        return proxy_.getProperty("Addresses").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::map<std::string, sdbus::Variant>> AddressData()
+    {
+        return proxy_.getProperty("AddressData").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Gateway()
+    {
+        return proxy_.getProperty("Gateway").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::Struct<std::vector<uint8_t>, uint32_t, std::vector<uint8_t>, uint32_t>> Routes()
+    {
+        return proxy_.getProperty("Routes").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::map<std::string, sdbus::Variant>> RouteData()
+    {
+        return proxy_.getProperty("RouteData").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::vector<uint8_t>> Nameservers()
+    {
+        return proxy_.getProperty("Nameservers").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> Domains()
+    {
+        return proxy_.getProperty("Domains").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> Searches()
+    {
+        return proxy_.getProperty("Searches").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<std::string> DnsOptions()
+    {
+        return proxy_.getProperty("DnsOptions").onInterface(INTERFACE_NAME);
+    }
+
+    int32_t DnsPriority()
+    {
+        return proxy_.getProperty("DnsPriority").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,64 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_PPP_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_PPP_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class PPP_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.PPP";
+
+protected:
+    PPP_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~PPP_proxy() = default;
+
+public:
+    std::tuple<std::string, std::string> NeedSecrets()
+    {
+        std::tuple<std::string, std::string> result;
+        proxy_.callMethod("NeedSecrets").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    void SetIp4Config(const std::map<std::string, sdbus::Variant>& config)
+    {
+        proxy_.callMethod("SetIp4Config").onInterface(INTERFACE_NAME).withArguments(config);
+    }
+
+    void SetIp6Config(const std::map<std::string, sdbus::Variant>& config)
+    {
+        proxy_.callMethod("SetIp6Config").onInterface(INTERFACE_NAME).withArguments(config);
+    }
+
+    void SetState(const uint32_t& state)
+    {
+        proxy_.callMethod("SetState").onInterface(INTERFACE_NAME).withArguments(state);
+    }
+
+    void SetIfindex(const int32_t& ifindex)
+    {
+        proxy_.callMethod("SetIfindex").onInterface(INTERFACE_NAME).withArguments(ifindex);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,59 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_SecretAgent_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_SecretAgent_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class SecretAgent_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.SecretAgent";
+
+protected:
+    SecretAgent_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~SecretAgent_proxy() = default;
+
+public:
+    std::map<std::string, std::map<std::string, sdbus::Variant>> GetSecrets(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const sdbus::ObjectPath& connection_path, const std::string& setting_name, const std::vector<std::string>& hints, const uint32_t& flags)
+    {
+        std::map<std::string, std::map<std::string, sdbus::Variant>> result;
+        proxy_.callMethod("GetSecrets").onInterface(INTERFACE_NAME).withArguments(connection, connection_path, setting_name, hints, flags).storeResultsTo(result);
+        return result;
+    }
+
+    void CancelGetSecrets(const sdbus::ObjectPath& connection_path, const std::string& setting_name)
+    {
+        proxy_.callMethod("CancelGetSecrets").onInterface(INTERFACE_NAME).withArguments(connection_path, setting_name);
+    }
+
+    void SaveSecrets(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const sdbus::ObjectPath& connection_path)
+    {
+        proxy_.callMethod("SaveSecrets").onInterface(INTERFACE_NAME).withArguments(connection, connection_path);
+    }
+
+    void DeleteSecrets(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const sdbus::ObjectPath& connection_path)
+    {
+        proxy_.callMethod("DeleteSecrets").onInterface(INTERFACE_NAME).withArguments(connection, connection_path);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,105 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Settings_Connection_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Settings_Connection_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace Settings {
+
+class Connection_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Settings.Connection";
+
+protected:
+    Connection_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("Updated").onInterface(INTERFACE_NAME).call([this](){ this->onUpdated(); });
+        proxy_.uponSignal("Removed").onInterface(INTERFACE_NAME).call([this](){ this->onRemoved(); });
+    }
+
+    ~Connection_proxy() = default;
+
+    virtual void onUpdated() = 0;
+    virtual void onRemoved() = 0;
+
+public:
+    void Update(const std::map<std::string, std::map<std::string, sdbus::Variant>>& properties)
+    {
+        proxy_.callMethod("Update").onInterface(INTERFACE_NAME).withArguments(properties);
+    }
+
+    void UpdateUnsaved(const std::map<std::string, std::map<std::string, sdbus::Variant>>& properties)
+    {
+        proxy_.callMethod("UpdateUnsaved").onInterface(INTERFACE_NAME).withArguments(properties);
+    }
+
+    void Delete()
+    {
+        proxy_.callMethod("Delete").onInterface(INTERFACE_NAME);
+    }
+
+    std::map<std::string, std::map<std::string, sdbus::Variant>> GetSettings()
+    {
+        std::map<std::string, std::map<std::string, sdbus::Variant>> result;
+        proxy_.callMethod("GetSettings").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    std::map<std::string, std::map<std::string, sdbus::Variant>> GetSecrets(const std::string& setting_name)
+    {
+        std::map<std::string, std::map<std::string, sdbus::Variant>> result;
+        proxy_.callMethod("GetSecrets").onInterface(INTERFACE_NAME).withArguments(setting_name).storeResultsTo(result);
+        return result;
+    }
+
+    void ClearSecrets()
+    {
+        proxy_.callMethod("ClearSecrets").onInterface(INTERFACE_NAME);
+    }
+
+    void Save()
+    {
+        proxy_.callMethod("Save").onInterface(INTERFACE_NAME);
+    }
+
+    std::map<std::string, sdbus::Variant> Update2(const std::map<std::string, std::map<std::string, sdbus::Variant>>& settings, const uint32_t& flags, const std::map<std::string, sdbus::Variant>& args)
+    {
+        std::map<std::string, sdbus::Variant> result;
+        proxy_.callMethod("Update2").onInterface(INTERFACE_NAME).withArguments(settings, flags, args).storeResultsTo(result);
+        return result;
+    }
+
+public:
+    bool Unsaved()
+    {
+        return proxy_.getProperty("Unsaved").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Flags()
+    {
+        return proxy_.getProperty("Flags").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Filename()
+    {
+        return proxy_.getProperty("Filename").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,112 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Settings_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_Settings_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class Settings_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.Settings";
+
+protected:
+    Settings_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("NewConnection").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& connection){ this->onNewConnection(connection); });
+        proxy_.uponSignal("ConnectionRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& connection){ this->onConnectionRemoved(connection); });
+    }
+
+    ~Settings_proxy() = default;
+
+    virtual void onNewConnection(const sdbus::ObjectPath& connection) = 0;
+    virtual void onConnectionRemoved(const sdbus::ObjectPath& connection) = 0;
+
+public:
+    std::vector<sdbus::ObjectPath> ListConnections()
+    {
+        std::vector<sdbus::ObjectPath> result;
+        proxy_.callMethod("ListConnections").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath GetConnectionByUuid(const std::string& uuid)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("GetConnectionByUuid").onInterface(INTERFACE_NAME).withArguments(uuid).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath AddConnection(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("AddConnection").onInterface(INTERFACE_NAME).withArguments(connection).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath AddConnectionUnsaved(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("AddConnectionUnsaved").onInterface(INTERFACE_NAME).withArguments(connection).storeResultsTo(result);
+        return result;
+    }
+
+    std::tuple<sdbus::ObjectPath, std::map<std::string, sdbus::Variant>> AddConnection2(const std::map<std::string, std::map<std::string, sdbus::Variant>>& settings, const uint32_t& flags, const std::map<std::string, sdbus::Variant>& args)
+    {
+        std::tuple<sdbus::ObjectPath, std::map<std::string, sdbus::Variant>> result;
+        proxy_.callMethod("AddConnection2").onInterface(INTERFACE_NAME).withArguments(settings, flags, args).storeResultsTo(result);
+        return result;
+    }
+
+    std::tuple<bool, std::vector<std::string>> LoadConnections(const std::vector<std::string>& filenames)
+    {
+        std::tuple<bool, std::vector<std::string>> result;
+        proxy_.callMethod("LoadConnections").onInterface(INTERFACE_NAME).withArguments(filenames).storeResultsTo(result);
+        return result;
+    }
+
+    bool ReloadConnections()
+    {
+        bool result;
+        proxy_.callMethod("ReloadConnections").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    void SaveHostname(const std::string& hostname)
+    {
+        proxy_.callMethod("SaveHostname").onInterface(INTERFACE_NAME).withArguments(hostname);
+    }
+
+public:
+    std::vector<sdbus::ObjectPath> Connections()
+    {
+        return proxy_.getProperty("Connections").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Hostname()
+    {
+        return proxy_.getProperty("Hostname").onInterface(INTERFACE_NAME);
+    }
+
+    bool CanModify()
+    {
+        return proxy_.getProperty("CanModify").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,51 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_VPN_Connection_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_VPN_Connection_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace VPN {
+
+class Connection_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.VPN.Connection";
+
+protected:
+    Connection_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("VpnStateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state, const uint32_t& reason){ this->onVpnStateChanged(state, reason); });
+    }
+
+    ~Connection_proxy() = default;
+
+    virtual void onVpnStateChanged(const uint32_t& state, const uint32_t& reason) = 0;
+
+public:
+    uint32_t VpnState()
+    {
+        return proxy_.getProperty("VpnState").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Banner()
+    {
+        return proxy_.getProperty("Banner").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,106 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_VPN_Plugin_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_VPN_Plugin_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace VPN {
+
+class Plugin_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.VPN.Plugin";
+
+protected:
+    Plugin_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state){ this->onStateChanged(state); });
+        proxy_.uponSignal("SecretsRequired").onInterface(INTERFACE_NAME).call([this](const std::string& message, const std::vector<std::string>& secrets){ this->onSecretsRequired(message, secrets); });
+        proxy_.uponSignal("Config").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& config){ this->onConfig(config); });
+        proxy_.uponSignal("Ip4Config").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& ip4config){ this->onIp4Config(ip4config); });
+        proxy_.uponSignal("Ip6Config").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& ip6config){ this->onIp6Config(ip6config); });
+        proxy_.uponSignal("LoginBanner").onInterface(INTERFACE_NAME).call([this](const std::string& banner){ this->onLoginBanner(banner); });
+        proxy_.uponSignal("Failure").onInterface(INTERFACE_NAME).call([this](const uint32_t& reason){ this->onFailure(reason); });
+    }
+
+    ~Plugin_proxy() = default;
+
+    virtual void onStateChanged(const uint32_t& state) = 0;
+    virtual void onSecretsRequired(const std::string& message, const std::vector<std::string>& secrets) = 0;
+    virtual void onConfig(const std::map<std::string, sdbus::Variant>& config) = 0;
+    virtual void onIp4Config(const std::map<std::string, sdbus::Variant>& ip4config) = 0;
+    virtual void onIp6Config(const std::map<std::string, sdbus::Variant>& ip6config) = 0;
+    virtual void onLoginBanner(const std::string& banner) = 0;
+    virtual void onFailure(const uint32_t& reason) = 0;
+
+public:
+    void Connect(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection)
+    {
+        proxy_.callMethod("Connect").onInterface(INTERFACE_NAME).withArguments(connection);
+    }
+
+    void ConnectInteractive(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const std::map<std::string, sdbus::Variant>& details)
+    {
+        proxy_.callMethod("ConnectInteractive").onInterface(INTERFACE_NAME).withArguments(connection, details);
+    }
+
+    std::string NeedSecrets(const std::map<std::string, std::map<std::string, sdbus::Variant>>& settings)
+    {
+        std::string result;
+        proxy_.callMethod("NeedSecrets").onInterface(INTERFACE_NAME).withArguments(settings).storeResultsTo(result);
+        return result;
+    }
+
+    void Disconnect()
+    {
+        proxy_.callMethod("Disconnect").onInterface(INTERFACE_NAME);
+    }
+
+    void SetConfig(const std::map<std::string, sdbus::Variant>& config)
+    {
+        proxy_.callMethod("SetConfig").onInterface(INTERFACE_NAME).withArguments(config);
+    }
+
+    void SetIp4Config(const std::map<std::string, sdbus::Variant>& config)
+    {
+        proxy_.callMethod("SetIp4Config").onInterface(INTERFACE_NAME).withArguments(config);
+    }
+
+    void SetIp6Config(const std::map<std::string, sdbus::Variant>& config)
+    {
+        proxy_.callMethod("SetIp6Config").onInterface(INTERFACE_NAME).withArguments(config);
+    }
+
+    void SetFailure(const std::string& reason)
+    {
+        proxy_.callMethod("SetFailure").onInterface(INTERFACE_NAME).withArguments(reason);
+    }
+
+    void NewSecrets(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection)
+    {
+        proxy_.callMethod("NewSecrets").onInterface(INTERFACE_NAME).withArguments(connection);
+    }
+
+public:
+    uint32_t State()
+    {
+        return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,53 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_WiMax_Nsp_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_WiMax_Nsp_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+namespace WiMax {
+
+class Nsp_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.WiMax.Nsp";
+
+protected:
+    Nsp_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Nsp_proxy() = default;
+
+public:
+    std::string Name()
+    {
+        return proxy_.getProperty("Name").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t SignalQuality()
+    {
+        return proxy_.getProperty("SignalQuality").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t NetworkType()
+    {
+        return proxy_.getProperty("NetworkType").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+#endif
@@ -0,0 +1,87 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_WifiP2PPeer_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_WifiP2PPeer_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+namespace NetworkManager {
+
+class WifiP2PPeer_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager.WifiP2PPeer";
+
+protected:
+    WifiP2PPeer_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~WifiP2PPeer_proxy() = default;
+
+public:
+    std::string Name()
+    {
+        return proxy_.getProperty("Name").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Flags()
+    {
+        return proxy_.getProperty("Flags").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Manufacturer()
+    {
+        return proxy_.getProperty("Manufacturer").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Model()
+    {
+        return proxy_.getProperty("Model").onInterface(INTERFACE_NAME);
+    }
+
+    std::string ModelNumber()
+    {
+        return proxy_.getProperty("ModelNumber").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Serial()
+    {
+        return proxy_.getProperty("Serial").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint8_t> WfdIEs()
+    {
+        return proxy_.getProperty("WfdIEs").onInterface(INTERFACE_NAME);
+    }
+
+    std::string HwAddress()
+    {
+        return proxy_.getProperty("HwAddress").onInterface(INTERFACE_NAME);
+    }
+
+    uint8_t Strength()
+    {
+        return proxy_.getProperty("Strength").onInterface(INTERFACE_NAME);
+    }
+
+    int32_t LastSeen()
+    {
+        return proxy_.getProperty("LastSeen").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif
@@ -0,0 +1,320 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_hpp__proxy__H__
+#define __sdbuscpp__dbus_hpp_org_freedesktop_NetworkManager_hpp__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace freedesktop {
+
+class NetworkManager_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.freedesktop.NetworkManager";
+
+protected:
+    NetworkManager_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("CheckPermissions").onInterface(INTERFACE_NAME).call([this](){ this->onCheckPermissions(); });
+        proxy_.uponSignal("StateChanged").onInterface(INTERFACE_NAME).call([this](const uint32_t& state){ this->onStateChanged(state); });
+        proxy_.uponSignal("DeviceAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& device_path){ this->onDeviceAdded(device_path); });
+        proxy_.uponSignal("DeviceRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& device_path){ this->onDeviceRemoved(device_path); });
+    }
+
+    ~NetworkManager_proxy() = default;
+
+    virtual void onCheckPermissions() = 0;
+    virtual void onStateChanged(const uint32_t& state) = 0;
+    virtual void onDeviceAdded(const sdbus::ObjectPath& device_path) = 0;
+    virtual void onDeviceRemoved(const sdbus::ObjectPath& device_path) = 0;
+
+public:
+    void Reload(const uint32_t& flags)
+    {
+        proxy_.callMethod("Reload").onInterface(INTERFACE_NAME).withArguments(flags);
+    }
+
+    std::vector<sdbus::ObjectPath> GetDevices()
+    {
+        std::vector<sdbus::ObjectPath> result;
+        proxy_.callMethod("GetDevices").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    std::vector<sdbus::ObjectPath> GetAllDevices()
+    {
+        std::vector<sdbus::ObjectPath> result;
+        proxy_.callMethod("GetAllDevices").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath GetDeviceByIpIface(const std::string& iface)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("GetDeviceByIpIface").onInterface(INTERFACE_NAME).withArguments(iface).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath ActivateConnection(const sdbus::ObjectPath& connection, const sdbus::ObjectPath& device, const sdbus::ObjectPath& specific_object)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("ActivateConnection").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object).storeResultsTo(result);
+        return result;
+    }
+
+    std::tuple<sdbus::ObjectPath, sdbus::ObjectPath> AddAndActivateConnection(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const sdbus::ObjectPath& device, const sdbus::ObjectPath& specific_object)
+    {
+        std::tuple<sdbus::ObjectPath, sdbus::ObjectPath> result;
+        proxy_.callMethod("AddAndActivateConnection").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object).storeResultsTo(result);
+        return result;
+    }
+
+    std::tuple<sdbus::ObjectPath, sdbus::ObjectPath, std::map<std::string, sdbus::Variant>> AddAndActivateConnection2(const std::map<std::string, std::map<std::string, sdbus::Variant>>& connection, const sdbus::ObjectPath& device, const sdbus::ObjectPath& specific_object, const std::map<std::string, sdbus::Variant>& options)
+    {
+        std::tuple<sdbus::ObjectPath, sdbus::ObjectPath, std::map<std::string, sdbus::Variant>> result;
+        proxy_.callMethod("AddAndActivateConnection2").onInterface(INTERFACE_NAME).withArguments(connection, device, specific_object, options).storeResultsTo(result);
+        return result;
+    }
+
+    void DeactivateConnection(const sdbus::ObjectPath& active_connection)
+    {
+        proxy_.callMethod("DeactivateConnection").onInterface(INTERFACE_NAME).withArguments(active_connection);
+    }
+
+    void Sleep(const bool& sleep)
+    {
+        proxy_.callMethod("Sleep").onInterface(INTERFACE_NAME).withArguments(sleep);
+    }
+
+    void Enable(const bool& enable)
+    {
+        proxy_.callMethod("Enable").onInterface(INTERFACE_NAME).withArguments(enable);
+    }
+
+    std::map<std::string, std::string> GetPermissions()
+    {
+        std::map<std::string, std::string> result;
+        proxy_.callMethod("GetPermissions").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    void SetLogging(const std::string& level, const std::string& domains)
+    {
+        proxy_.callMethod("SetLogging").onInterface(INTERFACE_NAME).withArguments(level, domains);
+    }
+
+    std::tuple<std::string, std::string> GetLogging()
+    {
+        std::tuple<std::string, std::string> result;
+        proxy_.callMethod("GetLogging").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t CheckConnectivity()
+    {
+        uint32_t result;
+        proxy_.callMethod("CheckConnectivity").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t state()
+    {
+        uint32_t result;
+        proxy_.callMethod("state").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath CheckpointCreate(const std::vector<sdbus::ObjectPath>& devices, const uint32_t& rollback_timeout, const uint32_t& flags)
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("CheckpointCreate").onInterface(INTERFACE_NAME).withArguments(devices, rollback_timeout, flags).storeResultsTo(result);
+        return result;
+    }
+
+    void CheckpointDestroy(const sdbus::ObjectPath& checkpoint)
+    {
+        proxy_.callMethod("CheckpointDestroy").onInterface(INTERFACE_NAME).withArguments(checkpoint);
+    }
+
+    std::map<std::string, uint32_t> CheckpointRollback(const sdbus::ObjectPath& checkpoint)
+    {
+        std::map<std::string, uint32_t> result;
+        proxy_.callMethod("CheckpointRollback").onInterface(INTERFACE_NAME).withArguments(checkpoint).storeResultsTo(result);
+        return result;
+    }
+
+    void CheckpointAdjustRollbackTimeout(const sdbus::ObjectPath& checkpoint, const uint32_t& add_timeout)
+    {
+        proxy_.callMethod("CheckpointAdjustRollbackTimeout").onInterface(INTERFACE_NAME).withArguments(checkpoint, add_timeout);
+    }
+
+public:
+    std::vector<sdbus::ObjectPath> Devices()
+    {
+        return proxy_.getProperty("Devices").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> AllDevices()
+    {
+        return proxy_.getProperty("AllDevices").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> Checkpoints()
+    {
+        return proxy_.getProperty("Checkpoints").onInterface(INTERFACE_NAME);
+    }
+
+    bool NetworkingEnabled()
+    {
+        return proxy_.getProperty("NetworkingEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    bool WirelessEnabled()
+    {
+        return proxy_.getProperty("WirelessEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    void WirelessEnabled(const bool& value)
+    {
+        proxy_.setProperty("WirelessEnabled").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool WirelessHardwareEnabled()
+    {
+        return proxy_.getProperty("WirelessHardwareEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    bool WwanEnabled()
+    {
+        return proxy_.getProperty("WwanEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    void WwanEnabled(const bool& value)
+    {
+        proxy_.setProperty("WwanEnabled").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool WwanHardwareEnabled()
+    {
+        return proxy_.getProperty("WwanHardwareEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    bool WimaxEnabled()
+    {
+        return proxy_.getProperty("WimaxEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    void WimaxEnabled(const bool& value)
+    {
+        proxy_.setProperty("WimaxEnabled").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool WimaxHardwareEnabled()
+    {
+        return proxy_.getProperty("WimaxHardwareEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t RadioFlags()
+    {
+        return proxy_.getProperty("RadioFlags").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<sdbus::ObjectPath> ActiveConnections()
+    {
+        return proxy_.getProperty("ActiveConnections").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath PrimaryConnection()
+    {
+        return proxy_.getProperty("PrimaryConnection").onInterface(INTERFACE_NAME);
+    }
+
+    std::string PrimaryConnectionType()
+    {
+        return proxy_.getProperty("PrimaryConnectionType").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Metered()
+    {
+        return proxy_.getProperty("Metered").onInterface(INTERFACE_NAME);
+    }
+
+    sdbus::ObjectPath ActivatingConnection()
+    {
+        return proxy_.getProperty("ActivatingConnection").onInterface(INTERFACE_NAME);
+    }
+
+    bool Startup()
+    {
+        return proxy_.getProperty("Startup").onInterface(INTERFACE_NAME);
+    }
+
+    std::string Version()
+    {
+        return proxy_.getProperty("Version").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint32_t> VersionInfo()
+    {
+        return proxy_.getProperty("VersionInfo").onInterface(INTERFACE_NAME);
+    }
+
+    std::vector<uint32_t> Capabilities()
+    {
+        return proxy_.getProperty("Capabilities").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t State()
+    {
+        return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
+    }
+
+    uint32_t Connectivity()
+    {
+        return proxy_.getProperty("Connectivity").onInterface(INTERFACE_NAME);
+    }
+
+    bool ConnectivityCheckAvailable()
+    {
+        return proxy_.getProperty("ConnectivityCheckAvailable").onInterface(INTERFACE_NAME);
+    }
+
+    bool ConnectivityCheckEnabled()
+    {
+        return proxy_.getProperty("ConnectivityCheckEnabled").onInterface(INTERFACE_NAME);
+    }
+
+    void ConnectivityCheckEnabled(const bool& value)
+    {
+        proxy_.setProperty("ConnectivityCheckEnabled").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    std::string ConnectivityCheckUri()
+    {
+        return proxy_.getProperty("ConnectivityCheckUri").onInterface(INTERFACE_NAME);
+    }
+
+    std::map<std::string, sdbus::Variant> GlobalDnsConfiguration()
+    {
+        return proxy_.getProperty("GlobalDnsConfiguration").onInterface(INTERFACE_NAME);
+    }
+
+    void GlobalDnsConfiguration(const std::map<std::string, sdbus::Variant>& value)
+    {
+        proxy_.setProperty("GlobalDnsConfiguration").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}} // namespaces
+
+#endif