cli-account.h

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

#ifndef IN_TELEPATHY_QT4_HEADER
#error IN_TELEPATHY_QT4_HEADER
#endif

#include <TelepathyQt4/Types>

#include <QtGlobal>

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

#include <QDBusPendingReply>

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

namespace Tp{
class PendingVariant;
class PendingOperation;
}

// FIXME: (API/ABI break) Remove definition of TELEPATHY_GNUC_DEPRECATED

// basically the same as GLib's G_GNUC_DEPRECATED
#ifndef TELEPATHY_GNUC_DEPRECATED
#   if defined(Q_CC_GNUC) && __GNUC__ >= 4
#       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
#   else
#       define TELEPATHY_GNUC_DEPRECATED
#   endif
#endif
namespace Tp
{
namespace Client
{

class TELEPATHY_QT4_EXPORT AccountInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Account";
    }

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

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

    AccountInterface(Tp::DBusProxy *proxy);

    Q_PROPERTY(QStringList Interfaces READ _deprecated_Interfaces)

    
    inline TELEPATHY_QT4_DEPRECATED QStringList Interfaces() const
    {
        return _deprecated_Interfaces();
    }

private:
    inline QStringList _deprecated_Interfaces() const
    {
        return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
    }
public:

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

    Q_PROPERTY(QString DisplayName READ _deprecated_DisplayName WRITE _deprecated_setDisplayName)

    
    inline TELEPATHY_QT4_DEPRECATED QString DisplayName() const
    {
        return _deprecated_DisplayName();
    }

private:
    inline QString _deprecated_DisplayName() const
    {
        return qvariant_cast<QString>(internalPropGet("DisplayName"));
    }
public:

    inline Tp::PendingVariant *requestPropertyDisplayName() const
    {
        return internalRequestProperty(QLatin1String("DisplayName"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setDisplayName(const QString& newValue)
    {
        return _deprecated_setDisplayName(newValue);
    }

private:
    inline void _deprecated_setDisplayName(const QString& newValue)
    {
        internalPropSet("DisplayName", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyDisplayName(QString newValue)
    {
        return internalSetProperty(QLatin1String("DisplayName"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(QString Icon READ _deprecated_Icon WRITE _deprecated_setIcon)

    
    inline TELEPATHY_QT4_DEPRECATED QString Icon() const
    {
        return _deprecated_Icon();
    }

private:
    inline QString _deprecated_Icon() const
    {
        return qvariant_cast<QString>(internalPropGet("Icon"));
    }
public:

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

    inline TELEPATHY_QT4_DEPRECATED void setIcon(const QString& newValue)
    {
        return _deprecated_setIcon(newValue);
    }

private:
    inline void _deprecated_setIcon(const QString& newValue)
    {
        internalPropSet("Icon", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyIcon(QString newValue)
    {
        return internalSetProperty(QLatin1String("Icon"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(bool Valid READ _deprecated_Valid)

    
    inline TELEPATHY_QT4_DEPRECATED bool Valid() const
    {
        return _deprecated_Valid();
    }

private:
    inline bool _deprecated_Valid() const
    {
        return qvariant_cast<bool>(internalPropGet("Valid"));
    }
public:

    inline Tp::PendingVariant *requestPropertyValid() const
    {
        return internalRequestProperty(QLatin1String("Valid"));
    }

    Q_PROPERTY(bool Enabled READ _deprecated_Enabled WRITE _deprecated_setEnabled)

    
    inline TELEPATHY_QT4_DEPRECATED bool Enabled() const
    {
        return _deprecated_Enabled();
    }

private:
    inline bool _deprecated_Enabled() const
    {
        return qvariant_cast<bool>(internalPropGet("Enabled"));
    }
public:

    inline Tp::PendingVariant *requestPropertyEnabled() const
    {
        return internalRequestProperty(QLatin1String("Enabled"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setEnabled(bool newValue)
    {
        return _deprecated_setEnabled(newValue);
    }

private:
    inline void _deprecated_setEnabled(bool newValue)
    {
        internalPropSet("Enabled", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyEnabled(bool newValue)
    {
        return internalSetProperty(QLatin1String("Enabled"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(QString Nickname READ _deprecated_Nickname WRITE _deprecated_setNickname)

    
    inline TELEPATHY_QT4_DEPRECATED QString Nickname() const
    {
        return _deprecated_Nickname();
    }

private:
    inline QString _deprecated_Nickname() const
    {
        return qvariant_cast<QString>(internalPropGet("Nickname"));
    }
public:

    inline Tp::PendingVariant *requestPropertyNickname() const
    {
        return internalRequestProperty(QLatin1String("Nickname"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setNickname(const QString& newValue)
    {
        return _deprecated_setNickname(newValue);
    }

private:
    inline void _deprecated_setNickname(const QString& newValue)
    {
        internalPropSet("Nickname", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyNickname(QString newValue)
    {
        return internalSetProperty(QLatin1String("Nickname"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(QString Service READ _deprecated_Service WRITE _deprecated_setService)

    
    inline TELEPATHY_QT4_DEPRECATED QString Service() const
    {
        return _deprecated_Service();
    }

private:
    inline QString _deprecated_Service() const
    {
        return qvariant_cast<QString>(internalPropGet("Service"));
    }
public:

    inline Tp::PendingVariant *requestPropertyService() const
    {
        return internalRequestProperty(QLatin1String("Service"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setService(const QString& newValue)
    {
        return _deprecated_setService(newValue);
    }

private:
    inline void _deprecated_setService(const QString& newValue)
    {
        internalPropSet("Service", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyService(QString newValue)
    {
        return internalSetProperty(QLatin1String("Service"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(QVariantMap Parameters READ _deprecated_Parameters)

    
    inline TELEPATHY_QT4_DEPRECATED QVariantMap Parameters() const
    {
        return _deprecated_Parameters();
    }

private:
    inline QVariantMap _deprecated_Parameters() const
    {
        return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
    }
public:

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

    Q_PROPERTY(Tp::SimplePresence AutomaticPresence READ _deprecated_AutomaticPresence WRITE _deprecated_setAutomaticPresence)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::SimplePresence AutomaticPresence() const
    {
        return _deprecated_AutomaticPresence();
    }

private:
    inline Tp::SimplePresence _deprecated_AutomaticPresence() const
    {
        return qvariant_cast<Tp::SimplePresence>(internalPropGet("AutomaticPresence"));
    }
public:

    inline Tp::PendingVariant *requestPropertyAutomaticPresence() const
    {
        return internalRequestProperty(QLatin1String("AutomaticPresence"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setAutomaticPresence(const Tp::SimplePresence& newValue)
    {
        return _deprecated_setAutomaticPresence(newValue);
    }

private:
    inline void _deprecated_setAutomaticPresence(const Tp::SimplePresence& newValue)
    {
        internalPropSet("AutomaticPresence", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyAutomaticPresence(Tp::SimplePresence newValue)
    {
        return internalSetProperty(QLatin1String("AutomaticPresence"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(bool ConnectAutomatically READ _deprecated_ConnectAutomatically WRITE _deprecated_setConnectAutomatically)

    
    inline TELEPATHY_QT4_DEPRECATED bool ConnectAutomatically() const
    {
        return _deprecated_ConnectAutomatically();
    }

private:
    inline bool _deprecated_ConnectAutomatically() const
    {
        return qvariant_cast<bool>(internalPropGet("ConnectAutomatically"));
    }
public:

    inline Tp::PendingVariant *requestPropertyConnectAutomatically() const
    {
        return internalRequestProperty(QLatin1String("ConnectAutomatically"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setConnectAutomatically(bool newValue)
    {
        return _deprecated_setConnectAutomatically(newValue);
    }

private:
    inline void _deprecated_setConnectAutomatically(bool newValue)
    {
        internalPropSet("ConnectAutomatically", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyConnectAutomatically(bool newValue)
    {
        return internalSetProperty(QLatin1String("ConnectAutomatically"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(QDBusObjectPath Connection READ _deprecated_Connection)

    
    inline TELEPATHY_QT4_DEPRECATED QDBusObjectPath Connection() const
    {
        return _deprecated_Connection();
    }

private:
    inline QDBusObjectPath _deprecated_Connection() const
    {
        return qvariant_cast<QDBusObjectPath>(internalPropGet("Connection"));
    }
public:

    inline Tp::PendingVariant *requestPropertyConnection() const
    {
        return internalRequestProperty(QLatin1String("Connection"));
    }

    Q_PROPERTY(uint ConnectionStatus READ _deprecated_ConnectionStatus)

    
    inline TELEPATHY_QT4_DEPRECATED uint ConnectionStatus() const
    {
        return _deprecated_ConnectionStatus();
    }

private:
    inline uint _deprecated_ConnectionStatus() const
    {
        return qvariant_cast<uint>(internalPropGet("ConnectionStatus"));
    }
public:

    inline Tp::PendingVariant *requestPropertyConnectionStatus() const
    {
        return internalRequestProperty(QLatin1String("ConnectionStatus"));
    }

    Q_PROPERTY(uint ConnectionStatusReason READ _deprecated_ConnectionStatusReason)

    
    inline TELEPATHY_QT4_DEPRECATED uint ConnectionStatusReason() const
    {
        return _deprecated_ConnectionStatusReason();
    }

private:
    inline uint _deprecated_ConnectionStatusReason() const
    {
        return qvariant_cast<uint>(internalPropGet("ConnectionStatusReason"));
    }
public:

    inline Tp::PendingVariant *requestPropertyConnectionStatusReason() const
    {
        return internalRequestProperty(QLatin1String("ConnectionStatusReason"));
    }

    Q_PROPERTY(QString ConnectionError READ _deprecated_ConnectionError)

    
    inline TELEPATHY_QT4_DEPRECATED QString ConnectionError() const
    {
        return _deprecated_ConnectionError();
    }

private:
    inline QString _deprecated_ConnectionError() const
    {
        return qvariant_cast<QString>(internalPropGet("ConnectionError"));
    }
public:

    inline Tp::PendingVariant *requestPropertyConnectionError() const
    {
        return internalRequestProperty(QLatin1String("ConnectionError"));
    }

    Q_PROPERTY(QVariantMap ConnectionErrorDetails READ _deprecated_ConnectionErrorDetails)

    
    inline TELEPATHY_QT4_DEPRECATED QVariantMap ConnectionErrorDetails() const
    {
        return _deprecated_ConnectionErrorDetails();
    }

private:
    inline QVariantMap _deprecated_ConnectionErrorDetails() const
    {
        return qvariant_cast<QVariantMap>(internalPropGet("ConnectionErrorDetails"));
    }
public:

    inline Tp::PendingVariant *requestPropertyConnectionErrorDetails() const
    {
        return internalRequestProperty(QLatin1String("ConnectionErrorDetails"));
    }

    Q_PROPERTY(Tp::SimplePresence CurrentPresence READ _deprecated_CurrentPresence)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::SimplePresence CurrentPresence() const
    {
        return _deprecated_CurrentPresence();
    }

private:
    inline Tp::SimplePresence _deprecated_CurrentPresence() const
    {
        return qvariant_cast<Tp::SimplePresence>(internalPropGet("CurrentPresence"));
    }
public:

    inline Tp::PendingVariant *requestPropertyCurrentPresence() const
    {
        return internalRequestProperty(QLatin1String("CurrentPresence"));
    }

    Q_PROPERTY(Tp::SimplePresence RequestedPresence READ _deprecated_RequestedPresence WRITE _deprecated_setRequestedPresence)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::SimplePresence RequestedPresence() const
    {
        return _deprecated_RequestedPresence();
    }

private:
    inline Tp::SimplePresence _deprecated_RequestedPresence() const
    {
        return qvariant_cast<Tp::SimplePresence>(internalPropGet("RequestedPresence"));
    }
public:

    inline Tp::PendingVariant *requestPropertyRequestedPresence() const
    {
        return internalRequestProperty(QLatin1String("RequestedPresence"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setRequestedPresence(const Tp::SimplePresence& newValue)
    {
        return _deprecated_setRequestedPresence(newValue);
    }

private:
    inline void _deprecated_setRequestedPresence(const Tp::SimplePresence& newValue)
    {
        internalPropSet("RequestedPresence", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyRequestedPresence(Tp::SimplePresence newValue)
    {
        return internalSetProperty(QLatin1String("RequestedPresence"), QVariant::fromValue(newValue));
    }

    Q_PROPERTY(bool ChangingPresence READ _deprecated_ChangingPresence)

    
    inline TELEPATHY_QT4_DEPRECATED bool ChangingPresence() const
    {
        return _deprecated_ChangingPresence();
    }

private:
    inline bool _deprecated_ChangingPresence() const
    {
        return qvariant_cast<bool>(internalPropGet("ChangingPresence"));
    }
public:

    inline Tp::PendingVariant *requestPropertyChangingPresence() const
    {
        return internalRequestProperty(QLatin1String("ChangingPresence"));
    }

    Q_PROPERTY(QString NormalizedName READ _deprecated_NormalizedName)

    
    inline TELEPATHY_QT4_DEPRECATED QString NormalizedName() const
    {
        return _deprecated_NormalizedName();
    }

private:
    inline QString _deprecated_NormalizedName() const
    {
        return qvariant_cast<QString>(internalPropGet("NormalizedName"));
    }
public:

    inline Tp::PendingVariant *requestPropertyNormalizedName() const
    {
        return internalRequestProperty(QLatin1String("NormalizedName"));
    }

    Q_PROPERTY(bool HasBeenOnline READ _deprecated_HasBeenOnline)

    
    inline TELEPATHY_QT4_DEPRECATED bool HasBeenOnline() const
    {
        return _deprecated_HasBeenOnline();
    }

private:
    inline bool _deprecated_HasBeenOnline() const
    {
        return qvariant_cast<bool>(internalPropGet("HasBeenOnline"));
    }
public:

    inline Tp::PendingVariant *requestPropertyHasBeenOnline() const
    {
        return internalRequestProperty(QLatin1String("HasBeenOnline"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> Remove()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        return asyncCall(QLatin1String("Remove"));
    }

    inline QDBusPendingReply<QStringList> UpdateParameters(const QVariantMap& set, const QStringList& unset)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(set) << QVariant::fromValue(unset);
        return asyncCallWithArgumentList(QLatin1String("UpdateParameters"), argumentList);
    }

    inline QDBusPendingReply<> Reconnect()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        return asyncCall(QLatin1String("Reconnect"));
    }

Q_SIGNALS:
    void Removed();

    void AccountPropertyChanged(const QVariantMap& properties);

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

class TELEPATHY_QT4_EXPORT AccountInterfaceAvatarInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Account.Interface.Avatar";
    }

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

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

    AccountInterfaceAvatarInterface(Tp::DBusProxy *proxy);

    explicit AccountInterfaceAvatarInterface(const Tp::Client::AccountInterface& mainInterface);

    AccountInterfaceAvatarInterface(const Tp::Client::AccountInterface& mainInterface, QObject* parent);

    Q_PROPERTY(Tp::Avatar Avatar READ _deprecated_Avatar WRITE _deprecated_setAvatar)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::Avatar Avatar() const
    {
        return _deprecated_Avatar();
    }

private:
    inline Tp::Avatar _deprecated_Avatar() const
    {
        return qvariant_cast<Tp::Avatar>(internalPropGet("Avatar"));
    }
public:

    inline Tp::PendingVariant *requestPropertyAvatar() const
    {
        return internalRequestProperty(QLatin1String("Avatar"));
    }

    inline TELEPATHY_QT4_DEPRECATED void setAvatar(const Tp::Avatar& newValue)
    {
        return _deprecated_setAvatar(newValue);
    }

private:
    inline void _deprecated_setAvatar(const Tp::Avatar& newValue)
    {
        internalPropSet("Avatar", QVariant::fromValue(newValue));
    }
public:

    inline Tp::PendingOperation *setPropertyAvatar(Tp::Avatar newValue)
    {
        return internalSetProperty(QLatin1String("Avatar"), QVariant::fromValue(newValue));
    }

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

Q_SIGNALS:
    void AvatarChanged();

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