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

namespace Tp
{
namespace Client
{

class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

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

    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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

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

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

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

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

    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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

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

    inline Tp::PendingVariant *requestPropertyDeferredTones() const
    {
        return internalRequestProperty(QLatin1String("DeferredTones"));
    }

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

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

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

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

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

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

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

Q_SIGNALS:
    void TonesDeferred(const QString& tones);

    void SendingTones(const QString& tones);

    void StoppedTones(bool cancelled);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceDestroyableInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceDestroyableInterface(Tp::DBusProxy *proxy);

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

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

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

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

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

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

    inline Tp::PendingVariant *requestPropertyMessageTypes() const
    {
        return internalRequestProperty(QLatin1String("MessageTypes"));
    }

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

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

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

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);

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

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

    inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
    {
        return internalRequestProperty(QLatin1String("AvailableMechanisms"));
    }

    inline Tp::PendingVariant *requestPropertyHasInitialData() const
    {
        return internalRequestProperty(QLatin1String("HasInitialData"));
    }

    inline Tp::PendingVariant *requestPropertyCanTryAgain() const
    {
        return internalRequestProperty(QLatin1String("CanTryAgain"));
    }

    inline Tp::PendingVariant *requestPropertySASLStatus() const
    {
        return internalRequestProperty(QLatin1String("SASLStatus"));
    }

    inline Tp::PendingVariant *requestPropertySASLError() const
    {
        return internalRequestProperty(QLatin1String("SASLError"));
    }

    inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
    {
        return internalRequestProperty(QLatin1String("SASLErrorDetails"));
    }

    inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
    {
        return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
    }

    inline Tp::PendingVariant *requestPropertyDefaultUsername() const
    {
        return internalRequestProperty(QLatin1String("DefaultUsername"));
    }

    inline Tp::PendingVariant *requestPropertyDefaultRealm() const
    {
        return internalRequestProperty(QLatin1String("DefaultRealm"));
    }

    inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
    {
        return internalRequestProperty(QLatin1String("MaySaveResponse"));
    }

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

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

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

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

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

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

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

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

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

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

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

Q_SIGNALS:
    void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);

    void NewChallenge(const QByteArray& challengeData);

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);

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

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

    inline Tp::PendingVariant *requestPropertyEncrypted() const
    {
        return internalRequestProperty(QLatin1String("Encrypted"));
    }

    inline Tp::PendingVariant *requestPropertyVerified() const
    {
        return internalRequestProperty(QLatin1String("Verified"));
    }

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

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

class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

    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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

    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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

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

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

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

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

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

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

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

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

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

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

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

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

    ChannelTypeDBusTubeInterface(Tp::DBusProxy *proxy);

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

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

    inline Tp::PendingVariant *requestPropertyServiceName() const
    {
        return internalRequestProperty(QLatin1String("ServiceName"));
    }

    inline Tp::PendingVariant *requestPropertyDBusNames() const
    {
        return internalRequestProperty(QLatin1String("DBusNames"));
    }

    inline Tp::PendingVariant *requestPropertySupportedAccessControls() const
    {
        return internalRequestProperty(QLatin1String("SupportedAccessControls"));
    }

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

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

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

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

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

Q_SIGNALS:
    void DBusNamesChanged(const Tp::DBusTubeParticipants& added, const Tp::UIntList& removed);

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

class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

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

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

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

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

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

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

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

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

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

    inline Tp::PendingVariant *requestPropertyURI() const
    {
        return internalRequestProperty(QLatin1String("URI"));
    }

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

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

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

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("AcceptFile"));
        callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
        return this->connection().asyncCall(callMessage, timeout);
    }

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

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

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

    void TransferredBytesChanged(qulonglong count);

    void InitialOffsetDefined(qulonglong initialOffset);

    void URIDefined(const QString& URI);

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

class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

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

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

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

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

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

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

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

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

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

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

    ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);

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

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

    inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
    {
        return internalRequestProperty(QLatin1String("AuthenticationMethod"));
    }

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

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

class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
    {
        return internalRequestProperty(QLatin1String("ReferenceIdentities"));
    }

    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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

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

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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);

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

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

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

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

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

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

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

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

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

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

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

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

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 QLatin1String staticInterfaceName()
    {
        return QLatin1String("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(int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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::ChannelInterfaceDestroyableInterface*)
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::ChannelInterfaceSASLAuthenticationInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
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::ChannelTypeDBusTubeInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
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*)