cli-connection.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;
}

namespace Tp
{
namespace Client
{

class TELEPATHY_QT4_EXPORT ConnectionInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterface(Tp::DBusProxy *proxy);

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

    inline Tp::PendingVariant *requestPropertySelfHandle() const
    {
        return internalRequestProperty(QLatin1String("SelfHandle"));
    }

    inline Tp::PendingVariant *requestPropertyStatus() const
    {
        return internalRequestProperty(QLatin1String("Status"));
    }

    inline Tp::PendingVariant *requestPropertyHasImmortalHandles() const
    {
        return internalRequestProperty(QLatin1String("HasImmortalHandles"));
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

    inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("RequestChannel"));
        callMessage << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
        return this->connection().asyncCall(callMessage, timeout);
    }

    inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

Q_SIGNALS:
    void SelfHandleChanged(uint selfHandle);

    void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);

    void ConnectionError(const QString& error, const QVariantMap& details);

    void StatusChanged(uint status, uint reason);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

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

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

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

    inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void AliasesChanged(const Tp::AliasPairList& aliases);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
    {
        return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
    }

    inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
    {
        return internalRequestProperty(QLatin1String("AnonymityMandatory"));
    }

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

    inline Tp::PendingVariant *requestPropertyAnonymityModes() const
    {
        return internalRequestProperty(QLatin1String("AnonymityModes"));
    }

    inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
    {
        return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
    }

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

Q_SIGNALS:
    void AnonymityModesChanged(uint modes);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& 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();
    }

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

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

    inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

Q_SIGNALS:
    void AvatarUpdated(uint contact, const QString& newAvatarToken);

    void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyAccountBalance() const
    {
        return internalRequestProperty(QLatin1String("AccountBalance"));
    }

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

Q_SIGNALS:
    void BalanceChanged(const Tp::CurrencyAmount& balance);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

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

public Q_SLOTS:
    inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
    {
        return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
    }

    inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
    {
        return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
    }

    inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
    {
        return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
    }

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

    inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
    {
        return internalRequestProperty(QLatin1String("MessageServiceCentre"));
    }

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

    inline Tp::PendingVariant *requestPropertyIMSI() const
    {
        return internalRequestProperty(QLatin1String("IMSI"));
    }

    inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
    {
        return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
    }

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

    inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
    {
        return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
    }

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

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

Q_SIGNALS:
    void IMSIChanged(const QString& IMSI);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

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

public Q_SLOTS:
    inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

Q_SIGNALS:
    void ClientTypesUpdated(uint contact, const QStringList& clientTypes);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
    {
        return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

Q_SIGNALS:
    void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

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

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

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

    inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyDisjointGroups() const
    {
        return internalRequestProperty(QLatin1String("DisjointGroups"));
    }

    inline Tp::PendingVariant *requestPropertyGroupStorage() const
    {
        return internalRequestProperty(QLatin1String("GroupStorage"));
    }

    inline Tp::PendingVariant *requestPropertyGroups() const
    {
        return internalRequestProperty(QLatin1String("Groups"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

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

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

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

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

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

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

Q_SIGNALS:
    void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);

    void GroupsCreated(const QStringList& names);

    void GroupRenamed(const QString& oldName, const QString& newName);

    void GroupsRemoved(const QStringList& names);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
    {
        return internalRequestProperty(QLatin1String("ContactInfoFlags"));
    }

    inline Tp::PendingVariant *requestPropertySupportedFields() const
    {
        return internalRequestProperty(QLatin1String("SupportedFields"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyContactListState() const
    {
        return internalRequestProperty(QLatin1String("ContactListState"));
    }

    inline Tp::PendingVariant *requestPropertyContactListPersists() const
    {
        return internalRequestProperty(QLatin1String("ContactListPersists"));
    }

    inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
    {
        return internalRequestProperty(QLatin1String("CanChangeContactList"));
    }

    inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
    {
        return internalRequestProperty(QLatin1String("RequestUsesMessage"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

    inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void ContactListStateChanged(uint contactListState);

    void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);

    void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
    {
        return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
    {
        return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
    }

    inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
    {
        return internalRequestProperty(QLatin1String("LocationAccessControl"));
    }

    inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
    {
        return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
    }

    inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
    {
        return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

Q_SIGNALS:
    void LocationUpdated(uint contact, const QVariantMap& location);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
    {
        return internalRequestProperty(QLatin1String("MailNotificationFlags"));
    }

    inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
    {
        return internalRequestProperty(QLatin1String("UnreadMailCount"));
    }

    inline Tp::PendingVariant *requestPropertyUnreadMails() const
    {
        return internalRequestProperty(QLatin1String("UnreadMails"));
    }

    inline Tp::PendingVariant *requestPropertyMailAddress() const
    {
        return internalRequestProperty(QLatin1String("MailAddress"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void MailsReceived(const Tp::MailList& mails);

    void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
    {
        return internalRequestProperty(QLatin1String("PowerSavingActive"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void PowerSavingChanged(bool active);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

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

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

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

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

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

    inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

    inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

    inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void PresenceUpdate(const Tp::ContactPresences& presence);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyChannels() const
    {
        return internalRequestProperty(QLatin1String("Channels"));
    }

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

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

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

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

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

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

Q_SIGNALS:
    void NewChannels(const Tp::ChannelDetailsList& channels);

    void ChannelClosed(const QDBusObjectPath& removed);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
    {
        return internalRequestProperty(QLatin1String("KnownServicePoints"));
    }

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

Q_SIGNALS:
    void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);

    explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);

    ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

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

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

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

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

    inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    void PresencesChanged(const Tp::SimpleContactPresences& presence);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)