Home · All Classes · All Namespaces · Modules · Functions · Files

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>

// 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 ChannelType)

    
    inline QString ChannelType() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("ChannelType"));
    }

    Q_PROPERTY(QStringList Interfaces READ Interfaces)

    
    inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
    }

    Q_PROPERTY(uint TargetHandle READ TargetHandle)

    
    inline uint TargetHandle() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("TargetHandle"));
    }

    Q_PROPERTY(QString TargetID READ TargetID)

    
    inline QString TargetID() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("TargetID"));
    }

    Q_PROPERTY(uint TargetHandleType READ TargetHandleType)

    
    inline uint TargetHandleType() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("TargetHandleType"));
    }

    Q_PROPERTY(bool Requested READ Requested)

    
    inline bool Requested() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<bool>(internalPropGet("Requested"));
    }

    Q_PROPERTY(uint InitiatorHandle READ InitiatorHandle)

    
    inline uint InitiatorHandle() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("InitiatorHandle"));
    }

    Q_PROPERTY(QString InitiatorID READ InitiatorID)

    
    inline QString InitiatorID() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("InitiatorID"));
    }

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

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

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

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

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

    
    inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("GroupFlags"));
    }

    Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)

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

    Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)

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

    Q_PROPERTY(Tp::UIntList Members READ Members)

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

    Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)

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

    Q_PROPERTY(uint SelfHandle READ SelfHandle)

    
    inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("SelfHandle"));
    }

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

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

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

    
    inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
    }

    Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)

    
    inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
    }

    Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)

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

    Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)

    
    inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
    }

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

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

    
    inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
    }

    Q_PROPERTY(uint State READ State)

    
    inline uint State() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("State"));
    }

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

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

    
    inline uint State() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("State"));
    }

    Q_PROPERTY(QString ContentType READ ContentType)

    
    inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("ContentType"));
    }

    Q_PROPERTY(QString Filename READ Filename)

    
    inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("Filename"));
    }

    Q_PROPERTY(qulonglong Size READ Size)

    
    inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<qulonglong>(internalPropGet("Size"));
    }

    Q_PROPERTY(uint ContentHashType READ ContentHashType)

    
    inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<uint>(internalPropGet("ContentHashType"));
    }

    Q_PROPERTY(QString ContentHash READ ContentHash)

    
    inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("ContentHash"));
    }

    Q_PROPERTY(QString Description READ Description)

    
    inline QString Description() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("Description"));
    }

    Q_PROPERTY(qlonglong Date READ Date)

    
    inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<qlonglong>(internalPropGet("Date"));
    }

    Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)

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

    Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)

    
    inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
    }

    Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)

    
    inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
    }

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

    
    inline QString Server() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("Server"));
    }

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

    
    inline QString Service() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QString>(internalPropGet("Service"));
    }

    Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)

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

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

    
    inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<bool>(internalPropGet("InitialAudio"));
    }

    Q_PROPERTY(bool InitialVideo READ InitialVideo)

    
    inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<bool>(internalPropGet("InitialVideo"));
    }

    Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)

    
    inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
    }

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

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

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