cli-connection-manager.h

/*
 * This file contains D-Bus client proxy classes generated by qt-client-gen.py.
 *
 * This file can be distributed under the same terms as the specification from
 * which it was generated.
 */

#ifndef IN_TP_QT_HEADER
#error IN_TP_QT_HEADER
#endif

#include <TelepathyQt/Types>

#include <QtGlobal>

#include <QString>
#include <QObject>
#include <QVariant>

#include <QDBusPendingReply>

#include <TelepathyQt/AbstractInterface>
#include <TelepathyQt/DBusProxy>
#include <TelepathyQt/Global>

namespace Tp
{
class PendingVariant;
class PendingOperation;
}

namespace Tp
{
namespace Client
{

class TP_QT_EXPORT ConnectionManagerInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.ConnectionManager");
    }

    ConnectionManagerInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ConnectionManagerInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ConnectionManagerInterface(Tp::DBusProxy *proxy);

    inline Tp::PendingVariant *requestPropertyProtocols() const
    {
        return internalRequestProperty(QLatin1String("Protocols"));
    }

    inline Tp::PendingVariant *requestPropertyInterfaces() const
    {
        return internalRequestProperty(QLatin1String("Interfaces"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    inline QDBusPendingReply<Tp::ParamSpecList> GetParameters(const QString& protocol, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ParamSpecList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("GetParameters"));
        callMessage << QVariant::fromValue(protocol);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<QStringList> ListProtocols(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("ListProtocols"));
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<QString, QDBusObjectPath> RequestConnection(const QString& protocol, const QVariantMap& parameters, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString, QDBusObjectPath>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("RequestConnection"));
        callMessage << QVariant::fromValue(protocol) << QVariant::fromValue(parameters);
        return this->connection().asyncCall(callMessage, timeout);
    }

Q_SIGNALS:
    void NewConnection(const QString& busName, const QDBusObjectPath& objectPath, const QString& protocol);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT ProtocolInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Protocol");
    }

    ProtocolInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterface(Tp::DBusProxy *proxy);

    explicit ProtocolInterface(const Tp::Client::ConnectionManagerInterface& mainInterface);

    ProtocolInterface(const Tp::Client::ConnectionManagerInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyInterfaces() const
    {
        return internalRequestProperty(QLatin1String("Interfaces"));
    }

    inline Tp::PendingVariant *requestPropertyParameters() const
    {
        return internalRequestProperty(QLatin1String("Parameters"));
    }

    inline Tp::PendingVariant *requestPropertyConnectionInterfaces() const
    {
        return internalRequestProperty(QLatin1String("ConnectionInterfaces"));
    }

    inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
    {
        return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
    }

    inline Tp::PendingVariant *requestPropertyVCardField() const
    {
        return internalRequestProperty(QLatin1String("VCardField"));
    }

    inline Tp::PendingVariant *requestPropertyEnglishName() const
    {
        return internalRequestProperty(QLatin1String("EnglishName"));
    }

    inline Tp::PendingVariant *requestPropertyIcon() const
    {
        return internalRequestProperty(QLatin1String("Icon"));
    }

    inline Tp::PendingVariant *requestPropertyAuthenticationTypes() const
    {
        return internalRequestProperty(QLatin1String("AuthenticationTypes"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    inline QDBusPendingReply<QString> IdentifyAccount(const QVariantMap& parameters, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("IdentifyAccount"));
        callMessage << QVariant::fromValue(parameters);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<QString> NormalizeContact(const QString& contactID, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("NormalizeContact"));
        callMessage << QVariant::fromValue(contactID);
        return this->connection().asyncCall(callMessage, timeout);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT ProtocolInterfaceAddressingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Protocol.Interface.Addressing");
    }

    ProtocolInterfaceAddressingInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterfaceAddressingInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterfaceAddressingInterface(Tp::DBusProxy *proxy);

    explicit ProtocolInterfaceAddressingInterface(const Tp::Client::ConnectionManagerInterface& mainInterface);

    ProtocolInterfaceAddressingInterface(const Tp::Client::ConnectionManagerInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyAddressableVCardFields() const
    {
        return internalRequestProperty(QLatin1String("AddressableVCardFields"));
    }

    inline Tp::PendingVariant *requestPropertyAddressableURISchemes() const
    {
        return internalRequestProperty(QLatin1String("AddressableURISchemes"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    inline QDBusPendingReply<QString> NormalizeVCardAddress(const QString& VCardField, const QString& VCardAddress, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("NormalizeVCardAddress"));
        callMessage << QVariant::fromValue(VCardField) << QVariant::fromValue(VCardAddress);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<QString> NormalizeContactURI(const QString& URI, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("NormalizeContactURI"));
        callMessage << QVariant::fromValue(URI);
        return this->connection().asyncCall(callMessage, timeout);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT ProtocolInterfaceAvatarsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Protocol.Interface.Avatars");
    }

    ProtocolInterfaceAvatarsInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterfaceAvatarsInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterfaceAvatarsInterface(Tp::DBusProxy *proxy);

    explicit ProtocolInterfaceAvatarsInterface(const Tp::Client::ConnectionManagerInterface& mainInterface);

    ProtocolInterfaceAvatarsInterface(const Tp::Client::ConnectionManagerInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
    {
        return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
    }

    inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
    {
        return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
    }

    inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
    {
        return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
    }

    inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
    {
        return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
    }

    inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
    {
        return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
    }

    inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
    {
        return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
    }

    inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
    {
        return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
    }

    inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
    {
        return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TP_QT_EXPORT ProtocolInterfacePresenceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Protocol.Interface.Presence");
    }

    ProtocolInterfacePresenceInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterfacePresenceInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ProtocolInterfacePresenceInterface(Tp::DBusProxy *proxy);

    explicit ProtocolInterfacePresenceInterface(const Tp::Client::ConnectionManagerInterface& mainInterface);

    ProtocolInterfacePresenceInterface(const Tp::Client::ConnectionManagerInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyStatuses() const
    {
        return internalRequestProperty(QLatin1String("Statuses"));
    }

    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}
Q_DECLARE_METATYPE(Tp::Client::ConnectionManagerInterface*)
Q_DECLARE_METATYPE(Tp::Client::ProtocolInterface*)
Q_DECLARE_METATYPE(Tp::Client::ProtocolInterfaceAddressingInterface*)
Q_DECLARE_METATYPE(Tp::Client::ProtocolInterfaceAvatarsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ProtocolInterfacePresenceInterface*)