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

// 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 ConnectionInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "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);

    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(uint SelfHandle READ _deprecated_SelfHandle)

    
    inline TELEPATHY_QT4_DEPRECATED uint SelfHandle() const
    {
        return _deprecated_SelfHandle();
    }

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

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

    Q_PROPERTY(uint Status READ _deprecated_Status)

    
    inline TELEPATHY_QT4_DEPRECATED uint Status() const
    {
        return _deprecated_Status();
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
        return asyncCallWithArgumentList(QLatin1String("HoldHandles"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
        return asyncCallWithArgumentList(QLatin1String("InspectHandles"), argumentList);
    }

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

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
        return asyncCallWithArgumentList(QLatin1String("ReleaseHandles"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
        return asyncCallWithArgumentList(QLatin1String("RequestChannel"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
        return asyncCallWithArgumentList(QLatin1String("RequestHandles"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(aliases);
        return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(uint SupportedAnonymityModes READ _deprecated_SupportedAnonymityModes)

    
    inline TELEPATHY_QT4_DEPRECATED uint SupportedAnonymityModes() const
    {
        return _deprecated_SupportedAnonymityModes();
    }

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

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

    Q_PROPERTY(bool AnonymityMandatory READ _deprecated_AnonymityMandatory WRITE _deprecated_setAnonymityMandatory)

    
    inline TELEPATHY_QT4_DEPRECATED bool AnonymityMandatory() const
    {
        return _deprecated_AnonymityMandatory();
    }

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

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

    inline TELEPATHY_QT4_DEPRECATED void setAnonymityMandatory(bool newValue)
    {
        return _deprecated_setAnonymityMandatory(newValue);
    }

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

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

    Q_PROPERTY(uint AnonymityModes READ _deprecated_AnonymityModes WRITE _deprecated_setAnonymityModes)

    
    inline TELEPATHY_QT4_DEPRECATED uint AnonymityModes() const
    {
        return _deprecated_AnonymityModes();
    }

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

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

    inline TELEPATHY_QT4_DEPRECATED void setAnonymityModes(uint newValue)
    {
        return _deprecated_setAnonymityModes(newValue);
    }

private:
    inline void _deprecated_setAnonymityModes(uint newValue)
    {
        internalPropSet("AnonymityModes", QVariant::fromValue(newValue));
    }
public:

    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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ _deprecated_SupportedAvatarMIMETypes)

    
    inline TELEPATHY_QT4_DEPRECATED QStringList SupportedAvatarMIMETypes() const
    {
        return _deprecated_SupportedAvatarMIMETypes();
    }

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

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

    Q_PROPERTY(uint MinimumAvatarHeight READ _deprecated_MinimumAvatarHeight)

    
    inline TELEPATHY_QT4_DEPRECATED uint MinimumAvatarHeight() const
    {
        return _deprecated_MinimumAvatarHeight();
    }

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

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

    Q_PROPERTY(uint MinimumAvatarWidth READ _deprecated_MinimumAvatarWidth)

    
    inline TELEPATHY_QT4_DEPRECATED uint MinimumAvatarWidth() const
    {
        return _deprecated_MinimumAvatarWidth();
    }

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

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

    Q_PROPERTY(uint RecommendedAvatarHeight READ _deprecated_RecommendedAvatarHeight)

    
    inline TELEPATHY_QT4_DEPRECATED uint RecommendedAvatarHeight() const
    {
        return _deprecated_RecommendedAvatarHeight();
    }

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

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

    Q_PROPERTY(uint RecommendedAvatarWidth READ _deprecated_RecommendedAvatarWidth)

    
    inline TELEPATHY_QT4_DEPRECATED uint RecommendedAvatarWidth() const
    {
        return _deprecated_RecommendedAvatarWidth();
    }

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

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

    Q_PROPERTY(uint MaximumAvatarHeight READ _deprecated_MaximumAvatarHeight)

    
    inline TELEPATHY_QT4_DEPRECATED uint MaximumAvatarHeight() const
    {
        return _deprecated_MaximumAvatarHeight();
    }

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

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

    Q_PROPERTY(uint MaximumAvatarWidth READ _deprecated_MaximumAvatarWidth)

    
    inline TELEPATHY_QT4_DEPRECATED uint MaximumAvatarWidth() const
    {
        return _deprecated_MaximumAvatarWidth();
    }

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

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

    Q_PROPERTY(uint MaximumAvatarBytes READ _deprecated_MaximumAvatarBytes)

    
    inline TELEPATHY_QT4_DEPRECATED uint MaximumAvatarBytes() const
    {
        return _deprecated_MaximumAvatarBytes();
    }

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

    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()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contact);
        return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
        return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
    }

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

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

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(Tp::CurrencyAmount AccountBalance READ _deprecated_AccountBalance)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::CurrencyAmount AccountBalance() const
    {
        return _deprecated_AccountBalance();
    }

private:
    inline Tp::CurrencyAmount _deprecated_AccountBalance() const
    {
        return qvariant_cast<Tp::CurrencyAmount>(internalPropGet("AccountBalance"));
    }
public:

    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 const char *staticInterfaceName()
    {
        return "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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
        return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handles);
        return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(uint MessageValidityPeriod READ _deprecated_MessageValidityPeriod WRITE _deprecated_setMessageValidityPeriod)

    
    inline TELEPATHY_QT4_DEPRECATED uint MessageValidityPeriod() const
    {
        return _deprecated_MessageValidityPeriod();
    }

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

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

    inline TELEPATHY_QT4_DEPRECATED void setMessageValidityPeriod(uint newValue)
    {
        return _deprecated_setMessageValidityPeriod(newValue);
    }

private:
    inline void _deprecated_setMessageValidityPeriod(uint newValue)
    {
        internalPropSet("MessageValidityPeriod", QVariant::fromValue(newValue));
    }
public:

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

    Q_PROPERTY(bool OverrideMessageServiceCentre READ _deprecated_OverrideMessageServiceCentre WRITE _deprecated_setOverrideMessageServiceCentre)

    
    inline TELEPATHY_QT4_DEPRECATED bool OverrideMessageServiceCentre() const
    {
        return _deprecated_OverrideMessageServiceCentre();
    }

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

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

    inline TELEPATHY_QT4_DEPRECATED void setOverrideMessageServiceCentre(bool newValue)
    {
        return _deprecated_setOverrideMessageServiceCentre(newValue);
    }

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

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

    Q_PROPERTY(QString MessageServiceCentre READ _deprecated_MessageServiceCentre WRITE _deprecated_setMessageServiceCentre)

    
    inline TELEPATHY_QT4_DEPRECATED QString MessageServiceCentre() const
    {
        return _deprecated_MessageServiceCentre();
    }

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

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

    inline TELEPATHY_QT4_DEPRECATED void setMessageServiceCentre(const QString& newValue)
    {
        return _deprecated_setMessageServiceCentre(newValue);
    }

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

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

    Q_PROPERTY(QString IMSI READ _deprecated_IMSI)

    
    inline TELEPATHY_QT4_DEPRECATED QString IMSI() const
    {
        return _deprecated_IMSI();
    }

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

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

    Q_PROPERTY(bool MessageReducedCharacterSet READ _deprecated_MessageReducedCharacterSet WRITE _deprecated_setMessageReducedCharacterSet)

    
    inline TELEPATHY_QT4_DEPRECATED bool MessageReducedCharacterSet() const
    {
        return _deprecated_MessageReducedCharacterSet();
    }

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

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

    inline TELEPATHY_QT4_DEPRECATED void setMessageReducedCharacterSet(bool newValue)
    {
        return _deprecated_setMessageReducedCharacterSet(newValue);
    }

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

    inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
    {
        return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), 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 const char *staticInterfaceName()
    {
        return "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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetClientTypes"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contact);
        return asyncCallWithArgumentList(QLatin1String("RequestClientTypes"), argumentList);
    }

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

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handlerCapabilities);
        return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handles);
        return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(bool DisjointGroups READ _deprecated_DisjointGroups)

    
    inline TELEPATHY_QT4_DEPRECATED bool DisjointGroups() const
    {
        return _deprecated_DisjointGroups();
    }

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

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

    Q_PROPERTY(uint GroupStorage READ _deprecated_GroupStorage)

    
    inline TELEPATHY_QT4_DEPRECATED uint GroupStorage() const
    {
        return _deprecated_GroupStorage();
    }

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

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

    Q_PROPERTY(QStringList Groups READ _deprecated_Groups)

    
    inline TELEPATHY_QT4_DEPRECATED QStringList Groups() const
    {
        return _deprecated_Groups();
    }

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

    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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contact) << QVariant::fromValue(groups);
        return asyncCallWithArgumentList(QLatin1String("SetContactGroups"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(group) << QVariant::fromValue(members);
        return asyncCallWithArgumentList(QLatin1String("SetGroupMembers"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(group) << QVariant::fromValue(members);
        return asyncCallWithArgumentList(QLatin1String("AddToGroup"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(group) << QVariant::fromValue(members);
        return asyncCallWithArgumentList(QLatin1String("RemoveFromGroup"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(group);
        return asyncCallWithArgumentList(QLatin1String("RemoveGroup"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
        return asyncCallWithArgumentList(QLatin1String("RenameGroup"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(uint ContactInfoFlags READ _deprecated_ContactInfoFlags)

    
    inline TELEPATHY_QT4_DEPRECATED uint ContactInfoFlags() const
    {
        return _deprecated_ContactInfoFlags();
    }

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

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

    Q_PROPERTY(Tp::FieldSpecs SupportedFields READ _deprecated_SupportedFields)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::FieldSpecs SupportedFields() const
    {
        return _deprecated_SupportedFields();
    }

private:
    inline Tp::FieldSpecs _deprecated_SupportedFields() const
    {
        return qvariant_cast<Tp::FieldSpecs>(internalPropGet("SupportedFields"));
    }
public:

    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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetContactInfo"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("RefreshContactInfo"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contact);
        return asyncCallWithArgumentList(QLatin1String("RequestContactInfo"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contactInfo);
        return asyncCallWithArgumentList(QLatin1String("SetContactInfo"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(uint ContactListState READ _deprecated_ContactListState)

    
    inline TELEPATHY_QT4_DEPRECATED uint ContactListState() const
    {
        return _deprecated_ContactListState();
    }

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

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

    Q_PROPERTY(bool ContactListPersists READ _deprecated_ContactListPersists)

    
    inline TELEPATHY_QT4_DEPRECATED bool ContactListPersists() const
    {
        return _deprecated_ContactListPersists();
    }

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

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

    Q_PROPERTY(bool CanChangeContactList READ _deprecated_CanChangeContactList)

    
    inline TELEPATHY_QT4_DEPRECATED bool CanChangeContactList() const
    {
        return _deprecated_CanChangeContactList();
    }

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

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

    Q_PROPERTY(bool RequestUsesMessage READ _deprecated_RequestUsesMessage)

    
    inline TELEPATHY_QT4_DEPRECATED bool RequestUsesMessage() const
    {
        return _deprecated_RequestUsesMessage();
    }

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

    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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
        return asyncCallWithArgumentList(QLatin1String("GetContactListAttributes"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
        return asyncCallWithArgumentList(QLatin1String("RequestSubscription"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("AuthorizePublication"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("RemoveContacts"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("Unsubscribe"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("Unpublish"), argumentList);
    }

Q_SIGNALS:
    void ContactListStateChanged(uint contactListState);

    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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(QStringList ContactAttributeInterfaces READ _deprecated_ContactAttributeInterfaces)

    
    inline TELEPATHY_QT4_DEPRECATED QStringList ContactAttributeInterfaces() const
    {
        return _deprecated_ContactAttributeInterfaces();
    }

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

    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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
        return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
    }

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

class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ _deprecated_LocationAccessControlTypes)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::UIntList LocationAccessControlTypes() const
    {
        return _deprecated_LocationAccessControlTypes();
    }

private:
    inline Tp::UIntList _deprecated_LocationAccessControlTypes() const
    {
        return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
    }
public:

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

    Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ _deprecated_LocationAccessControl WRITE _deprecated_setLocationAccessControl)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::RichPresenceAccessControl LocationAccessControl() const
    {
        return _deprecated_LocationAccessControl();
    }

private:
    inline Tp::RichPresenceAccessControl _deprecated_LocationAccessControl() const
    {
        return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
    }
public:

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

    inline TELEPATHY_QT4_DEPRECATED void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue)
    {
        return _deprecated_setLocationAccessControl(newValue);
    }

private:
    inline void _deprecated_setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue)
    {
        internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
    }
public:

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

    Q_PROPERTY(uint SupportedLocationFeatures READ _deprecated_SupportedLocationFeatures)

    
    inline TELEPATHY_QT4_DEPRECATED uint SupportedLocationFeatures() const
    {
        return _deprecated_SupportedLocationFeatures();
    }

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

    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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contact);
        return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(location);
        return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
    }

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

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

class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

    Q_PROPERTY(bool PowerSavingActive READ _deprecated_PowerSavingActive)

    
    inline TELEPATHY_QT4_DEPRECATED bool PowerSavingActive() const
    {
        return _deprecated_PowerSavingActive();
    }

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

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

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(activate);
        return asyncCallWithArgumentList(QLatin1String("SetPowerSaving"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
        return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
    }

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

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
    }

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

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(status);
        return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(time);
        return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(statuses);
        return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(Tp::ChannelDetailsList Channels READ _deprecated_Channels)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::ChannelDetailsList Channels() const
    {
        return _deprecated_Channels();
    }

private:
    inline Tp::ChannelDetailsList _deprecated_Channels() const
    {
        return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
    }
public:

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

    Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ _deprecated_RequestableChannelClasses)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::RequestableChannelClassList RequestableChannelClasses() const
    {
        return _deprecated_RequestableChannelClasses();
    }

private:
    inline Tp::RequestableChannelClassList _deprecated_RequestableChannelClasses() const
    {
        return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
    }
public:

    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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(request);
        return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(request);
        return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
    }

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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(Tp::ServicePointInfoList KnownServicePoints READ _deprecated_KnownServicePoints)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::ServicePointInfoList KnownServicePoints() const
    {
        return _deprecated_KnownServicePoints();
    }

private:
    inline Tp::ServicePointInfoList _deprecated_KnownServicePoints() const
    {
        return qvariant_cast<Tp::ServicePointInfoList>(internalPropGet("KnownServicePoints"));
    }
public:

    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 const char *staticInterfaceName()
    {
        return "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);

    Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ _deprecated_Statuses)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::SimpleStatusSpecMap Statuses() const
    {
        return _deprecated_Statuses();
    }

private:
    inline Tp::SimpleStatusSpecMap _deprecated_Statuses() const
    {
        return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
    }
public:

    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)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
        return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
    }

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contacts);
        return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
    }

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::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::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*)