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

#ifndef __sdbuscpp___home_rerdavies_src_pipedal_src_dbus_bluez_proxy_h__proxy__H__
#define __sdbuscpp___home_rerdavies_src_pipedal_src_dbus_bluez_proxy_h__proxy__H__

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

namespace org {
namespace bluez {

class GattService1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.GattService1";

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

    ~GattService1_proxy() = default;

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

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

namespace org {
namespace bluez {

class GattCharacteristic1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.GattCharacteristic1";

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

    ~GattCharacteristic1_proxy() = default;

public:
    void WriteValue(const std::vector<uint8_t>& value)
    {
        proxy_.callMethod("WriteValue").onInterface(INTERFACE_NAME).withArguments(value);
    }

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

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

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

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

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

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

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

namespace org {
namespace bluez {

class GattDescriptor1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.GattDescriptor1";

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

    ~GattDescriptor1_proxy() = default;

public:
    std::vector<uint8_t> ReadValue()
    {
        std::vector<uint8_t> result;
        proxy_.callMethod("ReadValue").onInterface(INTERFACE_NAME).storeResultsTo(result);
        return result;
    }

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

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

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

namespace org {
namespace bluez {

class LEAdvertisement1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.LEAdvertisement1";

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

    ~LEAdvertisement1_proxy() = default;

public:
    void Release()
    {
        proxy_.callMethod("Release").onInterface(INTERFACE_NAME).dontExpectReply();
    }

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

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

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

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

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

namespace org {
namespace freedesktop {
namespace DBus {

class Introspectable_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.Introspectable";

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

    ~Introspectable_proxy() = default;

public:
    std::string Introspect()
    {
        std::string result;
        proxy_.callMethod("Introspect").onInterface(INTERFACE_NAME).storeResultsTo(result);
        return result;
    }

private:
    sdbus::IProxy& proxy_;
};

}}} // namespaces

namespace org {
namespace bluez {

class Adapter1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.Adapter1";

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

    ~Adapter1_proxy() = default;

public:
    void StartDiscovery()
    {
        proxy_.callMethod("StartDiscovery").onInterface(INTERFACE_NAME);
    }

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

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

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

    std::vector<std::string> GetDiscoveryFilters()
    {
        std::vector<std::string> result;
        proxy_.callMethod("GetDiscoveryFilters").onInterface(INTERFACE_NAME).storeResultsTo(result);
        return result;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

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)
    {
        proxy_.uponSignal("PropertiesChanged").onInterface(INTERFACE_NAME).call([this](const std::string& interface, const std::map<std::string, sdbus::Variant>& changed_properties, const std::vector<std::string>& invalidated_properties){ this->onPropertiesChanged(interface, changed_properties, invalidated_properties); });
    }

    ~Properties_proxy() = default;

    virtual void onPropertiesChanged(const std::string& interface, const std::map<std::string, sdbus::Variant>& changed_properties, const std::vector<std::string>& invalidated_properties) = 0;

public:
    sdbus::Variant Get(const std::string& interface, const std::string& name)
    {
        sdbus::Variant result;
        proxy_.callMethod("Get").onInterface(INTERFACE_NAME).withArguments(interface, name).storeResultsTo(result);
        return result;
    }

    void Set(const std::string& interface, const std::string& name, const sdbus::Variant& value)
    {
        proxy_.callMethod("Set").onInterface(INTERFACE_NAME).withArguments(interface, name, value);
    }

    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;
    }

private:
    sdbus::IProxy& proxy_;
};

}}} // namespaces

namespace org {
namespace bluez {

class GattManager1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.GattManager1";

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

    ~GattManager1_proxy() = default;

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

namespace org {
namespace bluez {

class LEAdvertisingManager1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.LEAdvertisingManager1";

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

    ~LEAdvertisingManager1_proxy() = default;

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

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

public:
    uint8_t ActiveInstances()
    {
        return proxy_.getProperty("ActiveInstances").onInterface(INTERFACE_NAME);
    }

    uint8_t SupportedInstances()
    {
        return proxy_.getProperty("SupportedInstances").onInterface(INTERFACE_NAME);
    }

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

namespace org {
namespace bluez {

class Media1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.Media1";

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

    ~Media1_proxy() = default;

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

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

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

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

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

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

namespace org {
namespace bluez {

class NetworkServer1_proxy
{
public:
    static constexpr const char* INTERFACE_NAME = "org.bluez.NetworkServer1";

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

    ~NetworkServer1_proxy() = default;

public:
    void Register(const std::string& uuid, const std::string& bridge)
    {
        proxy_.callMethod("Register").onInterface(INTERFACE_NAME).withArguments(uuid, bridge);
    }

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

private:
    sdbus::IProxy& proxy_;
};

}} // namespaces

#endif