cli-channel.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 ChannelInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterface(Tp::DBusProxy *proxy);

    Q_PROPERTY(QString ChannelType READ _deprecated_ChannelType)

    
    inline TELEPATHY_QT4_DEPRECATED QString ChannelType() const
    {
        return _deprecated_ChannelType();
    }

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

    inline Tp::PendingVariant *requestPropertyChannelType() const
    {
        return internalRequestProperty(QLatin1String("ChannelType"));
    }

    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 TargetHandle READ _deprecated_TargetHandle)

    
    inline TELEPATHY_QT4_DEPRECATED uint TargetHandle() const
    {
        return _deprecated_TargetHandle();
    }

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

    inline Tp::PendingVariant *requestPropertyTargetHandle() const
    {
        return internalRequestProperty(QLatin1String("TargetHandle"));
    }

    Q_PROPERTY(QString TargetID READ _deprecated_TargetID)

    
    inline TELEPATHY_QT4_DEPRECATED QString TargetID() const
    {
        return _deprecated_TargetID();
    }

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

    inline Tp::PendingVariant *requestPropertyTargetID() const
    {
        return internalRequestProperty(QLatin1String("TargetID"));
    }

    Q_PROPERTY(uint TargetHandleType READ _deprecated_TargetHandleType)

    
    inline TELEPATHY_QT4_DEPRECATED uint TargetHandleType() const
    {
        return _deprecated_TargetHandleType();
    }

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

    inline Tp::PendingVariant *requestPropertyTargetHandleType() const
    {
        return internalRequestProperty(QLatin1String("TargetHandleType"));
    }

    Q_PROPERTY(bool Requested READ _deprecated_Requested)

    
    inline TELEPATHY_QT4_DEPRECATED bool Requested() const
    {
        return _deprecated_Requested();
    }

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

    inline Tp::PendingVariant *requestPropertyRequested() const
    {
        return internalRequestProperty(QLatin1String("Requested"));
    }

    Q_PROPERTY(uint InitiatorHandle READ _deprecated_InitiatorHandle)

    
    inline TELEPATHY_QT4_DEPRECATED uint InitiatorHandle() const
    {
        return _deprecated_InitiatorHandle();
    }

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

    inline Tp::PendingVariant *requestPropertyInitiatorHandle() const
    {
        return internalRequestProperty(QLatin1String("InitiatorHandle"));
    }

    Q_PROPERTY(QString InitiatorID READ _deprecated_InitiatorID)

    
    inline TELEPATHY_QT4_DEPRECATED QString InitiatorID() const
    {
        return _deprecated_InitiatorID();
    }

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

    inline Tp::PendingVariant *requestPropertyInitiatorID() const
    {
        return internalRequestProperty(QLatin1String("InitiatorID"));
    }

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

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

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

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

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

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

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

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

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

Q_SIGNALS:
    void Closed();

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(uint AnonymityModes READ _deprecated_AnonymityModes)

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

    Q_PROPERTY(bool AnonymityMandatory READ _deprecated_AnonymityMandatory)

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

    Q_PROPERTY(QString AnonymousID READ _deprecated_AnonymousID)

    
    inline TELEPATHY_QT4_DEPRECATED QString AnonymousID() const
    {
        return _deprecated_AnonymousID();
    }

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

    inline Tp::PendingVariant *requestPropertyAnonymousID() const
    {
        return internalRequestProperty(QLatin1String("AnonymousID"));
    }

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

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

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

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

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

Q_SIGNALS:
    void CallStateChanged(uint contact, uint state);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(Tp::ChatStateMap ChatStates READ _deprecated_ChatStates)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::ChatStateMap ChatStates() const
    {
        return _deprecated_ChatStates();
    }

private:
    inline Tp::ChatStateMap _deprecated_ChatStates() const
    {
        return qvariant_cast<Tp::ChatStateMap>(internalPropGet("ChatStates"));
    }
public:

    inline Tp::PendingVariant *requestPropertyChatStates() const
    {
        return internalRequestProperty(QLatin1String("ChatStates"));
    }

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

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

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

Q_SIGNALS:
    void ChatStateChanged(uint contact, uint state);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(Tp::ObjectPathList Channels READ _deprecated_Channels)

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

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

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

    Q_PROPERTY(Tp::ObjectPathList InitialChannels READ _deprecated_InitialChannels)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::ObjectPathList InitialChannels() const
    {
        return _deprecated_InitialChannels();
    }

private:
    inline Tp::ObjectPathList _deprecated_InitialChannels() const
    {
        return qvariant_cast<Tp::ObjectPathList>(internalPropGet("InitialChannels"));
    }
public:

    inline Tp::PendingVariant *requestPropertyInitialChannels() const
    {
        return internalRequestProperty(QLatin1String("InitialChannels"));
    }

    Q_PROPERTY(Tp::UIntList InitialInviteeHandles READ _deprecated_InitialInviteeHandles)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::UIntList InitialInviteeHandles() const
    {
        return _deprecated_InitialInviteeHandles();
    }

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

    inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
    {
        return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
    }

    Q_PROPERTY(QStringList InitialInviteeIDs READ _deprecated_InitialInviteeIDs)

    
    inline TELEPATHY_QT4_DEPRECATED QStringList InitialInviteeIDs() const
    {
        return _deprecated_InitialInviteeIDs();
    }

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

    inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
    {
        return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
    }

    Q_PROPERTY(QString InvitationMessage READ _deprecated_InvitationMessage)

    
    inline TELEPATHY_QT4_DEPRECATED QString InvitationMessage() const
    {
        return _deprecated_InvitationMessage();
    }

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

    inline Tp::PendingVariant *requestPropertyInvitationMessage() const
    {
        return internalRequestProperty(QLatin1String("InvitationMessage"));
    }

    Q_PROPERTY(Tp::ChannelOriginatorMap OriginalChannels READ _deprecated_OriginalChannels)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::ChannelOriginatorMap OriginalChannels() const
    {
        return _deprecated_OriginalChannels();
    }

private:
    inline Tp::ChannelOriginatorMap _deprecated_OriginalChannels() const
    {
        return qvariant_cast<Tp::ChannelOriginatorMap>(internalPropGet("OriginalChannels"));
    }
public:

    inline Tp::PendingVariant *requestPropertyOriginalChannels() const
    {
        return internalRequestProperty(QLatin1String("OriginalChannels"));
    }

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

Q_SIGNALS:
    void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);

    void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(bool CurrentlySendingTones READ _deprecated_CurrentlySendingTones)

    
    inline TELEPATHY_QT4_DEPRECATED bool CurrentlySendingTones() const
    {
        return _deprecated_CurrentlySendingTones();
    }

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

    inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
    {
        return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
    }

    Q_PROPERTY(QString InitialTones READ _deprecated_InitialTones)

    
    inline TELEPATHY_QT4_DEPRECATED QString InitialTones() const
    {
        return _deprecated_InitialTones();
    }

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

    inline Tp::PendingVariant *requestPropertyInitialTones() const
    {
        return internalRequestProperty(QLatin1String("InitialTones"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
        return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
    }

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

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

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

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

Q_SIGNALS:
    void SendingTones(const QString& tones);

    void StoppedTones(bool cancelled);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(uint GroupFlags READ _deprecated_GroupFlags)

    
    inline TELEPATHY_QT4_DEPRECATED uint GroupFlags() const
    {
        return _deprecated_GroupFlags();
    }

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

    inline Tp::PendingVariant *requestPropertyGroupFlags() const
    {
        return internalRequestProperty(QLatin1String("GroupFlags"));
    }

    Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ _deprecated_HandleOwners)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::HandleOwnerMap HandleOwners() const
    {
        return _deprecated_HandleOwners();
    }

private:
    inline Tp::HandleOwnerMap _deprecated_HandleOwners() const
    {
        return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
    }
public:

    inline Tp::PendingVariant *requestPropertyHandleOwners() const
    {
        return internalRequestProperty(QLatin1String("HandleOwners"));
    }

    Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ _deprecated_LocalPendingMembers)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::LocalPendingInfoList LocalPendingMembers() const
    {
        return _deprecated_LocalPendingMembers();
    }

private:
    inline Tp::LocalPendingInfoList _deprecated_LocalPendingMembers() const
    {
        return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
    }
public:

    inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
    {
        return internalRequestProperty(QLatin1String("LocalPendingMembers"));
    }

    Q_PROPERTY(Tp::UIntList Members READ _deprecated_Members)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::UIntList Members() const
    {
        return _deprecated_Members();
    }

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

    inline Tp::PendingVariant *requestPropertyMembers() const
    {
        return internalRequestProperty(QLatin1String("Members"));
    }

    Q_PROPERTY(Tp::UIntList RemotePendingMembers READ _deprecated_RemotePendingMembers)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::UIntList RemotePendingMembers() const
    {
        return _deprecated_RemotePendingMembers();
    }

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

    inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
    {
        return internalRequestProperty(QLatin1String("RemotePendingMembers"));
    }

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

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

public Q_SLOTS:
    inline QDBusPendingReply<> AddMembers(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("AddMembers"), argumentList);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    inline QDBusPendingReply<> RemoveMembers(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("RemoveMembers"), argumentList);
    }

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

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

Q_SIGNALS:
    void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);

    void SelfHandleChanged(uint selfHandle);

    void GroupFlagsChanged(uint added, uint removed);

    void MembersChanged(const QString& message, const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, uint actor, uint reason);

    void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

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

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

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

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

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

Q_SIGNALS:
    void HoldStateChanged(uint holdState, uint reason);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

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

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

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

Q_SIGNALS:
    void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(QStringList SupportedContentTypes READ _deprecated_SupportedContentTypes)

    
    inline TELEPATHY_QT4_DEPRECATED QStringList SupportedContentTypes() const
    {
        return _deprecated_SupportedContentTypes();
    }

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

    inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
    {
        return internalRequestProperty(QLatin1String("SupportedContentTypes"));
    }

    Q_PROPERTY(uint MessagePartSupportFlags READ _deprecated_MessagePartSupportFlags)

    
    inline TELEPATHY_QT4_DEPRECATED uint MessagePartSupportFlags() const
    {
        return _deprecated_MessagePartSupportFlags();
    }

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

    inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
    {
        return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
    }

    Q_PROPERTY(Tp::MessagePartListList PendingMessages READ _deprecated_PendingMessages)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::MessagePartListList PendingMessages() const
    {
        return _deprecated_PendingMessages();
    }

private:
    inline Tp::MessagePartListList _deprecated_PendingMessages() const
    {
        return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
    }
public:

    inline Tp::PendingVariant *requestPropertyPendingMessages() const
    {
        return internalRequestProperty(QLatin1String("PendingMessages"));
    }

    Q_PROPERTY(uint DeliveryReportingSupport READ _deprecated_DeliveryReportingSupport)

    
    inline TELEPATHY_QT4_DEPRECATED uint DeliveryReportingSupport() const
    {
        return _deprecated_DeliveryReportingSupport();
    }

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

    inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
    {
        return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
        return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
    }

Q_SIGNALS:
    void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);

    void PendingMessagesRemoved(const Tp::UIntList& messageIDs);

    void MessageReceived(const Tp::MessagePartList& message);

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

class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

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

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

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

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

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

Q_SIGNALS:
    void PasswordFlagsChanged(uint added, uint removed);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(Tp::ServicePoint InitialServicePoint READ _deprecated_InitialServicePoint)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::ServicePoint InitialServicePoint() const
    {
        return _deprecated_InitialServicePoint();
    }

private:
    inline Tp::ServicePoint _deprecated_InitialServicePoint() const
    {
        return qvariant_cast<Tp::ServicePoint>(internalPropGet("InitialServicePoint"));
    }
public:

    inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
    {
        return internalRequestProperty(QLatin1String("InitialServicePoint"));
    }

    Q_PROPERTY(Tp::ServicePoint CurrentServicePoint READ _deprecated_CurrentServicePoint)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::ServicePoint CurrentServicePoint() const
    {
        return _deprecated_CurrentServicePoint();
    }

private:
    inline Tp::ServicePoint _deprecated_CurrentServicePoint() const
    {
        return qvariant_cast<Tp::ServicePoint>(internalPropGet("CurrentServicePoint"));
    }
public:

    inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
    {
        return internalRequestProperty(QLatin1String("CurrentServicePoint"));
    }

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

Q_SIGNALS:
    void ServicePointChanged(const Tp::ServicePoint& servicePoint);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);

    explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(QVariantMap Parameters READ _deprecated_Parameters)

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

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

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

    Q_PROPERTY(uint State READ _deprecated_State)

    
    inline TELEPATHY_QT4_DEPRECATED uint State() const
    {
        return _deprecated_State();
    }

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

    inline Tp::PendingVariant *requestPropertyState() const
    {
        return internalRequestProperty(QLatin1String("State"));
    }

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

Q_SIGNALS:
    void TubeChannelStateChanged(uint state);

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

class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeContactListInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

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

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

class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(uint SearchState READ _deprecated_SearchState)

    
    inline TELEPATHY_QT4_DEPRECATED uint SearchState() const
    {
        return _deprecated_SearchState();
    }

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

    inline Tp::PendingVariant *requestPropertySearchState() const
    {
        return internalRequestProperty(QLatin1String("SearchState"));
    }

    Q_PROPERTY(uint Limit READ _deprecated_Limit)

    
    inline TELEPATHY_QT4_DEPRECATED uint Limit() const
    {
        return _deprecated_Limit();
    }

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

    inline Tp::PendingVariant *requestPropertyLimit() const
    {
        return internalRequestProperty(QLatin1String("Limit"));
    }

    Q_PROPERTY(QStringList AvailableSearchKeys READ _deprecated_AvailableSearchKeys)

    
    inline TELEPATHY_QT4_DEPRECATED QStringList AvailableSearchKeys() const
    {
        return _deprecated_AvailableSearchKeys();
    }

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

    inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
    {
        return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
    }

    Q_PROPERTY(QString Server READ _deprecated_Server)

    
    inline TELEPATHY_QT4_DEPRECATED QString Server() const
    {
        return _deprecated_Server();
    }

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

    inline Tp::PendingVariant *requestPropertyServer() const
    {
        return internalRequestProperty(QLatin1String("Server"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

Q_SIGNALS:
    void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);

    void SearchResultReceived(const Tp::ContactSearchResultMap& result);

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

class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(uint State READ _deprecated_State)

    
    inline TELEPATHY_QT4_DEPRECATED uint State() const
    {
        return _deprecated_State();
    }

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

    inline Tp::PendingVariant *requestPropertyState() const
    {
        return internalRequestProperty(QLatin1String("State"));
    }

    Q_PROPERTY(QString ContentType READ _deprecated_ContentType)

    
    inline TELEPATHY_QT4_DEPRECATED QString ContentType() const
    {
        return _deprecated_ContentType();
    }

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

    inline Tp::PendingVariant *requestPropertyContentType() const
    {
        return internalRequestProperty(QLatin1String("ContentType"));
    }

    Q_PROPERTY(QString Filename READ _deprecated_Filename)

    
    inline TELEPATHY_QT4_DEPRECATED QString Filename() const
    {
        return _deprecated_Filename();
    }

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

    inline Tp::PendingVariant *requestPropertyFilename() const
    {
        return internalRequestProperty(QLatin1String("Filename"));
    }

    Q_PROPERTY(qulonglong Size READ _deprecated_Size)

    
    inline TELEPATHY_QT4_DEPRECATED qulonglong Size() const
    {
        return _deprecated_Size();
    }

private:
    inline qulonglong _deprecated_Size() const
    {
        return qvariant_cast<qulonglong>(internalPropGet("Size"));
    }
public:

    inline Tp::PendingVariant *requestPropertySize() const
    {
        return internalRequestProperty(QLatin1String("Size"));
    }

    Q_PROPERTY(uint ContentHashType READ _deprecated_ContentHashType)

    
    inline TELEPATHY_QT4_DEPRECATED uint ContentHashType() const
    {
        return _deprecated_ContentHashType();
    }

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

    inline Tp::PendingVariant *requestPropertyContentHashType() const
    {
        return internalRequestProperty(QLatin1String("ContentHashType"));
    }

    Q_PROPERTY(QString ContentHash READ _deprecated_ContentHash)

    
    inline TELEPATHY_QT4_DEPRECATED QString ContentHash() const
    {
        return _deprecated_ContentHash();
    }

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

    inline Tp::PendingVariant *requestPropertyContentHash() const
    {
        return internalRequestProperty(QLatin1String("ContentHash"));
    }

    Q_PROPERTY(QString Description READ _deprecated_Description)

    
    inline TELEPATHY_QT4_DEPRECATED QString Description() const
    {
        return _deprecated_Description();
    }

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

    inline Tp::PendingVariant *requestPropertyDescription() const
    {
        return internalRequestProperty(QLatin1String("Description"));
    }

    Q_PROPERTY(qlonglong Date READ _deprecated_Date)

    
    inline TELEPATHY_QT4_DEPRECATED qlonglong Date() const
    {
        return _deprecated_Date();
    }

private:
    inline qlonglong _deprecated_Date() const
    {
        return qvariant_cast<qlonglong>(internalPropGet("Date"));
    }
public:

    inline Tp::PendingVariant *requestPropertyDate() const
    {
        return internalRequestProperty(QLatin1String("Date"));
    }

    Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ _deprecated_AvailableSocketTypes)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::SupportedSocketMap AvailableSocketTypes() const
    {
        return _deprecated_AvailableSocketTypes();
    }

private:
    inline Tp::SupportedSocketMap _deprecated_AvailableSocketTypes() const
    {
        return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
    }
public:

    inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
    {
        return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
    }

    Q_PROPERTY(qulonglong TransferredBytes READ _deprecated_TransferredBytes)

    
    inline TELEPATHY_QT4_DEPRECATED qulonglong TransferredBytes() const
    {
        return _deprecated_TransferredBytes();
    }

private:
    inline qulonglong _deprecated_TransferredBytes() const
    {
        return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
    }
public:

    inline Tp::PendingVariant *requestPropertyTransferredBytes() const
    {
        return internalRequestProperty(QLatin1String("TransferredBytes"));
    }

    Q_PROPERTY(qulonglong InitialOffset READ _deprecated_InitialOffset)

    
    inline TELEPATHY_QT4_DEPRECATED qulonglong InitialOffset() const
    {
        return _deprecated_InitialOffset();
    }

private:
    inline qulonglong _deprecated_InitialOffset() const
    {
        return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
    }
public:

    inline Tp::PendingVariant *requestPropertyInitialOffset() const
    {
        return internalRequestProperty(QLatin1String("InitialOffset"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
        return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
    }

    inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
        return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
    }

Q_SIGNALS:
    void FileTransferStateChanged(uint state, uint reason);

    void TransferredBytesChanged(qulonglong count);

    void InitialOffsetDefined(qulonglong initialOffset);

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

class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(QString Server READ _deprecated_Server)

    
    inline TELEPATHY_QT4_DEPRECATED QString Server() const
    {
        return _deprecated_Server();
    }

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

    inline Tp::PendingVariant *requestPropertyServer() const
    {
        return internalRequestProperty(QLatin1String("Server"));
    }

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

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

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

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

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

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

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

Q_SIGNALS:
    void GotRooms(const Tp::RoomInfoList& rooms);

    void ListingRooms(bool listing);

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

class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(QDBusObjectPath ServerCertificate READ _deprecated_ServerCertificate)

    
    inline TELEPATHY_QT4_DEPRECATED QDBusObjectPath ServerCertificate() const
    {
        return _deprecated_ServerCertificate();
    }

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

    inline Tp::PendingVariant *requestPropertyServerCertificate() const
    {
        return internalRequestProperty(QLatin1String("ServerCertificate"));
    }

    Q_PROPERTY(QString Hostname READ _deprecated_Hostname)

    
    inline TELEPATHY_QT4_DEPRECATED QString Hostname() const
    {
        return _deprecated_Hostname();
    }

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

    inline Tp::PendingVariant *requestPropertyHostname() const
    {
        return internalRequestProperty(QLatin1String("Hostname"));
    }

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

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

class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(QString Service READ _deprecated_Service)

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

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

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

    Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ _deprecated_SupportedSocketTypes)

    
    inline TELEPATHY_QT4_DEPRECATED Tp::SupportedSocketMap SupportedSocketTypes() const
    {
        return _deprecated_SupportedSocketTypes();
    }

private:
    inline Tp::SupportedSocketMap _deprecated_SupportedSocketTypes() const
    {
        return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
    }
public:

    inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
    {
        return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
        return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
    }

    inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
        return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
    }

Q_SIGNALS:
    void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);

    void NewLocalConnection(uint connectionID);

    void ConnectionClosed(uint connectionID, const QString& error, const QString& message);

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

class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    Q_PROPERTY(bool InitialAudio READ _deprecated_InitialAudio)

    
    inline TELEPATHY_QT4_DEPRECATED bool InitialAudio() const
    {
        return _deprecated_InitialAudio();
    }

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

    inline Tp::PendingVariant *requestPropertyInitialAudio() const
    {
        return internalRequestProperty(QLatin1String("InitialAudio"));
    }

    Q_PROPERTY(bool InitialVideo READ _deprecated_InitialVideo)

    
    inline TELEPATHY_QT4_DEPRECATED bool InitialVideo() const
    {
        return _deprecated_InitialVideo();
    }

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

    inline Tp::PendingVariant *requestPropertyInitialVideo() const
    {
        return internalRequestProperty(QLatin1String("InitialVideo"));
    }

    Q_PROPERTY(bool ImmutableStreams READ _deprecated_ImmutableStreams)

    
    inline TELEPATHY_QT4_DEPRECATED bool ImmutableStreams() const
    {
        return _deprecated_ImmutableStreams();
    }

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

    inline Tp::PendingVariant *requestPropertyImmutableStreams() const
    {
        return internalRequestProperty(QLatin1String("ImmutableStreams"));
    }

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

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

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

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

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

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

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
        return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
    }

    inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
        return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
    }

Q_SIGNALS:
    void StreamAdded(uint streamID, uint contactHandle, uint streamType);

    void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);

    void StreamError(uint streamID, uint errorCode, const QString& message);

    void StreamRemoved(uint streamID);

    void StreamStateChanged(uint streamID, uint streamState);

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

class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeTextInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

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

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

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

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

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

    inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<> Send(uint type, const QString& text)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
        return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
    }

Q_SIGNALS:
    void LostMessage();

    void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);

    void SendError(uint error, uint timestamp, uint type, const QString& text);

    void Sent(uint timestamp, uint type, const QString& text);

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

class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelTypeTubesInterface(Tp::DBusProxy *proxy);

    explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);

    ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

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

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

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

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

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

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

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

    inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
        return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
    }

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

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

    inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
        return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
    }

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

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

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

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

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

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

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

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

Q_SIGNALS:
    void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);

    void TubeStateChanged(uint ID, uint state);

    void TubeClosed(uint ID);

    void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);

    void StreamTubeNewConnection(uint ID, uint handle);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}
Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)