/*
 * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
 */

#ifndef __sdbuscpp__dbus_hpp_f1_w1_wpa_supplicant1_Interfaces_hpp__proxy__H__
#define __sdbuscpp__dbus_hpp_f1_w1_wpa_supplicant1_Interfaces_hpp__proxy__H__

#include <sdbus-c++/sdbus-c++.h>
#include <string>
#include <tuple>

namespace fi {
namespace w1 {
namespace wpa_supplicant1 {

class Interface_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "fi.w1.wpa_supplicant1.Interface";

protected:
    Interface_proxy(sdbus::IProxy& proxy)
        : proxy_(proxy)
    {
        proxy_.uponSignal("ScanDone").onInterface(INTERFACE_NAME).call([this](const bool& success){ this->onScanDone(success); });
        proxy_.uponSignal("BSSAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties){ this->onBSSAdded(path, properties); });
        proxy_.uponSignal("BSSRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onBSSRemoved(path); });
        proxy_.uponSignal("BlobAdded").onInterface(INTERFACE_NAME).call([this](const std::string& name){ this->onBlobAdded(name); });
        proxy_.uponSignal("BlobRemoved").onInterface(INTERFACE_NAME).call([this](const std::string& name){ this->onBlobRemoved(name); });
        proxy_.uponSignal("NetworkAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties){ this->onNetworkAdded(path, properties); });
        proxy_.uponSignal("NetworkRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onNetworkRemoved(path); });
        proxy_.uponSignal("NetworkSelected").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onNetworkSelected(path); });
        proxy_.uponSignal("PropertiesChanged").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onPropertiesChanged(properties); });
        proxy_.uponSignal("ProbeRequest").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& args){ this->onProbeRequest(args); });
        proxy_.uponSignal("Certification").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& certification){ this->onCertification(certification); });
        proxy_.uponSignal("EAP").onInterface(INTERFACE_NAME).call([this](const std::string& status, const std::string& parameter){ this->onEAP(status, parameter); });
        proxy_.uponSignal("StaAuthorized").onInterface(INTERFACE_NAME).call([this](const std::string& name){ this->onStaAuthorized(name); });
        proxy_.uponSignal("StaDeauthorized").onInterface(INTERFACE_NAME).call([this](const std::string& name){ this->onStaDeauthorized(name); });
        proxy_.uponSignal("StationAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties){ this->onStationAdded(path, properties); });
        proxy_.uponSignal("StationRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onStationRemoved(path); });
        proxy_.uponSignal("NetworkRequest").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const std::string& field, const std::string& text){ this->onNetworkRequest(path, field, text); });
        proxy_.uponSignal("InterworkingAPAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& bss, const sdbus::ObjectPath& cred, const std::map<std::string, sdbus::Variant>& properties){ this->onInterworkingAPAdded(bss, cred, properties); });
        proxy_.uponSignal("InterworkingSelectDone").onInterface(INTERFACE_NAME).call([this](){ this->onInterworkingSelectDone(); });
    }

    ~Interface_proxy() = default;

    virtual void onScanDone(const bool& success) = 0;
    virtual void onBSSAdded(const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onBSSRemoved(const sdbus::ObjectPath& path) = 0;
    virtual void onBlobAdded(const std::string& name) = 0;
    virtual void onBlobRemoved(const std::string& name) = 0;
    virtual void onNetworkAdded(const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onNetworkRemoved(const sdbus::ObjectPath& path) = 0;
    virtual void onNetworkSelected(const sdbus::ObjectPath& path) = 0;
    virtual void onPropertiesChanged(const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onProbeRequest(const std::map<std::string, sdbus::Variant>& args) = 0;
    virtual void onCertification(const std::map<std::string, sdbus::Variant>& certification) = 0;
    virtual void onEAP(const std::string& status, const std::string& parameter) = 0;
    virtual void onStaAuthorized(const std::string& name) = 0;
    virtual void onStaDeauthorized(const std::string& name) = 0;
    virtual void onStationAdded(const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onStationRemoved(const sdbus::ObjectPath& path) = 0;
    virtual void onNetworkRequest(const sdbus::ObjectPath& path, const std::string& field, const std::string& text) = 0;
    virtual void onInterworkingAPAdded(const sdbus::ObjectPath& bss, const sdbus::ObjectPath& cred, const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onInterworkingSelectDone() = 0;

public:
    void Scan(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("Scan").onInterface(INTERFACE_NAME).withArguments(args);
    }

    std::map<std::string, sdbus::Variant> SignalPoll()
    {
        std::map<std::string, sdbus::Variant> result;
        proxy_.callMethod("SignalPoll").onInterface(INTERFACE_NAME).storeResultsTo(result);
        return result;
    }

    void Disconnect()
    {
        proxy_.callMethod("Disconnect").onInterface(INTERFACE_NAME);
    }

    sdbus::ObjectPath AddNetwork(const std::map<std::string, sdbus::Variant>& args)
    {
        sdbus::ObjectPath result;
        proxy_.callMethod("AddNetwork").onInterface(INTERFACE_NAME).withArguments(args).storeResultsTo(result);
        return result;
    }

    void Reassociate()
    {
        proxy_.callMethod("Reassociate").onInterface(INTERFACE_NAME);
    }

    void Reattach()
    {
        proxy_.callMethod("Reattach").onInterface(INTERFACE_NAME);
    }

    void Reconnect()
    {
        proxy_.callMethod("Reconnect").onInterface(INTERFACE_NAME);
    }

    void RemoveNetwork(const sdbus::ObjectPath& path)
    {
        proxy_.callMethod("RemoveNetwork").onInterface(INTERFACE_NAME).withArguments(path);
    }

    void RemoveAllNetworks()
    {
        proxy_.callMethod("RemoveAllNetworks").onInterface(INTERFACE_NAME);
    }

    void SelectNetwork(const sdbus::ObjectPath& path)
    {
        proxy_.callMethod("SelectNetwork").onInterface(INTERFACE_NAME).withArguments(path);
    }

    void NetworkReply(const sdbus::ObjectPath& path, const std::string& field, const std::string& value)
    {
        proxy_.callMethod("NetworkReply").onInterface(INTERFACE_NAME).withArguments(path, field, value);
    }

    void Roam(const std::string& addr)
    {
        proxy_.callMethod("Roam").onInterface(INTERFACE_NAME).withArguments(addr);
    }

    void AddBlob(const std::string& name, const std::vector<uint8_t>& data)
    {
        proxy_.callMethod("AddBlob").onInterface(INTERFACE_NAME).withArguments(name, data);
    }

    std::vector<uint8_t> GetBlob(const std::string& name)
    {
        std::vector<uint8_t> result;
        proxy_.callMethod("GetBlob").onInterface(INTERFACE_NAME).withArguments(name).storeResultsTo(result);
        return result;
    }

    void RemoveBlob(const std::string& name)
    {
        proxy_.callMethod("RemoveBlob").onInterface(INTERFACE_NAME).withArguments(name);
    }

    void SetPKCS11EngineAndModulePath(const std::string& pkcs11_engine_path, const std::string& pkcs11_module_path)
    {
        proxy_.callMethod("SetPKCS11EngineAndModulePath").onInterface(INTERFACE_NAME).withArguments(pkcs11_engine_path, pkcs11_module_path);
    }

    void FlushBSS(const uint32_t& age)
    {
        proxy_.callMethod("FlushBSS").onInterface(INTERFACE_NAME).withArguments(age);
    }

    void SubscribeProbeReq()
    {
        proxy_.callMethod("SubscribeProbeReq").onInterface(INTERFACE_NAME);
    }

    void UnsubscribeProbeReq()
    {
        proxy_.callMethod("UnsubscribeProbeReq").onInterface(INTERFACE_NAME);
    }

    void EAPLogoff()
    {
        proxy_.callMethod("EAPLogoff").onInterface(INTERFACE_NAME);
    }

    void EAPLogon()
    {
        proxy_.callMethod("EAPLogon").onInterface(INTERFACE_NAME);
    }

    void AutoScan(const std::string& arg)
    {
        proxy_.callMethod("AutoScan").onInterface(INTERFACE_NAME).withArguments(arg);
    }

    void TDLSDiscover(const std::string& peer_address)
    {
        proxy_.callMethod("TDLSDiscover").onInterface(INTERFACE_NAME).withArguments(peer_address);
    }

    void TDLSSetup(const std::string& peer_address)
    {
        proxy_.callMethod("TDLSSetup").onInterface(INTERFACE_NAME).withArguments(peer_address);
    }

    std::string TDLSStatus(const std::string& peer_address)
    {
        std::string result;
        proxy_.callMethod("TDLSStatus").onInterface(INTERFACE_NAME).withArguments(peer_address).storeResultsTo(result);
        return result;
    }

    void TDLSTeardown(const std::string& peer_address)
    {
        proxy_.callMethod("TDLSTeardown").onInterface(INTERFACE_NAME).withArguments(peer_address);
    }

    void TDLSChannelSwitch(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("TDLSChannelSwitch").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void TDLSCancelChannelSwitch(const std::string& peer_address)
    {
        proxy_.callMethod("TDLSCancelChannelSwitch").onInterface(INTERFACE_NAME).withArguments(peer_address);
    }

    void VendorElemAdd(const int32_t& frame_id, const std::vector<uint8_t>& ielems)
    {
        proxy_.callMethod("VendorElemAdd").onInterface(INTERFACE_NAME).withArguments(frame_id, ielems);
    }

    std::vector<uint8_t> VendorElemGet(const int32_t& frame_id)
    {
        std::vector<uint8_t> result;
        proxy_.callMethod("VendorElemGet").onInterface(INTERFACE_NAME).withArguments(frame_id).storeResultsTo(result);
        return result;
    }

    void VendorElemRem(const int32_t& frame_id, const std::vector<uint8_t>& ielems)
    {
        proxy_.callMethod("VendorElemRem").onInterface(INTERFACE_NAME).withArguments(frame_id, ielems);
    }

    void SaveConfig()
    {
        proxy_.callMethod("SaveConfig").onInterface(INTERFACE_NAME);
    }

    void AbortScan()
    {
        proxy_.callMethod("AbortScan").onInterface(INTERFACE_NAME);
    }

    sdbus::ObjectPath AddCred(const std::map<std::string, sdbus::Variant>& args)
    {
        sdbus::ObjectPath result;
        proxy_.callMethod("AddCred").onInterface(INTERFACE_NAME).withArguments(args).storeResultsTo(result);
        return result;
    }

    void RemoveCred(const sdbus::ObjectPath& path)
    {
        proxy_.callMethod("RemoveCred").onInterface(INTERFACE_NAME).withArguments(path);
    }

    void RemoveAllCreds()
    {
        proxy_.callMethod("RemoveAllCreds").onInterface(INTERFACE_NAME);
    }

    void InterworkingSelect()
    {
        proxy_.callMethod("InterworkingSelect").onInterface(INTERFACE_NAME);
    }

public:
    std::map<std::string, sdbus::Variant> Capabilities()
    {
        return proxy_.getProperty("Capabilities").onInterface(INTERFACE_NAME);
    }

    std::string State()
    {
        return proxy_.getProperty("State").onInterface(INTERFACE_NAME);
    }

    bool Scanning()
    {
        return proxy_.getProperty("Scanning").onInterface(INTERFACE_NAME);
    }

    uint32_t ApScan()
    {
        return proxy_.getProperty("ApScan").onInterface(INTERFACE_NAME);
    }

    void ApScan(const uint32_t& value)
    {
        proxy_.setProperty("ApScan").onInterface(INTERFACE_NAME).toValue(value);
    }

    uint32_t BSSExpireAge()
    {
        return proxy_.getProperty("BSSExpireAge").onInterface(INTERFACE_NAME);
    }

    void BSSExpireAge(const uint32_t& value)
    {
        proxy_.setProperty("BSSExpireAge").onInterface(INTERFACE_NAME).toValue(value);
    }

    uint32_t BSSExpireCount()
    {
        return proxy_.getProperty("BSSExpireCount").onInterface(INTERFACE_NAME);
    }

    void BSSExpireCount(const uint32_t& value)
    {
        proxy_.setProperty("BSSExpireCount").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Country()
    {
        return proxy_.getProperty("Country").onInterface(INTERFACE_NAME);
    }

    void Country(const std::string& value)
    {
        proxy_.setProperty("Country").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Ifname()
    {
        return proxy_.getProperty("Ifname").onInterface(INTERFACE_NAME);
    }

    std::string Driver()
    {
        return proxy_.getProperty("Driver").onInterface(INTERFACE_NAME);
    }

    std::string BridgeIfname()
    {
        return proxy_.getProperty("BridgeIfname").onInterface(INTERFACE_NAME);
    }

    void BridgeIfname(const std::string& value)
    {
        proxy_.setProperty("BridgeIfname").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ConfigFile()
    {
        return proxy_.getProperty("ConfigFile").onInterface(INTERFACE_NAME);
    }

    sdbus::ObjectPath CurrentBSS()
    {
        return proxy_.getProperty("CurrentBSS").onInterface(INTERFACE_NAME);
    }

    sdbus::ObjectPath CurrentNetwork()
    {
        return proxy_.getProperty("CurrentNetwork").onInterface(INTERFACE_NAME);
    }

    std::string CurrentAuthMode()
    {
        return proxy_.getProperty("CurrentAuthMode").onInterface(INTERFACE_NAME);
    }

    std::map<std::string, std::vector<uint8_t>> Blobs()
    {
        return proxy_.getProperty("Blobs").onInterface(INTERFACE_NAME);
    }

    std::vector<sdbus::ObjectPath> BSSs()
    {
        return proxy_.getProperty("BSSs").onInterface(INTERFACE_NAME);
    }

    std::vector<sdbus::ObjectPath> Networks()
    {
        return proxy_.getProperty("Networks").onInterface(INTERFACE_NAME);
    }

    bool FastReauth()
    {
        return proxy_.getProperty("FastReauth").onInterface(INTERFACE_NAME);
    }

    void FastReauth(const bool& value)
    {
        proxy_.setProperty("FastReauth").onInterface(INTERFACE_NAME).toValue(value);
    }

    int32_t ScanInterval()
    {
        return proxy_.getProperty("ScanInterval").onInterface(INTERFACE_NAME);
    }

    void ScanInterval(const int32_t& value)
    {
        proxy_.setProperty("ScanInterval").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string PKCS11EnginePath()
    {
        return proxy_.getProperty("PKCS11EnginePath").onInterface(INTERFACE_NAME);
    }

    std::string PKCS11ModulePath()
    {
        return proxy_.getProperty("PKCS11ModulePath").onInterface(INTERFACE_NAME);
    }

    int32_t DisconnectReason()
    {
        return proxy_.getProperty("DisconnectReason").onInterface(INTERFACE_NAME);
    }

    int32_t AuthStatusCode()
    {
        return proxy_.getProperty("AuthStatusCode").onInterface(INTERFACE_NAME);
    }

    int32_t AssocStatusCode()
    {
        return proxy_.getProperty("AssocStatusCode").onInterface(INTERFACE_NAME);
    }

    uint32_t RoamTime()
    {
        return proxy_.getProperty("RoamTime").onInterface(INTERFACE_NAME);
    }

    bool RoamComplete()
    {
        return proxy_.getProperty("RoamComplete").onInterface(INTERFACE_NAME);
    }

    uint32_t SessionLength()
    {
        return proxy_.getProperty("SessionLength").onInterface(INTERFACE_NAME);
    }

    uint32_t BSSTMStatus()
    {
        return proxy_.getProperty("BSSTMStatus").onInterface(INTERFACE_NAME);
    }

    std::vector<sdbus::ObjectPath> Stations()
    {
        return proxy_.getProperty("Stations").onInterface(INTERFACE_NAME);
    }

    std::map<std::string, std::vector<uint8_t>> MACAddressRandomizationMask()
    {
        return proxy_.getProperty("MACAddressRandomizationMask").onInterface(INTERFACE_NAME);
    }

    void MACAddressRandomizationMask(const std::map<std::string, std::vector<uint8_t>>& value)
    {
        proxy_.setProperty("MACAddressRandomizationMask").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string CtrlInterface()
    {
        return proxy_.getProperty("CtrlInterface").onInterface(INTERFACE_NAME);
    }

    void CtrlInterface(const std::string& value)
    {
        proxy_.setProperty("CtrlInterface").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string CtrlInterfaceGroup()
    {
        return proxy_.getProperty("CtrlInterfaceGroup").onInterface(INTERFACE_NAME);
    }

    void CtrlInterfaceGroup(const std::string& value)
    {
        proxy_.setProperty("CtrlInterfaceGroup").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string EapolVersion()
    {
        return proxy_.getProperty("EapolVersion").onInterface(INTERFACE_NAME);
    }

    void EapolVersion(const std::string& value)
    {
        proxy_.setProperty("EapolVersion").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Bgscan()
    {
        return proxy_.getProperty("Bgscan").onInterface(INTERFACE_NAME);
    }

    void Bgscan(const std::string& value)
    {
        proxy_.setProperty("Bgscan").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string UserMpm()
    {
        return proxy_.getProperty("UserMpm").onInterface(INTERFACE_NAME);
    }

    void UserMpm(const std::string& value)
    {
        proxy_.setProperty("UserMpm").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string MaxPeerLinks()
    {
        return proxy_.getProperty("MaxPeerLinks").onInterface(INTERFACE_NAME);
    }

    void MaxPeerLinks(const std::string& value)
    {
        proxy_.setProperty("MaxPeerLinks").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string MeshMaxInactivity()
    {
        return proxy_.getProperty("MeshMaxInactivity").onInterface(INTERFACE_NAME);
    }

    void MeshMaxInactivity(const std::string& value)
    {
        proxy_.setProperty("MeshMaxInactivity").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string MeshFwding()
    {
        return proxy_.getProperty("MeshFwding").onInterface(INTERFACE_NAME);
    }

    void MeshFwding(const std::string& value)
    {
        proxy_.setProperty("MeshFwding").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Dot11RSNASAERetransPeriod()
    {
        return proxy_.getProperty("Dot11RSNASAERetransPeriod").onInterface(INTERFACE_NAME);
    }

    void Dot11RSNASAERetransPeriod(const std::string& value)
    {
        proxy_.setProperty("Dot11RSNASAERetransPeriod").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DisableScanOffload()
    {
        return proxy_.getProperty("DisableScanOffload").onInterface(INTERFACE_NAME);
    }

    void DisableScanOffload(const std::string& value)
    {
        proxy_.setProperty("DisableScanOffload").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string OpenscEnginePath()
    {
        return proxy_.getProperty("OpenscEnginePath").onInterface(INTERFACE_NAME);
    }

    void OpenscEnginePath(const std::string& value)
    {
        proxy_.setProperty("OpenscEnginePath").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string OpensslCiphers()
    {
        return proxy_.getProperty("OpensslCiphers").onInterface(INTERFACE_NAME);
    }

    void OpensslCiphers(const std::string& value)
    {
        proxy_.setProperty("OpensslCiphers").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string PcscReader()
    {
        return proxy_.getProperty("PcscReader").onInterface(INTERFACE_NAME);
    }

    void PcscReader(const std::string& value)
    {
        proxy_.setProperty("PcscReader").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string PcscPin()
    {
        return proxy_.getProperty("PcscPin").onInterface(INTERFACE_NAME);
    }

    void PcscPin(const std::string& value)
    {
        proxy_.setProperty("PcscPin").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ExternalSim()
    {
        return proxy_.getProperty("ExternalSim").onInterface(INTERFACE_NAME);
    }

    void ExternalSim(const std::string& value)
    {
        proxy_.setProperty("ExternalSim").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DriverParam()
    {
        return proxy_.getProperty("DriverParam").onInterface(INTERFACE_NAME);
    }

    void DriverParam(const std::string& value)
    {
        proxy_.setProperty("DriverParam").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Dot11RSNAConfigPMKLifetime()
    {
        return proxy_.getProperty("Dot11RSNAConfigPMKLifetime").onInterface(INTERFACE_NAME);
    }

    void Dot11RSNAConfigPMKLifetime(const std::string& value)
    {
        proxy_.setProperty("Dot11RSNAConfigPMKLifetime").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Dot11RSNAConfigPMKReauthThreshold()
    {
        return proxy_.getProperty("Dot11RSNAConfigPMKReauthThreshold").onInterface(INTERFACE_NAME);
    }

    void Dot11RSNAConfigPMKReauthThreshold(const std::string& value)
    {
        proxy_.setProperty("Dot11RSNAConfigPMKReauthThreshold").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Dot11RSNAConfigSATimeout()
    {
        return proxy_.getProperty("Dot11RSNAConfigSATimeout").onInterface(INTERFACE_NAME);
    }

    void Dot11RSNAConfigSATimeout(const std::string& value)
    {
        proxy_.setProperty("Dot11RSNAConfigSATimeout").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string UpdateConfig()
    {
        return proxy_.getProperty("UpdateConfig").onInterface(INTERFACE_NAME);
    }

    void UpdateConfig(const std::string& value)
    {
        proxy_.setProperty("UpdateConfig").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Uuid()
    {
        return proxy_.getProperty("Uuid").onInterface(INTERFACE_NAME);
    }

    void Uuid(const std::string& value)
    {
        proxy_.setProperty("Uuid").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string AutoUuid()
    {
        return proxy_.getProperty("AutoUuid").onInterface(INTERFACE_NAME);
    }

    void AutoUuid(const std::string& value)
    {
        proxy_.setProperty("AutoUuid").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DeviceName()
    {
        return proxy_.getProperty("DeviceName").onInterface(INTERFACE_NAME);
    }

    void DeviceName(const std::string& value)
    {
        proxy_.setProperty("DeviceName").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Manufacturer()
    {
        return proxy_.getProperty("Manufacturer").onInterface(INTERFACE_NAME);
    }

    void Manufacturer(const std::string& value)
    {
        proxy_.setProperty("Manufacturer").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ModelName()
    {
        return proxy_.getProperty("ModelName").onInterface(INTERFACE_NAME);
    }

    void ModelName(const std::string& value)
    {
        proxy_.setProperty("ModelName").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ModelNumber()
    {
        return proxy_.getProperty("ModelNumber").onInterface(INTERFACE_NAME);
    }

    void ModelNumber(const std::string& value)
    {
        proxy_.setProperty("ModelNumber").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SerialNumber()
    {
        return proxy_.getProperty("SerialNumber").onInterface(INTERFACE_NAME);
    }

    void SerialNumber(const std::string& value)
    {
        proxy_.setProperty("SerialNumber").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DeviceType()
    {
        return proxy_.getProperty("DeviceType").onInterface(INTERFACE_NAME);
    }

    void DeviceType(const std::string& value)
    {
        proxy_.setProperty("DeviceType").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string OsVersion()
    {
        return proxy_.getProperty("OsVersion").onInterface(INTERFACE_NAME);
    }

    void OsVersion(const std::string& value)
    {
        proxy_.setProperty("OsVersion").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ConfigMethods()
    {
        return proxy_.getProperty("ConfigMethods").onInterface(INTERFACE_NAME);
    }

    void ConfigMethods(const std::string& value)
    {
        proxy_.setProperty("ConfigMethods").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsCredProcessing()
    {
        return proxy_.getProperty("WpsCredProcessing").onInterface(INTERFACE_NAME);
    }

    void WpsCredProcessing(const std::string& value)
    {
        proxy_.setProperty("WpsCredProcessing").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsCredAddSae()
    {
        return proxy_.getProperty("WpsCredAddSae").onInterface(INTERFACE_NAME);
    }

    void WpsCredAddSae(const std::string& value)
    {
        proxy_.setProperty("WpsCredAddSae").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsVendorExtM1()
    {
        return proxy_.getProperty("WpsVendorExtM1").onInterface(INTERFACE_NAME);
    }

    void WpsVendorExtM1(const std::string& value)
    {
        proxy_.setProperty("WpsVendorExtM1").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SecDeviceType()
    {
        return proxy_.getProperty("SecDeviceType").onInterface(INTERFACE_NAME);
    }

    void SecDeviceType(const std::string& value)
    {
        proxy_.setProperty("SecDeviceType").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pListenRegClass()
    {
        return proxy_.getProperty("P2pListenRegClass").onInterface(INTERFACE_NAME);
    }

    void P2pListenRegClass(const std::string& value)
    {
        proxy_.setProperty("P2pListenRegClass").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pListenChannel()
    {
        return proxy_.getProperty("P2pListenChannel").onInterface(INTERFACE_NAME);
    }

    void P2pListenChannel(const std::string& value)
    {
        proxy_.setProperty("P2pListenChannel").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pOperRegClass()
    {
        return proxy_.getProperty("P2pOperRegClass").onInterface(INTERFACE_NAME);
    }

    void P2pOperRegClass(const std::string& value)
    {
        proxy_.setProperty("P2pOperRegClass").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pOperChannel()
    {
        return proxy_.getProperty("P2pOperChannel").onInterface(INTERFACE_NAME);
    }

    void P2pOperChannel(const std::string& value)
    {
        proxy_.setProperty("P2pOperChannel").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoIntent()
    {
        return proxy_.getProperty("P2pGoIntent").onInterface(INTERFACE_NAME);
    }

    void P2pGoIntent(const std::string& value)
    {
        proxy_.setProperty("P2pGoIntent").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pSsidPostfix()
    {
        return proxy_.getProperty("P2pSsidPostfix").onInterface(INTERFACE_NAME);
    }

    void P2pSsidPostfix(const std::string& value)
    {
        proxy_.setProperty("P2pSsidPostfix").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string PersistentReconnect()
    {
        return proxy_.getProperty("PersistentReconnect").onInterface(INTERFACE_NAME);
    }

    void PersistentReconnect(const std::string& value)
    {
        proxy_.setProperty("PersistentReconnect").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pIntraBss()
    {
        return proxy_.getProperty("P2pIntraBss").onInterface(INTERFACE_NAME);
    }

    void P2pIntraBss(const std::string& value)
    {
        proxy_.setProperty("P2pIntraBss").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGroupIdle()
    {
        return proxy_.getProperty("P2pGroupIdle").onInterface(INTERFACE_NAME);
    }

    void P2pGroupIdle(const std::string& value)
    {
        proxy_.setProperty("P2pGroupIdle").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoFreqChangePolicy()
    {
        return proxy_.getProperty("P2pGoFreqChangePolicy").onInterface(INTERFACE_NAME);
    }

    void P2pGoFreqChangePolicy(const std::string& value)
    {
        proxy_.setProperty("P2pGoFreqChangePolicy").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pPassphraseLen()
    {
        return proxy_.getProperty("P2pPassphraseLen").onInterface(INTERFACE_NAME);
    }

    void P2pPassphraseLen(const std::string& value)
    {
        proxy_.setProperty("P2pPassphraseLen").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pPrefChan()
    {
        return proxy_.getProperty("P2pPrefChan").onInterface(INTERFACE_NAME);
    }

    void P2pPrefChan(const std::string& value)
    {
        proxy_.setProperty("P2pPrefChan").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pNoGoFreq()
    {
        return proxy_.getProperty("P2pNoGoFreq").onInterface(INTERFACE_NAME);
    }

    void P2pNoGoFreq(const std::string& value)
    {
        proxy_.setProperty("P2pNoGoFreq").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pAddCliChan()
    {
        return proxy_.getProperty("P2pAddCliChan").onInterface(INTERFACE_NAME);
    }

    void P2pAddCliChan(const std::string& value)
    {
        proxy_.setProperty("P2pAddCliChan").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pOptimizeListenChan()
    {
        return proxy_.getProperty("P2pOptimizeListenChan").onInterface(INTERFACE_NAME);
    }

    void P2pOptimizeListenChan(const std::string& value)
    {
        proxy_.setProperty("P2pOptimizeListenChan").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoHt40()
    {
        return proxy_.getProperty("P2pGoHt40").onInterface(INTERFACE_NAME);
    }

    void P2pGoHt40(const std::string& value)
    {
        proxy_.setProperty("P2pGoHt40").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoVht()
    {
        return proxy_.getProperty("P2pGoVht").onInterface(INTERFACE_NAME);
    }

    void P2pGoVht(const std::string& value)
    {
        proxy_.setProperty("P2pGoVht").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoHe()
    {
        return proxy_.getProperty("P2pGoHe").onInterface(INTERFACE_NAME);
    }

    void P2pGoHe(const std::string& value)
    {
        proxy_.setProperty("P2pGoHe").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoEdmg()
    {
        return proxy_.getProperty("P2pGoEdmg").onInterface(INTERFACE_NAME);
    }

    void P2pGoEdmg(const std::string& value)
    {
        proxy_.setProperty("P2pGoEdmg").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pDisabled()
    {
        return proxy_.getProperty("P2pDisabled").onInterface(INTERFACE_NAME);
    }

    void P2pDisabled(const std::string& value)
    {
        proxy_.setProperty("P2pDisabled").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoCtwindow()
    {
        return proxy_.getProperty("P2pGoCtwindow").onInterface(INTERFACE_NAME);
    }

    void P2pGoCtwindow(const std::string& value)
    {
        proxy_.setProperty("P2pGoCtwindow").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pNoGroupIface()
    {
        return proxy_.getProperty("P2pNoGroupIface").onInterface(INTERFACE_NAME);
    }

    void P2pNoGroupIface(const std::string& value)
    {
        proxy_.setProperty("P2pNoGroupIface").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pIgnoreSharedFreq()
    {
        return proxy_.getProperty("P2pIgnoreSharedFreq").onInterface(INTERFACE_NAME);
    }

    void P2pIgnoreSharedFreq(const std::string& value)
    {
        proxy_.setProperty("P2pIgnoreSharedFreq").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string IpAddrGo()
    {
        return proxy_.getProperty("IpAddrGo").onInterface(INTERFACE_NAME);
    }

    void IpAddrGo(const std::string& value)
    {
        proxy_.setProperty("IpAddrGo").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string IpAddrMask()
    {
        return proxy_.getProperty("IpAddrMask").onInterface(INTERFACE_NAME);
    }

    void IpAddrMask(const std::string& value)
    {
        proxy_.setProperty("IpAddrMask").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string IpAddrStart()
    {
        return proxy_.getProperty("IpAddrStart").onInterface(INTERFACE_NAME);
    }

    void IpAddrStart(const std::string& value)
    {
        proxy_.setProperty("IpAddrStart").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string IpAddrEnd()
    {
        return proxy_.getProperty("IpAddrEnd").onInterface(INTERFACE_NAME);
    }

    void IpAddrEnd(const std::string& value)
    {
        proxy_.setProperty("IpAddrEnd").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pCliProbe()
    {
        return proxy_.getProperty("P2pCliProbe").onInterface(INTERFACE_NAME);
    }

    void P2pCliProbe(const std::string& value)
    {
        proxy_.setProperty("P2pCliProbe").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pDeviceRandomMacAddr()
    {
        return proxy_.getProperty("P2pDeviceRandomMacAddr").onInterface(INTERFACE_NAME);
    }

    void P2pDeviceRandomMacAddr(const std::string& value)
    {
        proxy_.setProperty("P2pDeviceRandomMacAddr").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pDevicePersistentMacAddr()
    {
        return proxy_.getProperty("P2pDevicePersistentMacAddr").onInterface(INTERFACE_NAME);
    }

    void P2pDevicePersistentMacAddr(const std::string& value)
    {
        proxy_.setProperty("P2pDevicePersistentMacAddr").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pInterfaceRandomMacAddr()
    {
        return proxy_.getProperty("P2pInterfaceRandomMacAddr").onInterface(INTERFACE_NAME);
    }

    void P2pInterfaceRandomMacAddr(const std::string& value)
    {
        proxy_.setProperty("P2pInterfaceRandomMacAddr").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2p6ghzDisable()
    {
        return proxy_.getProperty("P2p6ghzDisable").onInterface(INTERFACE_NAME);
    }

    void P2p6ghzDisable(const std::string& value)
    {
        proxy_.setProperty("P2p6ghzDisable").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string BssMaxCount()
    {
        return proxy_.getProperty("BssMaxCount").onInterface(INTERFACE_NAME);
    }

    void BssMaxCount(const std::string& value)
    {
        proxy_.setProperty("BssMaxCount").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FilterSsids()
    {
        return proxy_.getProperty("FilterSsids").onInterface(INTERFACE_NAME);
    }

    void FilterSsids(const std::string& value)
    {
        proxy_.setProperty("FilterSsids").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FilterRssi()
    {
        return proxy_.getProperty("FilterRssi").onInterface(INTERFACE_NAME);
    }

    void FilterRssi(const std::string& value)
    {
        proxy_.setProperty("FilterRssi").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string MaxNumSta()
    {
        return proxy_.getProperty("MaxNumSta").onInterface(INTERFACE_NAME);
    }

    void MaxNumSta(const std::string& value)
    {
        proxy_.setProperty("MaxNumSta").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ApIsolate()
    {
        return proxy_.getProperty("ApIsolate").onInterface(INTERFACE_NAME);
    }

    void ApIsolate(const std::string& value)
    {
        proxy_.setProperty("ApIsolate").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DisassocLowAck()
    {
        return proxy_.getProperty("DisassocLowAck").onInterface(INTERFACE_NAME);
    }

    void DisassocLowAck(const std::string& value)
    {
        proxy_.setProperty("DisassocLowAck").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Hs20()
    {
        return proxy_.getProperty("Hs20").onInterface(INTERFACE_NAME);
    }

    void Hs20(const std::string& value)
    {
        proxy_.setProperty("Hs20").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Interworking()
    {
        return proxy_.getProperty("Interworking").onInterface(INTERFACE_NAME);
    }

    void Interworking(const std::string& value)
    {
        proxy_.setProperty("Interworking").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Hessid()
    {
        return proxy_.getProperty("Hessid").onInterface(INTERFACE_NAME);
    }

    void Hessid(const std::string& value)
    {
        proxy_.setProperty("Hessid").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string AccessNetworkType()
    {
        return proxy_.getProperty("AccessNetworkType").onInterface(INTERFACE_NAME);
    }

    void AccessNetworkType(const std::string& value)
    {
        proxy_.setProperty("AccessNetworkType").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GoInterworking()
    {
        return proxy_.getProperty("GoInterworking").onInterface(INTERFACE_NAME);
    }

    void GoInterworking(const std::string& value)
    {
        proxy_.setProperty("GoInterworking").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GoAccessNetworkType()
    {
        return proxy_.getProperty("GoAccessNetworkType").onInterface(INTERFACE_NAME);
    }

    void GoAccessNetworkType(const std::string& value)
    {
        proxy_.setProperty("GoAccessNetworkType").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GoInternet()
    {
        return proxy_.getProperty("GoInternet").onInterface(INTERFACE_NAME);
    }

    void GoInternet(const std::string& value)
    {
        proxy_.setProperty("GoInternet").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GoVenueGroup()
    {
        return proxy_.getProperty("GoVenueGroup").onInterface(INTERFACE_NAME);
    }

    void GoVenueGroup(const std::string& value)
    {
        proxy_.setProperty("GoVenueGroup").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GoVenueType()
    {
        return proxy_.getProperty("GoVenueType").onInterface(INTERFACE_NAME);
    }

    void GoVenueType(const std::string& value)
    {
        proxy_.setProperty("GoVenueType").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string PbcInM1()
    {
        return proxy_.getProperty("PbcInM1").onInterface(INTERFACE_NAME);
    }

    void PbcInM1(const std::string& value)
    {
        proxy_.setProperty("PbcInM1").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Autoscan()
    {
        return proxy_.getProperty("Autoscan").onInterface(INTERFACE_NAME);
    }

    void Autoscan(const std::string& value)
    {
        proxy_.setProperty("Autoscan").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsNfcDevPwId()
    {
        return proxy_.getProperty("WpsNfcDevPwId").onInterface(INTERFACE_NAME);
    }

    void WpsNfcDevPwId(const std::string& value)
    {
        proxy_.setProperty("WpsNfcDevPwId").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsNfcDhPubkey()
    {
        return proxy_.getProperty("WpsNfcDhPubkey").onInterface(INTERFACE_NAME);
    }

    void WpsNfcDhPubkey(const std::string& value)
    {
        proxy_.setProperty("WpsNfcDhPubkey").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsNfcDhPrivkey()
    {
        return proxy_.getProperty("WpsNfcDhPrivkey").onInterface(INTERFACE_NAME);
    }

    void WpsNfcDhPrivkey(const std::string& value)
    {
        proxy_.setProperty("WpsNfcDhPrivkey").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsNfcDevPw()
    {
        return proxy_.getProperty("WpsNfcDevPw").onInterface(INTERFACE_NAME);
    }

    void WpsNfcDevPw(const std::string& value)
    {
        proxy_.setProperty("WpsNfcDevPw").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ExtPasswordBackend()
    {
        return proxy_.getProperty("ExtPasswordBackend").onInterface(INTERFACE_NAME);
    }

    void ExtPasswordBackend(const std::string& value)
    {
        proxy_.setProperty("ExtPasswordBackend").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pGoMaxInactivity()
    {
        return proxy_.getProperty("P2pGoMaxInactivity").onInterface(INTERFACE_NAME);
    }

    void P2pGoMaxInactivity(const std::string& value)
    {
        proxy_.setProperty("P2pGoMaxInactivity").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string AutoInterworking()
    {
        return proxy_.getProperty("AutoInterworking").onInterface(INTERFACE_NAME);
    }

    void AutoInterworking(const std::string& value)
    {
        proxy_.setProperty("AutoInterworking").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Okc()
    {
        return proxy_.getProperty("Okc").onInterface(INTERFACE_NAME);
    }

    void Okc(const std::string& value)
    {
        proxy_.setProperty("Okc").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Pmf()
    {
        return proxy_.getProperty("Pmf").onInterface(INTERFACE_NAME);
    }

    void Pmf(const std::string& value)
    {
        proxy_.setProperty("Pmf").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SaeGroups()
    {
        return proxy_.getProperty("SaeGroups").onInterface(INTERFACE_NAME);
    }

    void SaeGroups(const std::string& value)
    {
        proxy_.setProperty("SaeGroups").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SaePwe()
    {
        return proxy_.getProperty("SaePwe").onInterface(INTERFACE_NAME);
    }

    void SaePwe(const std::string& value)
    {
        proxy_.setProperty("SaePwe").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SaePmkidInAssoc()
    {
        return proxy_.getProperty("SaePmkidInAssoc").onInterface(INTERFACE_NAME);
    }

    void SaePmkidInAssoc(const std::string& value)
    {
        proxy_.setProperty("SaePmkidInAssoc").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DtimPeriod()
    {
        return proxy_.getProperty("DtimPeriod").onInterface(INTERFACE_NAME);
    }

    void DtimPeriod(const std::string& value)
    {
        proxy_.setProperty("DtimPeriod").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string BeaconInt()
    {
        return proxy_.getProperty("BeaconInt").onInterface(INTERFACE_NAME);
    }

    void BeaconInt(const std::string& value)
    {
        proxy_.setProperty("BeaconInt").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ApAssocrespElements()
    {
        return proxy_.getProperty("ApAssocrespElements").onInterface(INTERFACE_NAME);
    }

    void ApAssocrespElements(const std::string& value)
    {
        proxy_.setProperty("ApAssocrespElements").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ApVendorElements()
    {
        return proxy_.getProperty("ApVendorElements").onInterface(INTERFACE_NAME);
    }

    void ApVendorElements(const std::string& value)
    {
        proxy_.setProperty("ApVendorElements").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string IgnoreOldScanRes()
    {
        return proxy_.getProperty("IgnoreOldScanRes").onInterface(INTERFACE_NAME);
    }

    void IgnoreOldScanRes(const std::string& value)
    {
        proxy_.setProperty("IgnoreOldScanRes").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FreqList()
    {
        return proxy_.getProperty("FreqList").onInterface(INTERFACE_NAME);
    }

    void FreqList(const std::string& value)
    {
        proxy_.setProperty("FreqList").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string InitialFreqList()
    {
        return proxy_.getProperty("InitialFreqList").onInterface(INTERFACE_NAME);
    }

    void InitialFreqList(const std::string& value)
    {
        proxy_.setProperty("InitialFreqList").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ScanCurFreq()
    {
        return proxy_.getProperty("ScanCurFreq").onInterface(INTERFACE_NAME);
    }

    void ScanCurFreq(const std::string& value)
    {
        proxy_.setProperty("ScanCurFreq").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ScanResValidForConnect()
    {
        return proxy_.getProperty("ScanResValidForConnect").onInterface(INTERFACE_NAME);
    }

    void ScanResValidForConnect(const std::string& value)
    {
        proxy_.setProperty("ScanResValidForConnect").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SchedScanInterval()
    {
        return proxy_.getProperty("SchedScanInterval").onInterface(INTERFACE_NAME);
    }

    void SchedScanInterval(const std::string& value)
    {
        proxy_.setProperty("SchedScanInterval").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SchedScanStartDelay()
    {
        return proxy_.getProperty("SchedScanStartDelay").onInterface(INTERFACE_NAME);
    }

    void SchedScanStartDelay(const std::string& value)
    {
        proxy_.setProperty("SchedScanStartDelay").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string TdlsExternalControl()
    {
        return proxy_.getProperty("TdlsExternalControl").onInterface(INTERFACE_NAME);
    }

    void TdlsExternalControl(const std::string& value)
    {
        proxy_.setProperty("TdlsExternalControl").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string OsuDir()
    {
        return proxy_.getProperty("OsuDir").onInterface(INTERFACE_NAME);
    }

    void OsuDir(const std::string& value)
    {
        proxy_.setProperty("OsuDir").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WowlanTriggers()
    {
        return proxy_.getProperty("WowlanTriggers").onInterface(INTERFACE_NAME);
    }

    void WowlanTriggers(const std::string& value)
    {
        proxy_.setProperty("WowlanTriggers").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string P2pSearchDelay()
    {
        return proxy_.getProperty("P2pSearchDelay").onInterface(INTERFACE_NAME);
    }

    void P2pSearchDelay(const std::string& value)
    {
        proxy_.setProperty("P2pSearchDelay").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string MacAddr()
    {
        return proxy_.getProperty("MacAddr").onInterface(INTERFACE_NAME);
    }

    void MacAddr(const std::string& value)
    {
        proxy_.setProperty("MacAddr").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string RandAddrLifetime()
    {
        return proxy_.getProperty("RandAddrLifetime").onInterface(INTERFACE_NAME);
    }

    void RandAddrLifetime(const std::string& value)
    {
        proxy_.setProperty("RandAddrLifetime").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string PreassocMacAddr()
    {
        return proxy_.getProperty("PreassocMacAddr").onInterface(INTERFACE_NAME);
    }

    void PreassocMacAddr(const std::string& value)
    {
        proxy_.setProperty("PreassocMacAddr").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string KeyMgmtOffload()
    {
        return proxy_.getProperty("KeyMgmtOffload").onInterface(INTERFACE_NAME);
    }

    void KeyMgmtOffload(const std::string& value)
    {
        proxy_.setProperty("KeyMgmtOffload").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string PassiveScan()
    {
        return proxy_.getProperty("PassiveScan").onInterface(INTERFACE_NAME);
    }

    void PassiveScan(const std::string& value)
    {
        proxy_.setProperty("PassiveScan").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ReassocSameBssOptim()
    {
        return proxy_.getProperty("ReassocSameBssOptim").onInterface(INTERFACE_NAME);
    }

    void ReassocSameBssOptim(const std::string& value)
    {
        proxy_.setProperty("ReassocSameBssOptim").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpsPriority()
    {
        return proxy_.getProperty("WpsPriority").onInterface(INTERFACE_NAME);
    }

    void WpsPriority(const std::string& value)
    {
        proxy_.setProperty("WpsPriority").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FstGroupId()
    {
        return proxy_.getProperty("FstGroupId").onInterface(INTERFACE_NAME);
    }

    void FstGroupId(const std::string& value)
    {
        proxy_.setProperty("FstGroupId").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FstPriority()
    {
        return proxy_.getProperty("FstPriority").onInterface(INTERFACE_NAME);
    }

    void FstPriority(const std::string& value)
    {
        proxy_.setProperty("FstPriority").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FstLlt()
    {
        return proxy_.getProperty("FstLlt").onInterface(INTERFACE_NAME);
    }

    void FstLlt(const std::string& value)
    {
        proxy_.setProperty("FstLlt").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string CertInCb()
    {
        return proxy_.getProperty("CertInCb").onInterface(INTERFACE_NAME);
    }

    void CertInCb(const std::string& value)
    {
        proxy_.setProperty("CertInCb").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WpaRscRelaxation()
    {
        return proxy_.getProperty("WpaRscRelaxation").onInterface(INTERFACE_NAME);
    }

    void WpaRscRelaxation(const std::string& value)
    {
        proxy_.setProperty("WpaRscRelaxation").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SchedScanPlans()
    {
        return proxy_.getProperty("SchedScanPlans").onInterface(INTERFACE_NAME);
    }

    void SchedScanPlans(const std::string& value)
    {
        proxy_.setProperty("SchedScanPlans").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string NonPrefChan()
    {
        return proxy_.getProperty("NonPrefChan").onInterface(INTERFACE_NAME);
    }

    void NonPrefChan(const std::string& value)
    {
        proxy_.setProperty("NonPrefChan").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string MboCellCapa()
    {
        return proxy_.getProperty("MboCellCapa").onInterface(INTERFACE_NAME);
    }

    void MboCellCapa(const std::string& value)
    {
        proxy_.setProperty("MboCellCapa").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DisassocImminentRssiThreshold()
    {
        return proxy_.getProperty("DisassocImminentRssiThreshold").onInterface(INTERFACE_NAME);
    }

    void DisassocImminentRssiThreshold(const std::string& value)
    {
        proxy_.setProperty("DisassocImminentRssiThreshold").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Oce()
    {
        return proxy_.getProperty("Oce").onInterface(INTERFACE_NAME);
    }

    void Oce(const std::string& value)
    {
        proxy_.setProperty("Oce").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GasAddress3()
    {
        return proxy_.getProperty("GasAddress3").onInterface(INTERFACE_NAME);
    }

    void GasAddress3(const std::string& value)
    {
        proxy_.setProperty("GasAddress3").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FtmResponder()
    {
        return proxy_.getProperty("FtmResponder").onInterface(INTERFACE_NAME);
    }

    void FtmResponder(const std::string& value)
    {
        proxy_.setProperty("FtmResponder").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string FtmInitiator()
    {
        return proxy_.getProperty("FtmInitiator").onInterface(INTERFACE_NAME);
    }

    void FtmInitiator(const std::string& value)
    {
        proxy_.setProperty("FtmInitiator").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GasRandAddrLifetime()
    {
        return proxy_.getProperty("GasRandAddrLifetime").onInterface(INTERFACE_NAME);
    }

    void GasRandAddrLifetime(const std::string& value)
    {
        proxy_.setProperty("GasRandAddrLifetime").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string GasRandMacAddr()
    {
        return proxy_.getProperty("GasRandMacAddr").onInterface(INTERFACE_NAME);
    }

    void GasRandMacAddr(const std::string& value)
    {
        proxy_.setProperty("GasRandMacAddr").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DppConfigProcessing()
    {
        return proxy_.getProperty("DppConfigProcessing").onInterface(INTERFACE_NAME);
    }

    void DppConfigProcessing(const std::string& value)
    {
        proxy_.setProperty("DppConfigProcessing").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DppName()
    {
        return proxy_.getProperty("DppName").onInterface(INTERFACE_NAME);
    }

    void DppName(const std::string& value)
    {
        proxy_.setProperty("DppName").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DppMudUrl()
    {
        return proxy_.getProperty("DppMudUrl").onInterface(INTERFACE_NAME);
    }

    void DppMudUrl(const std::string& value)
    {
        proxy_.setProperty("DppMudUrl").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ColocIntfReporting()
    {
        return proxy_.getProperty("ColocIntfReporting").onInterface(INTERFACE_NAME);
    }

    void ColocIntfReporting(const std::string& value)
    {
        proxy_.setProperty("ColocIntfReporting").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DisableBtm()
    {
        return proxy_.getProperty("DisableBtm").onInterface(INTERFACE_NAME);
    }

    void DisableBtm(const std::string& value)
    {
        proxy_.setProperty("DisableBtm").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ExtendedKeyId()
    {
        return proxy_.getProperty("ExtendedKeyId").onInterface(INTERFACE_NAME);
    }

    void ExtendedKeyId(const std::string& value)
    {
        proxy_.setProperty("ExtendedKeyId").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string WowlanDisconnectOnDeinit()
    {
        return proxy_.getProperty("WowlanDisconnectOnDeinit").onInterface(INTERFACE_NAME);
    }

    void WowlanDisconnectOnDeinit(const std::string& value)
    {
        proxy_.setProperty("WowlanDisconnectOnDeinit").onInterface(INTERFACE_NAME).toValue(value);
    }

private:
    sdbus::IProxy& proxy_;
};

}}} // namespaces

namespace fi {
namespace w1 {
namespace wpa_supplicant1 {
namespace Interface {

class WPS_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "fi.w1.wpa_supplicant1.Interface.WPS";

protected:
    WPS_proxy(sdbus::IProxy& proxy)
        : proxy_(proxy)
    {
        proxy_.uponSignal("Event").onInterface(INTERFACE_NAME).call([this](const std::string& name, const std::map<std::string, sdbus::Variant>& args){ this->onEvent(name, args); });
        proxy_.uponSignal("Credentials").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& credentials){ this->onCredentials(credentials); });
        proxy_.uponSignal("PropertiesChanged").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onPropertiesChanged(properties); });
    }

    ~WPS_proxy() = default;

    virtual void onEvent(const std::string& name, const std::map<std::string, sdbus::Variant>& args) = 0;
    virtual void onCredentials(const std::map<std::string, sdbus::Variant>& credentials) = 0;
    virtual void onPropertiesChanged(const std::map<std::string, sdbus::Variant>& properties) = 0;

public:
    std::map<std::string, sdbus::Variant> Start(const std::map<std::string, sdbus::Variant>& args)
    {
        std::map<std::string, sdbus::Variant> result;
        proxy_.callMethod("Start").onInterface(INTERFACE_NAME).withArguments(args).storeResultsTo(result);
        return result;
    }

    void Cancel()
    {
        proxy_.callMethod("Cancel").onInterface(INTERFACE_NAME);
    }

public:
    bool ProcessCredentials()
    {
        return proxy_.getProperty("ProcessCredentials").onInterface(INTERFACE_NAME);
    }

    void ProcessCredentials(const bool& value)
    {
        proxy_.setProperty("ProcessCredentials").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ConfigMethods()
    {
        return proxy_.getProperty("ConfigMethods").onInterface(INTERFACE_NAME);
    }

    void ConfigMethods(const std::string& value)
    {
        proxy_.setProperty("ConfigMethods").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string DeviceName()
    {
        return proxy_.getProperty("DeviceName").onInterface(INTERFACE_NAME);
    }

    void DeviceName(const std::string& value)
    {
        proxy_.setProperty("DeviceName").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string Manufacturer()
    {
        return proxy_.getProperty("Manufacturer").onInterface(INTERFACE_NAME);
    }

    void Manufacturer(const std::string& value)
    {
        proxy_.setProperty("Manufacturer").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ModelName()
    {
        return proxy_.getProperty("ModelName").onInterface(INTERFACE_NAME);
    }

    void ModelName(const std::string& value)
    {
        proxy_.setProperty("ModelName").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string ModelNumber()
    {
        return proxy_.getProperty("ModelNumber").onInterface(INTERFACE_NAME);
    }

    void ModelNumber(const std::string& value)
    {
        proxy_.setProperty("ModelNumber").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::string SerialNumber()
    {
        return proxy_.getProperty("SerialNumber").onInterface(INTERFACE_NAME);
    }

    void SerialNumber(const std::string& value)
    {
        proxy_.setProperty("SerialNumber").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::vector<uint8_t> DeviceType()
    {
        return proxy_.getProperty("DeviceType").onInterface(INTERFACE_NAME);
    }

    void DeviceType(const std::vector<uint8_t>& value)
    {
        proxy_.setProperty("DeviceType").onInterface(INTERFACE_NAME).toValue(value);
    }

private:
    sdbus::IProxy& proxy_;
};

}}}} // namespaces

namespace fi {
namespace w1 {
namespace wpa_supplicant1 {
namespace Interface {

class P2PDevice_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "fi.w1.wpa_supplicant1.Interface.P2PDevice";

protected:
    P2PDevice_proxy(sdbus::IProxy& proxy)
        : proxy_(proxy)
    {
        proxy_.uponSignal("DeviceFound").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onDeviceFound(path); });
        proxy_.uponSignal("DeviceFoundProperties").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties){ this->onDeviceFoundProperties(path, properties); });
        proxy_.uponSignal("DeviceLost").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onDeviceLost(path); });
        proxy_.uponSignal("FindStopped").onInterface(INTERFACE_NAME).call([this](){ this->onFindStopped(); });
        proxy_.uponSignal("ProvisionDiscoveryRequestDisplayPin").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer_object, const std::string& pin){ this->onProvisionDiscoveryRequestDisplayPin(peer_object, pin); });
        proxy_.uponSignal("ProvisionDiscoveryResponseDisplayPin").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer_object, const std::string& pin){ this->onProvisionDiscoveryResponseDisplayPin(peer_object, pin); });
        proxy_.uponSignal("ProvisionDiscoveryRequestEnterPin").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer_object){ this->onProvisionDiscoveryRequestEnterPin(peer_object); });
        proxy_.uponSignal("ProvisionDiscoveryResponseEnterPin").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer_object){ this->onProvisionDiscoveryResponseEnterPin(peer_object); });
        proxy_.uponSignal("ProvisionDiscoveryPBCRequest").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer_object){ this->onProvisionDiscoveryPBCRequest(peer_object); });
        proxy_.uponSignal("ProvisionDiscoveryPBCResponse").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer_object){ this->onProvisionDiscoveryPBCResponse(peer_object); });
        proxy_.uponSignal("ProvisionDiscoveryFailure").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& peer_object, const int32_t& status){ this->onProvisionDiscoveryFailure(peer_object, status); });
        proxy_.uponSignal("GroupStarted").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onGroupStarted(properties); });
        proxy_.uponSignal("GroupFormationFailure").onInterface(INTERFACE_NAME).call([this](const std::string& reason){ this->onGroupFormationFailure(reason); });
        proxy_.uponSignal("GONegotiationSuccess").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onGONegotiationSuccess(properties); });
        proxy_.uponSignal("GONegotiationFailure").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onGONegotiationFailure(properties); });
        proxy_.uponSignal("GONegotiationRequest").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const uint16_t& dev_passwd_id, const uint8_t& device_go_intent){ this->onGONegotiationRequest(path, dev_passwd_id, device_go_intent); });
        proxy_.uponSignal("InvitationResult").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& invite_result){ this->onInvitationResult(invite_result); });
        proxy_.uponSignal("GroupFinished").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onGroupFinished(properties); });
        proxy_.uponSignal("ServiceDiscoveryRequest").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& sd_request){ this->onServiceDiscoveryRequest(sd_request); });
        proxy_.uponSignal("ServiceDiscoveryResponse").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& sd_response){ this->onServiceDiscoveryResponse(sd_response); });
        proxy_.uponSignal("PersistentGroupAdded").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties){ this->onPersistentGroupAdded(path, properties); });
        proxy_.uponSignal("PersistentGroupRemoved").onInterface(INTERFACE_NAME).call([this](const sdbus::ObjectPath& path){ this->onPersistentGroupRemoved(path); });
        proxy_.uponSignal("WpsFailed").onInterface(INTERFACE_NAME).call([this](const std::string& name, const std::map<std::string, sdbus::Variant>& args){ this->onWpsFailed(name, args); });
        proxy_.uponSignal("InvitationReceived").onInterface(INTERFACE_NAME).call([this](const std::map<std::string, sdbus::Variant>& properties){ this->onInvitationReceived(properties); });
    }

    ~P2PDevice_proxy() = default;

    virtual void onDeviceFound(const sdbus::ObjectPath& path) = 0;
    virtual void onDeviceFoundProperties(const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onDeviceLost(const sdbus::ObjectPath& path) = 0;
    virtual void onFindStopped() = 0;
    virtual void onProvisionDiscoveryRequestDisplayPin(const sdbus::ObjectPath& peer_object, const std::string& pin) = 0;
    virtual void onProvisionDiscoveryResponseDisplayPin(const sdbus::ObjectPath& peer_object, const std::string& pin) = 0;
    virtual void onProvisionDiscoveryRequestEnterPin(const sdbus::ObjectPath& peer_object) = 0;
    virtual void onProvisionDiscoveryResponseEnterPin(const sdbus::ObjectPath& peer_object) = 0;
    virtual void onProvisionDiscoveryPBCRequest(const sdbus::ObjectPath& peer_object) = 0;
    virtual void onProvisionDiscoveryPBCResponse(const sdbus::ObjectPath& peer_object) = 0;
    virtual void onProvisionDiscoveryFailure(const sdbus::ObjectPath& peer_object, const int32_t& status) = 0;
    virtual void onGroupStarted(const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onGroupFormationFailure(const std::string& reason) = 0;
    virtual void onGONegotiationSuccess(const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onGONegotiationFailure(const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onGONegotiationRequest(const sdbus::ObjectPath& path, const uint16_t& dev_passwd_id, const uint8_t& device_go_intent) = 0;
    virtual void onInvitationResult(const std::map<std::string, sdbus::Variant>& invite_result) = 0;
    virtual void onGroupFinished(const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onServiceDiscoveryRequest(const std::map<std::string, sdbus::Variant>& sd_request) = 0;
    virtual void onServiceDiscoveryResponse(const std::map<std::string, sdbus::Variant>& sd_response) = 0;
    virtual void onPersistentGroupAdded(const sdbus::ObjectPath& path, const std::map<std::string, sdbus::Variant>& properties) = 0;
    virtual void onPersistentGroupRemoved(const sdbus::ObjectPath& path) = 0;
    virtual void onWpsFailed(const std::string& name, const std::map<std::string, sdbus::Variant>& args) = 0;
    virtual void onInvitationReceived(const std::map<std::string, sdbus::Variant>& properties) = 0;

public:
    void Find(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("Find").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void StopFind()
    {
        proxy_.callMethod("StopFind").onInterface(INTERFACE_NAME);
    }

    void Listen(const int32_t& timeout)
    {
        proxy_.callMethod("Listen").onInterface(INTERFACE_NAME).withArguments(timeout);
    }

    void ExtendedListen(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("ExtendedListen").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void PresenceRequest(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("PresenceRequest").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void ProvisionDiscoveryRequest(const sdbus::ObjectPath& peer, const std::string& config_method)
    {
        proxy_.callMethod("ProvisionDiscoveryRequest").onInterface(INTERFACE_NAME).withArguments(peer, config_method);
    }

    std::string Connect(const std::map<std::string, sdbus::Variant>& args)
    {
        std::string result;
        proxy_.callMethod("Connect").onInterface(INTERFACE_NAME).withArguments(args).storeResultsTo(result);
        return result;
    }

    void GroupAdd(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("GroupAdd").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void Cancel()
    {
        proxy_.callMethod("Cancel").onInterface(INTERFACE_NAME);
    }

    void Invite(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("Invite").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void Disconnect()
    {
        proxy_.callMethod("Disconnect").onInterface(INTERFACE_NAME);
    }

    void RejectPeer(const sdbus::ObjectPath& peer)
    {
        proxy_.callMethod("RejectPeer").onInterface(INTERFACE_NAME).withArguments(peer);
    }

    void RemoveClient(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("RemoveClient").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void Flush()
    {
        proxy_.callMethod("Flush").onInterface(INTERFACE_NAME);
    }

    void AddService(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("AddService").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void DeleteService(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("DeleteService").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void FlushService()
    {
        proxy_.callMethod("FlushService").onInterface(INTERFACE_NAME);
    }

    uint64_t ServiceDiscoveryRequest(const std::map<std::string, sdbus::Variant>& args)
    {
        uint64_t result;
        proxy_.callMethod("ServiceDiscoveryRequest").onInterface(INTERFACE_NAME).withArguments(args).storeResultsTo(result);
        return result;
    }

    void ServiceDiscoveryResponse(const std::map<std::string, sdbus::Variant>& args)
    {
        proxy_.callMethod("ServiceDiscoveryResponse").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void ServiceDiscoveryCancelRequest(const uint64_t& args)
    {
        proxy_.callMethod("ServiceDiscoveryCancelRequest").onInterface(INTERFACE_NAME).withArguments(args);
    }

    void ServiceUpdate()
    {
        proxy_.callMethod("ServiceUpdate").onInterface(INTERFACE_NAME);
    }

    void ServiceDiscoveryExternal(const int32_t& arg)
    {
        proxy_.callMethod("ServiceDiscoveryExternal").onInterface(INTERFACE_NAME).withArguments(arg);
    }

    sdbus::ObjectPath AddPersistentGroup(const std::map<std::string, sdbus::Variant>& args)
    {
        sdbus::ObjectPath result;
        proxy_.callMethod("AddPersistentGroup").onInterface(INTERFACE_NAME).withArguments(args).storeResultsTo(result);
        return result;
    }

    void RemovePersistentGroup(const sdbus::ObjectPath& path)
    {
        proxy_.callMethod("RemovePersistentGroup").onInterface(INTERFACE_NAME).withArguments(path);
    }

    void RemoveAllPersistentGroups()
    {
        proxy_.callMethod("RemoveAllPersistentGroups").onInterface(INTERFACE_NAME);
    }

public:
    std::map<std::string, sdbus::Variant> P2PDeviceConfig()
    {
        return proxy_.getProperty("P2PDeviceConfig").onInterface(INTERFACE_NAME);
    }

    void P2PDeviceConfig(const std::map<std::string, sdbus::Variant>& value)
    {
        proxy_.setProperty("P2PDeviceConfig").onInterface(INTERFACE_NAME).toValue(value);
    }

    std::vector<sdbus::ObjectPath> Peers()
    {
        return proxy_.getProperty("Peers").onInterface(INTERFACE_NAME);
    }

    std::string Role()
    {
        return proxy_.getProperty("Role").onInterface(INTERFACE_NAME);
    }

    sdbus::ObjectPath Group()
    {
        return proxy_.getProperty("Group").onInterface(INTERFACE_NAME);
    }

    sdbus::ObjectPath PeerGO()
    {
        return proxy_.getProperty("PeerGO").onInterface(INTERFACE_NAME);
    }

    std::vector<sdbus::ObjectPath> PersistentGroups()
    {
        return proxy_.getProperty("PersistentGroups").onInterface(INTERFACE_NAME);
    }

private:
    sdbus::IProxy& proxy_;
};

}}}} // namespaces

namespace fi {
namespace w1 {
namespace wpa_supplicant1 {

class PersistentGroup_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "fi.w1.wpa_supplicant1.PersistentGroup";

protected:
    PersistentGroup_proxy(sdbus::IProxy& proxy)
        : proxy_(proxy)
    {
    }

    ~PersistentGroup_proxy() = default;

public:
    std::map<std::string, sdbus::Variant> Properties()
    {
        return proxy_.getProperty("Properties").onInterface(INTERFACE_NAME);
    }

    void Properties(const std::map<std::string, sdbus::Variant>& value)
    {
        proxy_.setProperty("Properties").onInterface(INTERFACE_NAME).toValue(value);
    }

private:
    sdbus::IProxy& proxy_;
};

}}} // namespaces

#endif