/*
 * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
 *
 * This file can be distributed under the same terms as the specification from
 * which it was generated.
 */

#ifndef IN_TELEPATHY_QT4_HEADER
#error IN_TELEPATHY_QT4_HEADER
#endif

#include <TelepathyQt4/Types>

#include <QtGlobal>

#include <QString>
#include <QObject>
#include <QVariant>

#include <QDBusPendingReply>

#include <TelepathyQt4/AbstractInterface>
#include <TelepathyQt4/DBusProxy>
#include <TelepathyQt4/Global>

namespace Tp{
class PendingVariant;
class PendingOperation;
}

// FIXME: (API/ABI break) Remove definition of TELEPATHY_GNUC_DEPRECATED

// basically the same as GLib's G_GNUC_DEPRECATED
#ifndef TELEPATHY_GNUC_DEPRECATED
#   if defined(Q_CC_GNUC) && __GNUC__ >= 4
#       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
#   else
#       define TELEPATHY_GNUC_DEPRECATED
#   endif
#endif
namespace Tp
{
namespace Client
{

/**
 * \class ChannelInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel."
 */
class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel";
    }

    /**
     * Creates a ChannelInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterface(Tp::DBusProxy *proxy);

    /**
     * Represents property "ChannelType" on the remote object.
     * 
     * <p>The channel's type. This cannot change once the channel has
     *   been created.</p>
     * 
     * <p>For compatibility between older connection managers and newer
     *   clients, if this is unavailable or is an empty string,
     *   clients MUST use the result of calling
     *   <tp:member-ref>GetChannelType</tp:member-ref>.</p>
     * 
     * <tp:rationale>
     *   The GetAll method lets clients retrieve all properties in one
     *   round-trip, which is desirable.
     * </tp:rationale>
     * 
     * <p>When requesting a channel, the request MUST specify a channel
     *   type, and the request MUST fail if the specified channel type
     *   cannot be supplied.</p>
     * 
     * <tp:rationale>
     *   Common sense.
     * </tp:rationale>
     */
    Q_PROPERTY(QString ChannelType READ _deprecated_ChannelType)

    /**
     * Getter for the remote object property "ChannelType".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyChannelType() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString ChannelType() const
    {
        return _deprecated_ChannelType();
    }

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

    /**
     * Asynchronous getter for the remote object property "ChannelType" of type QString.
     *
     * 
     * <p>The channel's type. This cannot change once the channel has
     *   been created.</p>
     * 
     * <p>For compatibility between older connection managers and newer
     *   clients, if this is unavailable or is an empty string,
     *   clients MUST use the result of calling
     *   <tp:member-ref>GetChannelType</tp:member-ref>.</p>
     * 
     * <tp:rationale>
     *   The GetAll method lets clients retrieve all properties in one
     *   round-trip, which is desirable.
     * </tp:rationale>
     * 
     * <p>When requesting a channel, the request MUST specify a channel
     *   type, and the request MUST fail if the specified channel type
     *   cannot be supplied.</p>
     * 
     * <tp:rationale>
     *   Common sense.
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyChannelType() const
    {
        return internalRequestProperty(QLatin1String("ChannelType"));
    }

    /**
     * Represents property "Interfaces" on the remote object.
     * 
     * <p>Extra interfaces provided by this channel. This SHOULD NOT include
     *   the channel type and the Channel interface itself, and cannot
     *   change once the channel has been created.</p>
     * 
     * <p>For compatibility between older connection managers and newer
     *   clients, if this is unavailable, or if this is an empty list and
     *   <tp:member-ref>ChannelType</tp:member-ref> is an empty string,
     *   clients MUST use the result of calling
     *   <tp:member-ref>GetInterfaces</tp:member-ref> instead. If this is an
     *   empty list but ChannelType is non-empty, clients SHOULD NOT call
     *   GetInterfaces; this implies that connection managers that implement
     *   the ChannelType property MUST also implement the Interfaces property
     *   correctly.</p>
     * 
     * <tp:rationale>
     *   The GetAll method lets clients retrieve all properties in one
     *   round-trip, which is desirable.
     * </tp:rationale>
     * 
     * <p>When requesting a channel with a particular value for this
     *   property, the request must fail without side-effects unless the
     *   connection manager expects to be able to provide a channel whose
     *   interfaces include at least the interfaces requested.</p>
     */
    Q_PROPERTY(QStringList Interfaces READ _deprecated_Interfaces)

    /**
     * Getter for the remote object property "Interfaces".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInterfaces() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QStringList Interfaces() const
    {
        return _deprecated_Interfaces();
    }

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

    /**
     * Asynchronous getter for the remote object property "Interfaces" of type QStringList.
     *
     * 
     * <p>Extra interfaces provided by this channel. This SHOULD NOT include
     *   the channel type and the Channel interface itself, and cannot
     *   change once the channel has been created.</p>
     * 
     * <p>For compatibility between older connection managers and newer
     *   clients, if this is unavailable, or if this is an empty list and
     *   <tp:member-ref>ChannelType</tp:member-ref> is an empty string,
     *   clients MUST use the result of calling
     *   <tp:member-ref>GetInterfaces</tp:member-ref> instead. If this is an
     *   empty list but ChannelType is non-empty, clients SHOULD NOT call
     *   GetInterfaces; this implies that connection managers that implement
     *   the ChannelType property MUST also implement the Interfaces property
     *   correctly.</p>
     * 
     * <tp:rationale>
     *   The GetAll method lets clients retrieve all properties in one
     *   round-trip, which is desirable.
     * </tp:rationale>
     * 
     * <p>When requesting a channel with a particular value for this
     *   property, the request must fail without side-effects unless the
     *   connection manager expects to be able to provide a channel whose
     *   interfaces include at least the interfaces requested.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInterfaces() const
    {
        return internalRequestProperty(QLatin1String("Interfaces"));
    }

    /**
     * Represents property "TargetHandle" on the remote object.
     * 
     * <p>The handle (a representation for the identifier) of the contact,
     *   chatroom, etc. with which this handle communicates. Its type
     *   is given by the <tp:member-ref>TargetHandleType</tp:member-ref>
     *   property.</p>
     * 
     * <p>This is fixed for the lifetime of the channel, so channels which
     *   could potentially be used to communicate with multiple contacts
     *   (such as streamed media calls defined by their members, or ad-hoc
     *   chatrooms like MSN switchboards) must have TargetHandleType set
     *   to Handle_Type_None and TargetHandle set to 0.</p>
     * 
     * <p>Unlike in the telepathy-spec 0.16 API, there is no particular
     *   uniqueness guarantee - there can be many channels with the same
     *   (channel type, handle type, handle) tuple. This is necessary
     *   to support conversation threads in XMPP and SIP, for example.</p>
     * 
     * <p>If this is present in a channel request, it must be nonzero,
     *   <tp:member-ref>TargetHandleType</tp:member-ref>
     *   MUST be present and not Handle_Type_None, and
     *   <tp:member-ref>TargetID</tp:member-ref> MUST NOT be
     *   present. Properties from
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Addressing.DRAFT</tp:dbus-ref>
     *   MUST NOT be present.</p>
     * 
     * <p>The channel that satisfies the request MUST either:</p>
     * 
     * <ul>
     *   <li>have the specified TargetHandle property; or</li>
     *   <li>have <tp:member-ref>TargetHandleType</tp:member-ref> =
     *     Handle_Type_None, TargetHandle = 0, and be configured such that
     *     it could communicate with the specified handle in some other way
     *     (e.g. have the requested contact handle in its Group
     *     interface)</li>
     * </ul>
     */
    Q_PROPERTY(uint TargetHandle READ _deprecated_TargetHandle)

    /**
     * Getter for the remote object property "TargetHandle".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyTargetHandle() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint TargetHandle() const
    {
        return _deprecated_TargetHandle();
    }

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

    /**
     * Asynchronous getter for the remote object property "TargetHandle" of type uint.
     *
     * 
     * <p>The handle (a representation for the identifier) of the contact,
     *   chatroom, etc. with which this handle communicates. Its type
     *   is given by the <tp:member-ref>TargetHandleType</tp:member-ref>
     *   property.</p>
     * 
     * <p>This is fixed for the lifetime of the channel, so channels which
     *   could potentially be used to communicate with multiple contacts
     *   (such as streamed media calls defined by their members, or ad-hoc
     *   chatrooms like MSN switchboards) must have TargetHandleType set
     *   to Handle_Type_None and TargetHandle set to 0.</p>
     * 
     * <p>Unlike in the telepathy-spec 0.16 API, there is no particular
     *   uniqueness guarantee - there can be many channels with the same
     *   (channel type, handle type, handle) tuple. This is necessary
     *   to support conversation threads in XMPP and SIP, for example.</p>
     * 
     * <p>If this is present in a channel request, it must be nonzero,
     *   <tp:member-ref>TargetHandleType</tp:member-ref>
     *   MUST be present and not Handle_Type_None, and
     *   <tp:member-ref>TargetID</tp:member-ref> MUST NOT be
     *   present. Properties from
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Addressing.DRAFT</tp:dbus-ref>
     *   MUST NOT be present.</p>
     * 
     * <p>The channel that satisfies the request MUST either:</p>
     * 
     * <ul>
     *   <li>have the specified TargetHandle property; or</li>
     *   <li>have <tp:member-ref>TargetHandleType</tp:member-ref> =
     *     Handle_Type_None, TargetHandle = 0, and be configured such that
     *     it could communicate with the specified handle in some other way
     *     (e.g. have the requested contact handle in its Group
     *     interface)</li>
     * </ul>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyTargetHandle() const
    {
        return internalRequestProperty(QLatin1String("TargetHandle"));
    }

    /**
     * Represents property "TargetID" on the remote object.
     * 
     * <p>The string that would result from inspecting the
     *   <tp:member-ref>TargetHandle</tp:member-ref>
     *   property (i.e. the identifier in the IM protocol of the contact,
     *   room, etc. with which this channel communicates), or the empty
     *   string if the TargetHandle is 0.</p>
     * 
     * <tp:rationale>
     *   <p>The presence of this property avoids the following race
     *     condition:</p>
     * 
     *   <ul>
     *     <li>New channel C is signalled with target handle T</li>
     *     <li>Client calls <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [T])</li>
     *     <li>Channel C closes, removing the last reference to handle T</li>
     *     <li><tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [T]) returns an error</li>
     *   </ul>
     * </tp:rationale>
     * 
     * <p>If this is present in a channel request,
     *   <tp:member-ref>TargetHandleType</tp:member-ref>
     *   MUST be present and not Handle_Type_None, and
     *   <tp:member-ref>TargetHandle</tp:member-ref> MUST NOT be
     *   present. Properties from
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Addressing.DRAFT</tp:dbus-ref>
     *   MUST NOT be present.The request MUST fail with error InvalidHandle,
     *   without side-effects, if the requested TargetID would not be
     *   accepted by
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">RequestHandles</tp:dbus-ref>.</p>
     * 
     * <p>The returned channel must be related to the handle corresponding
     *   to the given identifier, in the same way as if TargetHandle
     *   had been part of the request instead.</p>
     * 
     * <tp:rationale>
     *   <p>Requesting channels with a string identifier saves a round-trip
     *     (the call to RequestHandles). It also allows the channel
     *     dispatcher to accept a channel request for an account that is not
     *     yet connected (and thus has no valid handles), bring the account
     *     online, and pass on the same parameters to the new connection's
     *     CreateChannel method.</p>
     * </tp:rationale>
     */
    Q_PROPERTY(QString TargetID READ _deprecated_TargetID)

    /**
     * Getter for the remote object property "TargetID".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyTargetID() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString TargetID() const
    {
        return _deprecated_TargetID();
    }

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

    /**
     * Asynchronous getter for the remote object property "TargetID" of type QString.
     *
     * 
     * <p>The string that would result from inspecting the
     *   <tp:member-ref>TargetHandle</tp:member-ref>
     *   property (i.e. the identifier in the IM protocol of the contact,
     *   room, etc. with which this channel communicates), or the empty
     *   string if the TargetHandle is 0.</p>
     * 
     * <tp:rationale>
     *   <p>The presence of this property avoids the following race
     *     condition:</p>
     * 
     *   <ul>
     *     <li>New channel C is signalled with target handle T</li>
     *     <li>Client calls <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [T])</li>
     *     <li>Channel C closes, removing the last reference to handle T</li>
     *     <li><tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [T]) returns an error</li>
     *   </ul>
     * </tp:rationale>
     * 
     * <p>If this is present in a channel request,
     *   <tp:member-ref>TargetHandleType</tp:member-ref>
     *   MUST be present and not Handle_Type_None, and
     *   <tp:member-ref>TargetHandle</tp:member-ref> MUST NOT be
     *   present. Properties from
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Addressing.DRAFT</tp:dbus-ref>
     *   MUST NOT be present.The request MUST fail with error InvalidHandle,
     *   without side-effects, if the requested TargetID would not be
     *   accepted by
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">RequestHandles</tp:dbus-ref>.</p>
     * 
     * <p>The returned channel must be related to the handle corresponding
     *   to the given identifier, in the same way as if TargetHandle
     *   had been part of the request instead.</p>
     * 
     * <tp:rationale>
     *   <p>Requesting channels with a string identifier saves a round-trip
     *     (the call to RequestHandles). It also allows the channel
     *     dispatcher to accept a channel request for an account that is not
     *     yet connected (and thus has no valid handles), bring the account
     *     online, and pass on the same parameters to the new connection's
     *     CreateChannel method.</p>
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyTargetID() const
    {
        return internalRequestProperty(QLatin1String("TargetID"));
    }

    /**
     * Represents property "TargetHandleType" on the remote object.
     * 
     * <p>The type of <tp:member-ref>TargetHandle</tp:member-ref>.</p>
     * 
     * <p>If this is omitted from a channel request, connection managers
     *   SHOULD treat this as equivalent to Handle_Type_None.</p>
     * 
     * <p>If this is omitted or is Handle_Type_None,
     *   <tp:member-ref>TargetHandle</tp:member-ref> and
     *   <tp:member-ref>TargetID</tp:member-ref> MUST be omitted from the
     *   request.</p>
     */
    Q_PROPERTY(uint TargetHandleType READ _deprecated_TargetHandleType)

    /**
     * Getter for the remote object property "TargetHandleType".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyTargetHandleType() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint TargetHandleType() const
    {
        return _deprecated_TargetHandleType();
    }

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

    /**
     * Asynchronous getter for the remote object property "TargetHandleType" of type uint.
     *
     * 
     * <p>The type of <tp:member-ref>TargetHandle</tp:member-ref>.</p>
     * 
     * <p>If this is omitted from a channel request, connection managers
     *   SHOULD treat this as equivalent to Handle_Type_None.</p>
     * 
     * <p>If this is omitted or is Handle_Type_None,
     *   <tp:member-ref>TargetHandle</tp:member-ref> and
     *   <tp:member-ref>TargetID</tp:member-ref> MUST be omitted from the
     *   request.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyTargetHandleType() const
    {
        return internalRequestProperty(QLatin1String("TargetHandleType"));
    }

    /**
     * Represents property "Requested" on the remote object.
     * 
     * <p>True if this channel was created in response to a local request,
     *   such as a call to
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.RequestChannel</tp:dbus-ref>
     *   or
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>.</p>
     * 
     * <tp:rationale>
     *   <p>The idea of this property is to distinguish between &quot;incoming&quot;
     *     and &quot;outgoing&quot; channels, in a way that doesn't break down when
     *     considering special cases like contact lists that are automatically
     *     created on connection to the server, or chatrooms that an
     *     IRC proxy/bouncer like irssi-proxy or bip was already in.</p>
     * 
     *   <p>The reason we want to make that distinction is that UIs for
     *     things that the user explicitly requested should start up
     *     automatically, whereas for incoming messages and VoIP calls we
     *     should first ask the user whether they want to open the messaging
     *     UI or accept the call.</p>
     * </tp:rationale>
     * 
     * <p>If the channel was not explicitly requested (even if it was
     *   created as a side-effect of a call to one of those functions,
     *   e.g. because joining a Tube in a MUC context on XMPP implies
     *   joining that MUC), then this property is false.</p>
     * 
     * <p>For compatibility with older connection managers, clients SHOULD
     *   assume that this property is true if they see a channel announced
     *   by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.NewChannel</tp:dbus-ref>
     *   signal with the suppress_handler parameter set to true.</p>
     * 
     * <tp:rationale>
     *   <p>In a correct connection manager, the only way to get such a
     *     channel is to request it.</p>
     * </tp:rationale>
     * 
     * <p>Clients MAY additionally assume that this property is false
     *   if they see a channel announced by the NewChannel signal with the
     *   suppress_handler parameter set to false.</p>
     * 
     * <tp:rationale>
     *   <p>This is more controversial, since it's possible to get that
     *     parameter set to false by requesting a channel. However, there's
     *     no good reason to do so, and we've deprecated this practice.</p>
     * 
     *   <p>In the particular case of the channel dispatcher, the only
     *     side-effect of wrongly thinking a channel is unrequested
     *     is likely to be that the user has to confirm that they want to
     *     use it, so it seems fairly harmless to assume in the channel
     *     dispatcher that channels with suppress_handler false are
     *     indeed unrequested.</p>
     * </tp:rationale>
     * 
     * <p>It does not make sense for this property to be in channel
     *   requests—it will always be true for channels returned by
     *   CreateChannel, and callers of EnsureChannel cannot control whether an
     *   existing channel was originally requested locally—so it MUST NOT
     *   be accepted.</p>
     */
    Q_PROPERTY(bool Requested READ _deprecated_Requested)

    /**
     * Getter for the remote object property "Requested".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyRequested() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED bool Requested() const
    {
        return _deprecated_Requested();
    }

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

    /**
     * Asynchronous getter for the remote object property "Requested" of type bool.
     *
     * 
     * <p>True if this channel was created in response to a local request,
     *   such as a call to
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.RequestChannel</tp:dbus-ref>
     *   or
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>.</p>
     * 
     * <tp:rationale>
     *   <p>The idea of this property is to distinguish between &quot;incoming&quot;
     *     and &quot;outgoing&quot; channels, in a way that doesn't break down when
     *     considering special cases like contact lists that are automatically
     *     created on connection to the server, or chatrooms that an
     *     IRC proxy/bouncer like irssi-proxy or bip was already in.</p>
     * 
     *   <p>The reason we want to make that distinction is that UIs for
     *     things that the user explicitly requested should start up
     *     automatically, whereas for incoming messages and VoIP calls we
     *     should first ask the user whether they want to open the messaging
     *     UI or accept the call.</p>
     * </tp:rationale>
     * 
     * <p>If the channel was not explicitly requested (even if it was
     *   created as a side-effect of a call to one of those functions,
     *   e.g. because joining a Tube in a MUC context on XMPP implies
     *   joining that MUC), then this property is false.</p>
     * 
     * <p>For compatibility with older connection managers, clients SHOULD
     *   assume that this property is true if they see a channel announced
     *   by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.NewChannel</tp:dbus-ref>
     *   signal with the suppress_handler parameter set to true.</p>
     * 
     * <tp:rationale>
     *   <p>In a correct connection manager, the only way to get such a
     *     channel is to request it.</p>
     * </tp:rationale>
     * 
     * <p>Clients MAY additionally assume that this property is false
     *   if they see a channel announced by the NewChannel signal with the
     *   suppress_handler parameter set to false.</p>
     * 
     * <tp:rationale>
     *   <p>This is more controversial, since it's possible to get that
     *     parameter set to false by requesting a channel. However, there's
     *     no good reason to do so, and we've deprecated this practice.</p>
     * 
     *   <p>In the particular case of the channel dispatcher, the only
     *     side-effect of wrongly thinking a channel is unrequested
     *     is likely to be that the user has to confirm that they want to
     *     use it, so it seems fairly harmless to assume in the channel
     *     dispatcher that channels with suppress_handler false are
     *     indeed unrequested.</p>
     * </tp:rationale>
     * 
     * <p>It does not make sense for this property to be in channel
     *   requests—it will always be true for channels returned by
     *   CreateChannel, and callers of EnsureChannel cannot control whether an
     *   existing channel was originally requested locally—so it MUST NOT
     *   be accepted.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyRequested() const
    {
        return internalRequestProperty(QLatin1String("Requested"));
    }

    /**
     * Represents property "InitiatorHandle" on the remote object.
     * 
     * <p>The contact who initiated the channel; for instance, the contact
     *   who invited the local user to a chatroom, or the contact who
     *   initiated a call.</p>
     * 
     * <p>This does <em>not</em> necessarily represent the contact who
     *   created the underlying protocol-level construct. For instance, if
     *   Rob creates a chatroom, Will joins that chatroom, and Will invites Simon
     *   to join it, then Simon will see Will as the InitiatorHandle of the
     *   channel representing the chatroom.</p>
     * 
     * <tp:rationale>
     *   <p>The room creator is generally a less useful piece of information
     *     than the inviter, is less likely to be available at invitation
     *     time (i.e. can't necessarily be an immutable property), and is
     *     less likely to be available at all. The creator of a chatroom
     *     is not currently available via Telepathy; if added in future, it
     *     is likely to be made available as a property on the Chatroom
     *     interface (<a href="http://bugs.freedesktop.org/show_bug.cgi?id=23151">bug 23151</a>).</p>
     * </tp:rationale>
     * 
     * <p>For channels requested by the
     *   local user, this MUST be the value of
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.SelfHandle</tp:dbus-ref>
     *   at the time the channel was created (i.e. not a channel-specific
     *   handle).</p>
     * 
     * <tp:rationale>
     *   <p>On some protocols, the SelfHandle may change (as signalled by
     *     <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.SelfHandleChanged</tp:dbus-ref>),
     *     but this property is immutable. Hence, locally-requested channels'
     *     InitiatorHandle and InitiatorID may not match the current
     *     SelfHandle; <tp:member-ref>Requested</tp:member-ref> can be used to
     *     determine whether the channel was created locally.</p>
     * </tp:rationale>
     * 
     * <p>For channels requested by a remote user, this MUST be their handle.
     *   If unavailable or not applicable, this MUST be 0 (for instance,
     *   contact lists are not really initiated by anyone in particular, and
     *   it's easy to imagine a protocol where chatroom invitations can be
     *   anonymous).</p>
     * 
     * <p>For channels with the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group</tp:dbus-ref>
     *   interface, this SHOULD be the same
     *   contact who is signalled as the &quot;Actor&quot; causing the self-handle
     *   to be placed in the local-pending set.</p>
     * 
     * <p>This SHOULD NOT be a channel-specific handle, if possible.</p>
     * 
     * <p>It does not make sense for this property to be in channel
     *   requests - the initiator will always be the local user - so it
     *   MUST NOT be accepted.</p>
     */
    Q_PROPERTY(uint InitiatorHandle READ _deprecated_InitiatorHandle)

    /**
     * Getter for the remote object property "InitiatorHandle".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitiatorHandle() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint InitiatorHandle() const
    {
        return _deprecated_InitiatorHandle();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitiatorHandle" of type uint.
     *
     * 
     * <p>The contact who initiated the channel; for instance, the contact
     *   who invited the local user to a chatroom, or the contact who
     *   initiated a call.</p>
     * 
     * <p>This does <em>not</em> necessarily represent the contact who
     *   created the underlying protocol-level construct. For instance, if
     *   Rob creates a chatroom, Will joins that chatroom, and Will invites Simon
     *   to join it, then Simon will see Will as the InitiatorHandle of the
     *   channel representing the chatroom.</p>
     * 
     * <tp:rationale>
     *   <p>The room creator is generally a less useful piece of information
     *     than the inviter, is less likely to be available at invitation
     *     time (i.e. can't necessarily be an immutable property), and is
     *     less likely to be available at all. The creator of a chatroom
     *     is not currently available via Telepathy; if added in future, it
     *     is likely to be made available as a property on the Chatroom
     *     interface (<a href="http://bugs.freedesktop.org/show_bug.cgi?id=23151">bug 23151</a>).</p>
     * </tp:rationale>
     * 
     * <p>For channels requested by the
     *   local user, this MUST be the value of
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.SelfHandle</tp:dbus-ref>
     *   at the time the channel was created (i.e. not a channel-specific
     *   handle).</p>
     * 
     * <tp:rationale>
     *   <p>On some protocols, the SelfHandle may change (as signalled by
     *     <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.SelfHandleChanged</tp:dbus-ref>),
     *     but this property is immutable. Hence, locally-requested channels'
     *     InitiatorHandle and InitiatorID may not match the current
     *     SelfHandle; <tp:member-ref>Requested</tp:member-ref> can be used to
     *     determine whether the channel was created locally.</p>
     * </tp:rationale>
     * 
     * <p>For channels requested by a remote user, this MUST be their handle.
     *   If unavailable or not applicable, this MUST be 0 (for instance,
     *   contact lists are not really initiated by anyone in particular, and
     *   it's easy to imagine a protocol where chatroom invitations can be
     *   anonymous).</p>
     * 
     * <p>For channels with the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group</tp:dbus-ref>
     *   interface, this SHOULD be the same
     *   contact who is signalled as the &quot;Actor&quot; causing the self-handle
     *   to be placed in the local-pending set.</p>
     * 
     * <p>This SHOULD NOT be a channel-specific handle, if possible.</p>
     * 
     * <p>It does not make sense for this property to be in channel
     *   requests - the initiator will always be the local user - so it
     *   MUST NOT be accepted.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitiatorHandle() const
    {
        return internalRequestProperty(QLatin1String("InitiatorHandle"));
    }

    /**
     * Represents property "InitiatorID" on the remote object.
     * 
     * <p>The string that would result from inspecting the
     *   <tp:member-ref>InitiatorHandle</tp:member-ref>
     *   property (i.e. the initiator's identifier in the IM protocol).</p>
     * 
     * <tp:rationale>
     *   <p>The presence of this property avoids the following race
     *     condition:</p>
     * 
     *   <ul>
     *     <li>New StreamedMedia channel C is signalled with initiator
     *       handle I</li>
     *     <li>Client calls <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [I])</li>
     *     <li>Channel C closes, removing the last reference to handle I</li>
     *     <li><tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [I]) returns an error</li>
     *     <li>Client can indicate that a call was missed, but not who
     *       called!</li>
     *   </ul>
     * </tp:rationale>
     * 
     * <p>It does not make sense for this property to be in channel
     *   requests - the initiator will always be the local user - so it
     *   MUST NOT be accepted.</p>
     */
    Q_PROPERTY(QString InitiatorID READ _deprecated_InitiatorID)

    /**
     * Getter for the remote object property "InitiatorID".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitiatorID() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString InitiatorID() const
    {
        return _deprecated_InitiatorID();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitiatorID" of type QString.
     *
     * 
     * <p>The string that would result from inspecting the
     *   <tp:member-ref>InitiatorHandle</tp:member-ref>
     *   property (i.e. the initiator's identifier in the IM protocol).</p>
     * 
     * <tp:rationale>
     *   <p>The presence of this property avoids the following race
     *     condition:</p>
     * 
     *   <ul>
     *     <li>New StreamedMedia channel C is signalled with initiator
     *       handle I</li>
     *     <li>Client calls <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [I])</li>
     *     <li>Channel C closes, removing the last reference to handle I</li>
     *     <li><tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>(CONTACT,
     *       [I]) returns an error</li>
     *     <li>Client can indicate that a call was missed, but not who
     *       called!</li>
     *   </ul>
     * </tp:rationale>
     * 
     * <p>It does not make sense for this property to be in channel
     *   requests - the initiator will always be the local user - so it
     *   MUST NOT be accepted.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitiatorID() const
    {
        return internalRequestProperty(QLatin1String("InitiatorID"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "Close" on the remote object.
     * 
     * Request that the channel be closed. This is not the case until the 
     * Closed signal has been emitted, and depending on the connection manager 
     * this may simply remove you from the channel on the server, rather than 
     * causing it to stop existing entirely. Some channels such as contact 
     * list channels may not be closed.
     */
    inline QDBusPendingReply<> Close()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetChannelType" on the remote object.
     * 
     * Returns the interface name for the type of this channel. Clients SHOULD 
     * use the ChannelType property instead, falling back to this method only 
     * if necessary. The GetAll method lets clients retrieve all properties in 
     * one round-trip.
     *
     * \return
     *     
     *     The interface name
     */
    inline QDBusPendingReply<QString> GetChannelType()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetHandle" on the remote object.
     * 
     * Returns the handle type and number if this channel represents a 
     * communication with a particular contact, room or server-stored list, or 
     * zero if it is transient and defined only by its contents. Clients 
     * SHOULD use the TargetHandle and TargetHandleType properties instead, 
     * falling back to this method only if necessary. The GetAll method lets 
     * clients retrieve all properties in one round-trip.
     *
     * \return
     *     
     *     The same as TargetHandleType.
     *
     * \return
     *     
     *     The same as TargetHandle.
     */
    inline QDBusPendingReply<uint, uint> GetHandle()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetInterfaces" on the remote object.
     * 
     * Get the optional interfaces implemented by the channel. Clients SHOULD 
     * use the Interfaces property instead, falling back to this method only 
     * if necessary. The GetAll method lets clients retrieve all properties in 
     * one round-trip.
     *
     * \return
     *     
     *     An array of the D-Bus interface names
     */
    inline QDBusPendingReply<QStringList> GetInterfaces()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "Closed" on the remote object.
     * 
     * Emitted when the channel has been closed. Method calls on the channel 
     * are no longer valid after this signal has been emitted, and the 
     * connection manager may then remove the object from the bus at any point.
     */
    void Closed();

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

/**
 * \class ChannelInterfaceAnonymityInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.Anonymity."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.Anonymity", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.Anonymity";
    }

    /**
     * Creates a ChannelInterfaceAnonymityInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceAnonymityInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceAnonymityInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceAnonymityInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceAnonymityInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceAnonymityInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceAnonymityInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "AnonymityModes" on the remote object.
     * 
     * The list of initially requested anonymity modes on the channel.  This
     * MUST NOT change, and is Requestable.
     */
    Q_PROPERTY(uint AnonymityModes READ _deprecated_AnonymityModes)

    /**
     * Getter for the remote object property "AnonymityModes".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyAnonymityModes() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint AnonymityModes() const
    {
        return _deprecated_AnonymityModes();
    }

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

    /**
     * Asynchronous getter for the remote object property "AnonymityModes" of type uint.
     *
     * 
     * The list of initially requested anonymity modes on the channel.  This
     * MUST NOT change, and is Requestable.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAnonymityModes() const
    {
        return internalRequestProperty(QLatin1String("AnonymityModes"));
    }

    /**
     * Represents property "AnonymityMandatory" on the remote object.
     * 
     * Whether or not the anonymity settings are required for this channel. 
     * This MUST NOT change, and is Requestable.
     */
    Q_PROPERTY(bool AnonymityMandatory READ _deprecated_AnonymityMandatory)

    /**
     * Getter for the remote object property "AnonymityMandatory".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyAnonymityMandatory() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED bool AnonymityMandatory() const
    {
        return _deprecated_AnonymityMandatory();
    }

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

    /**
     * Asynchronous getter for the remote object property "AnonymityMandatory" of type bool.
     *
     * 
     * Whether or not the anonymity settings are required for this channel. 
     * This MUST NOT change, and is Requestable.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
    {
        return internalRequestProperty(QLatin1String("AnonymityMandatory"));
    }

    /**
     * Represents property "AnonymousID" on the remote object.
     * 
     * <p>This is the ID that the remote user of the channel MAY see
     * (assuming there's a single ID).  For example, for SIP connections
     * where the From address has been scrambled by the CM, the scrambled
     * address would be available here for the client to see.  This is
     * completely optional, and MAY be an empty string (&quot;&quot;) in
     * cases where anonymity modes are not set, or the CM doesn't know
     * what the remote contact will see, or any other case where this
     * doesn't make sense.</p>
     * 
     * <p>This MAY change over the lifetime of the channel, and SHOULD NOT
     * be used with the Request interface.</p>
     */
    Q_PROPERTY(QString AnonymousID READ _deprecated_AnonymousID)

    /**
     * Getter for the remote object property "AnonymousID".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyAnonymousID() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString AnonymousID() const
    {
        return _deprecated_AnonymousID();
    }

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

    /**
     * Asynchronous getter for the remote object property "AnonymousID" of type QString.
     *
     * 
     * <p>This is the ID that the remote user of the channel MAY see
     * (assuming there's a single ID).  For example, for SIP connections
     * where the From address has been scrambled by the CM, the scrambled
     * address would be available here for the client to see.  This is
     * completely optional, and MAY be an empty string (&quot;&quot;) in
     * cases where anonymity modes are not set, or the CM doesn't know
     * what the remote contact will see, or any other case where this
     * doesn't make sense.</p>
     * 
     * <p>This MAY change over the lifetime of the channel, and SHOULD NOT
     * be used with the Request interface.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAnonymousID() const
    {
        return internalRequestProperty(QLatin1String("AnonymousID"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

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

/**
 * \class ChannelInterfaceCallStateInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.CallState."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.CallState", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.CallState";
    }

    /**
     * Creates a ChannelInterfaceCallStateInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceCallStateInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceCallStateInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceCallStateInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceCallStateInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceCallStateInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceCallStateInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "GetCallStates" on the remote object.
     * 
     * Get the current call states for all contacts involved in this call.
     *
     * \return
     *     
     *     The current call states. Participants where the call state flags 
     *     would be 0 (all unset) may be omitted from this mapping.
     */
    inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "CallStateChanged" on the remote object.
     * 
     * Emitted when the state of a member of the channel has changed.
     *
     * \param contact
     *     
     *     An integer handle for the contact.
     *
     * \param state
     *     
     *     The new state for this contact.
     */
    void CallStateChanged(uint contact, uint state);

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

/**
 * \class ChannelInterfaceChatStateInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.ChatState."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.ChatState", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
    }

    /**
     * Creates a ChannelInterfaceChatStateInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceChatStateInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceChatStateInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceChatStateInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceChatStateInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceChatStateInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceChatStateInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "ChatStates" on the remote object.
     * 
     * <p>A map containing the chat states of all contacts in this
     *   channel whose chat state is not Inactive.</p>
     * 
     * <p>Contacts in this channel, but who are not listed in this map,
     *   may be assumed to be in the Inactive state.</p>
     * 
     * <p>In implementations that do not have this property, its value may be
     *   assumed to be empty until a
     *   <tp:member-ref>ChatStateChanged</tp:member-ref> signal indicates
     *   otherwise.</p>
     * 
     * <tp:rationale>
     *   <p>This property was not present in older versions of telepathy-spec,
     *     because chat states in XMPP are not state-recoverable (if you
     *     miss the change notification signal, there's no way to know the
     *     state). However, this property still allows clients to recover
     *     state changes that were seen by the CM before the client started
     *     to deal with the channel.</p>
     * 
     *   <p>In CMs that follow older spec versions, assuming Inactive will
     *     mean that initial chat states will always be assumed to be
     *     Inactive, which is the best we can do. XEP 0085 specifies
     *     Inactive as the &quot;neutral&quot; state to be assumed unless told
     *     otherwise.</p>
     * </tp:rationale>
     */
    Q_PROPERTY(Tp::ChatStateMap ChatStates READ _deprecated_ChatStates)

    /**
     * Getter for the remote object property "ChatStates".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyChatStates() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::ChatStateMap ChatStates() const
    {
        return _deprecated_ChatStates();
    }

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

    /**
     * Asynchronous getter for the remote object property "ChatStates" of type Tp::ChatStateMap.
     *
     * 
     * <p>A map containing the chat states of all contacts in this
     *   channel whose chat state is not Inactive.</p>
     * 
     * <p>Contacts in this channel, but who are not listed in this map,
     *   may be assumed to be in the Inactive state.</p>
     * 
     * <p>In implementations that do not have this property, its value may be
     *   assumed to be empty until a
     *   <tp:member-ref>ChatStateChanged</tp:member-ref> signal indicates
     *   otherwise.</p>
     * 
     * <tp:rationale>
     *   <p>This property was not present in older versions of telepathy-spec,
     *     because chat states in XMPP are not state-recoverable (if you
     *     miss the change notification signal, there's no way to know the
     *     state). However, this property still allows clients to recover
     *     state changes that were seen by the CM before the client started
     *     to deal with the channel.</p>
     * 
     *   <p>In CMs that follow older spec versions, assuming Inactive will
     *     mean that initial chat states will always be assumed to be
     *     Inactive, which is the best we can do. XEP 0085 specifies
     *     Inactive as the &quot;neutral&quot; state to be assumed unless told
     *     otherwise.</p>
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyChatStates() const
    {
        return internalRequestProperty(QLatin1String("ChatStates"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "SetChatState" on the remote object.
     * 
     * Set the local state and notify other members of the channel that it has 
     * changed.
     *
     * \param state
     *     
     *     The new state.
     */
    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:
    /**
     * Represents the signal "ChatStateChanged" on the remote object.
     * 
     * Emitted when the state of a member of the channel has changed. This 
     * includes local state.
     *
     * \param contact
     *     
     *     An integer handle for the contact.
     *
     * \param state
     *     
     *     The new state of this contact.
     */
    void ChatStateChanged(uint contact, uint state);

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

/**
 * \class ChannelInterfaceConferenceInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.Conference."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.Conference", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.Conference";
    }

    /**
     * Creates a ChannelInterfaceConferenceInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceConferenceInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceConferenceInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceConferenceInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceConferenceInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceConferenceInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceConferenceInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "Channels" on the remote object.
     * 
     *  <p>The individual <tp:dbus-ref namespace="org.freedesktop.Telepathy">Channel</tp:dbus-ref>s that
     *    are continued by this conference, which have the same <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">ChannelType</tp:dbus-ref> as this one, but with <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandleType</tp:dbus-ref> = CONTACT.</p>
     * 
     *  <p>This property MUST NOT be requestable; instead, the
     *    <tp:member-ref>InitialChannels</tp:member-ref> property may be
     *    specified when requesting a channel.</p>
     * 
     *  <tp:rationale>
     *    <p>This is consistent with requesting
     *      <tp:member-ref>InitialInviteeHandles</tp:member-ref> and
     *      <tp:member-ref>InitialInviteeIDs</tp:member-ref>, rather than
     *      requesting <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.Members</tp:dbus-ref>
     *      and some hypothetical ID version of that property.</p>
     * </tp:rationale>
     * 
     *  <p>Change notification is via the
     *    <tp:member-ref>ChannelMerged</tp:member-ref> and
     *    <tp:member-ref>ChannelRemoved</tp:member-ref> signals.</p>
     */
    Q_PROPERTY(Tp::ObjectPathList Channels READ _deprecated_Channels)

    /**
     * Getter for the remote object property "Channels".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyChannels() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::ObjectPathList Channels() const
    {
        return _deprecated_Channels();
    }

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

    /**
     * Asynchronous getter for the remote object property "Channels" of type Tp::ObjectPathList.
     *
     * 
     *  <p>The individual <tp:dbus-ref namespace="org.freedesktop.Telepathy">Channel</tp:dbus-ref>s that
     *    are continued by this conference, which have the same <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">ChannelType</tp:dbus-ref> as this one, but with <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandleType</tp:dbus-ref> = CONTACT.</p>
     * 
     *  <p>This property MUST NOT be requestable; instead, the
     *    <tp:member-ref>InitialChannels</tp:member-ref> property may be
     *    specified when requesting a channel.</p>
     * 
     *  <tp:rationale>
     *    <p>This is consistent with requesting
     *      <tp:member-ref>InitialInviteeHandles</tp:member-ref> and
     *      <tp:member-ref>InitialInviteeIDs</tp:member-ref>, rather than
     *      requesting <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.Members</tp:dbus-ref>
     *      and some hypothetical ID version of that property.</p>
     * </tp:rationale>
     * 
     *  <p>Change notification is via the
     *    <tp:member-ref>ChannelMerged</tp:member-ref> and
     *    <tp:member-ref>ChannelRemoved</tp:member-ref> signals.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyChannels() const
    {
        return internalRequestProperty(QLatin1String("Channels"));
    }

    /**
     * Represents property "InitialChannels" on the remote object.
     * 
     * <p>The initial value of <tp:member-ref>Channels</tp:member-ref>.</p>
     * 
     * <p>This property SHOULD be requestable. Omitting it from a request is
     *   equivalent to providing it with an empty list as value. Requests
     *   where its value has at least two channel paths SHOULD be expected to
     *   succeed on any implementation of this interface. If
     *   <tp:member-ref>InitialInviteeHandles</tp:member-ref> and
     *   <tp:member-ref>InitialInviteeIDs</tp:member-ref> are
     *   <var>Allowed_Properties</var> in <tp:dbus-ref namespace="ofdT.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>, then requests with zero
     *   or one channel paths SHOULD also succeed; otherwise, clients SHOULD
     *   NOT make requests with zero or one paths for this property.</p>
     * 
     * <tp:rationale>
     *   <p>In GSM, a pair of calls can be merged into a conference, but you
     *     can't start a conference call from zero or one existing calls. In
     *     XMPP and MSN, you can create a new chatroom, or upgrade one 1-1
     *     channel into a chatroom; however, on these protocols, it is also
     *     possible to fake GSM-style merging by upgrading the first channel,
     *     then inviting the targets of all the other channels into it.</p>
     * </tp:rationale>
     * 
     * <p>If possible, the <tp:member-ref>Channels</tp:member-ref>' states SHOULD
     *   NOT be altered by merging them into a conference. However, depending on
     *   the protocol, the Channels MAY be placed in a &quot;frozen&quot; state by placing
     *   them in this property's value or by calling
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">MergeableConference.DRAFT.Merge</tp:dbus-ref> on them.</p>
     * 
     * <tp:rationale>
     *   <p>In Jingle, nothing special will happen to merged calls. UIs MAY
     *     automatically place calls on hold before merging them, if that is
     *     the desired behaviour; this SHOULD always work. Not doing
     *     an implicit hold/unhold seems to preserve least-astonishment.</p>
     * 
     *   <p>In GSM, the calls that are merged go into a state similar to
     *     Hold, but they cannot be unheld, only split from the conference
     *     call using <tp:dbus-ref namespace="org.freedesktop.Telepathy">Channel.Interface.Splittable.DRAFT.Split</tp:dbus-ref>.</p>
     * </tp:rationale>
     * 
     * <p>Depending on the protocol, it might be signalled to remote users
     *   that this channel is a continuation of all the requested channels,
     *   or that it is only a continuation of the first channel in the
     *   list.</p>
     * 
     * <tp:rationale>
     *   <p>In MSN, the conference steals the underlying switchboard (protocol
     *     construct) from one of its component channels, so the conference
     *     appears to remote users to be a continuation of that channel and no
     *     other. The connection manager has to make some arbitrary choice, so
     *     we arbitrarily mandate that it SHOULD choose the first channel in
     *     the list as the one to continue.</p>
     * </tp:rationale>
     * 
     * <p>This property is immutable.</p>
     */
    Q_PROPERTY(Tp::ObjectPathList InitialChannels READ _deprecated_InitialChannels)

    /**
     * Getter for the remote object property "InitialChannels".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialChannels() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::ObjectPathList InitialChannels() const
    {
        return _deprecated_InitialChannels();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialChannels" of type Tp::ObjectPathList.
     *
     * 
     * <p>The initial value of <tp:member-ref>Channels</tp:member-ref>.</p>
     * 
     * <p>This property SHOULD be requestable. Omitting it from a request is
     *   equivalent to providing it with an empty list as value. Requests
     *   where its value has at least two channel paths SHOULD be expected to
     *   succeed on any implementation of this interface. If
     *   <tp:member-ref>InitialInviteeHandles</tp:member-ref> and
     *   <tp:member-ref>InitialInviteeIDs</tp:member-ref> are
     *   <var>Allowed_Properties</var> in <tp:dbus-ref namespace="ofdT.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>, then requests with zero
     *   or one channel paths SHOULD also succeed; otherwise, clients SHOULD
     *   NOT make requests with zero or one paths for this property.</p>
     * 
     * <tp:rationale>
     *   <p>In GSM, a pair of calls can be merged into a conference, but you
     *     can't start a conference call from zero or one existing calls. In
     *     XMPP and MSN, you can create a new chatroom, or upgrade one 1-1
     *     channel into a chatroom; however, on these protocols, it is also
     *     possible to fake GSM-style merging by upgrading the first channel,
     *     then inviting the targets of all the other channels into it.</p>
     * </tp:rationale>
     * 
     * <p>If possible, the <tp:member-ref>Channels</tp:member-ref>' states SHOULD
     *   NOT be altered by merging them into a conference. However, depending on
     *   the protocol, the Channels MAY be placed in a &quot;frozen&quot; state by placing
     *   them in this property's value or by calling
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">MergeableConference.DRAFT.Merge</tp:dbus-ref> on them.</p>
     * 
     * <tp:rationale>
     *   <p>In Jingle, nothing special will happen to merged calls. UIs MAY
     *     automatically place calls on hold before merging them, if that is
     *     the desired behaviour; this SHOULD always work. Not doing
     *     an implicit hold/unhold seems to preserve least-astonishment.</p>
     * 
     *   <p>In GSM, the calls that are merged go into a state similar to
     *     Hold, but they cannot be unheld, only split from the conference
     *     call using <tp:dbus-ref namespace="org.freedesktop.Telepathy">Channel.Interface.Splittable.DRAFT.Split</tp:dbus-ref>.</p>
     * </tp:rationale>
     * 
     * <p>Depending on the protocol, it might be signalled to remote users
     *   that this channel is a continuation of all the requested channels,
     *   or that it is only a continuation of the first channel in the
     *   list.</p>
     * 
     * <tp:rationale>
     *   <p>In MSN, the conference steals the underlying switchboard (protocol
     *     construct) from one of its component channels, so the conference
     *     appears to remote users to be a continuation of that channel and no
     *     other. The connection manager has to make some arbitrary choice, so
     *     we arbitrarily mandate that it SHOULD choose the first channel in
     *     the list as the one to continue.</p>
     * </tp:rationale>
     * 
     * <p>This property is immutable.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialChannels() const
    {
        return internalRequestProperty(QLatin1String("InitialChannels"));
    }

    /**
     * Represents property "InitialInviteeHandles" on the remote object.
     * 
     * <p>A list of additional contacts invited to this conference when it
     *   was created.</p>
     * 
     * <p>If it is possible to invite new contacts when creating a conference
     *   (as opposed to merging several channels into one new conference
     *   channel), this property SHOULD be requestable, and appear in the allowed
     *   properties in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>. Otherwise, this property
     *   SHOULD NOT be requestable, and its value SHOULD always be the empty
     *   list.</p>
     * 
     * <tp:rationale>
     *   <p>On GSM you have to place a 1-1 call before you can merge it into a
     *     conference; on the other hand, you can invite new contacts to XMPP
     *     Muji calls and XMPP/MSN/Skype ad-hoc chat rooms without starting a
     *     1-1 channel with them first.</p>
     * </tp:rationale>
     * 
     * <p>If included in a request, the given contacts are automatically
     *   invited into the new channel, as if they had been added with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.AddMembers</tp:dbus-ref>(InitialInviteeHandles,
     *   <tp:member-ref>InvitationMessage</tp:member-ref>) immediately after
     *   the channel was created.</p>
     * 
     * <tp:rationale>
     *   <p>This is a simple convenience API for the common case that a UI
     *     upgrades a 1-1 chat to a multi-user chat solely in order to invite
     *     someone else to participate.</p>
     * </tp:rationale>
     * 
     * <p>If the local user was not the initiator of this channel, the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.SelfHandle</tp:dbus-ref> SHOULD appear in the value of this
     *   property, together with any other contacts invited at the same time
     *   (if that information is known).</p>
     * 
     * <p>This property is immutable.</p>
     * 
     * <p>InitialInviteeHandles, InitialInviteeIDs and InitialChannels MAY be
     *   combined in a single request.</p>
     * 
     * <tp:rationale>
     *   <p>For example, if you have a 1-1 channel C1 with Rob, and you want
     *     to invite Sjoerd to join the discussion, you can do so by
     *     requesting a channel with InitialChannels=[C1] and
     *     InitialInviteeHandles=[sjoerd],
     *     or InitialChannels=[C1] and
     *     InitialInviteeIDs=[&quot;sjoerd@example.com&quot;].</p>
     * </tp:rationale>
     * 
     * <p>If a request includes some combination of InitialInviteeHandles,
     *   InitialInviteeIDs and InitialChannels, then the value of
     *   InitialInviteeHandles on the resulting channel SHOULD be the union of
     *   the handles from InitialInviteeHandles, the handles corresponding
     *   to the InitialInviteeIDs, and the target handles of the
     *   InitialChannels, with any duplicate handles removed. Because this
     *   property is immutable, its value SHOULD be computed before the
     *   channel is announced via the NewChannels signal.</p>
     * 
     * <tp:rationale>
     *   <p>This simplifies identification of new channels in clients - they
     *     only have to look at one of the properties, not both. For example,
     *     after either of the requests mentioned above, the NewChannels
     *     signal would announce the channel with InitialChannels=[C1],
     *     InitialInviteeHandles=[rob, sjoerd], and
     *     InitialInviteeIDs=[&quot;rob@example.net&quot;, &quot;sjoerd.example.com&quot;].</p>
     * </tp:rationale>
     */
    Q_PROPERTY(Tp::UIntList InitialInviteeHandles READ _deprecated_InitialInviteeHandles)

    /**
     * Getter for the remote object property "InitialInviteeHandles".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialInviteeHandles() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::UIntList InitialInviteeHandles() const
    {
        return _deprecated_InitialInviteeHandles();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialInviteeHandles" of type Tp::UIntList.
     *
     * 
     * <p>A list of additional contacts invited to this conference when it
     *   was created.</p>
     * 
     * <p>If it is possible to invite new contacts when creating a conference
     *   (as opposed to merging several channels into one new conference
     *   channel), this property SHOULD be requestable, and appear in the allowed
     *   properties in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>. Otherwise, this property
     *   SHOULD NOT be requestable, and its value SHOULD always be the empty
     *   list.</p>
     * 
     * <tp:rationale>
     *   <p>On GSM you have to place a 1-1 call before you can merge it into a
     *     conference; on the other hand, you can invite new contacts to XMPP
     *     Muji calls and XMPP/MSN/Skype ad-hoc chat rooms without starting a
     *     1-1 channel with them first.</p>
     * </tp:rationale>
     * 
     * <p>If included in a request, the given contacts are automatically
     *   invited into the new channel, as if they had been added with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.AddMembers</tp:dbus-ref>(InitialInviteeHandles,
     *   <tp:member-ref>InvitationMessage</tp:member-ref>) immediately after
     *   the channel was created.</p>
     * 
     * <tp:rationale>
     *   <p>This is a simple convenience API for the common case that a UI
     *     upgrades a 1-1 chat to a multi-user chat solely in order to invite
     *     someone else to participate.</p>
     * </tp:rationale>
     * 
     * <p>If the local user was not the initiator of this channel, the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.SelfHandle</tp:dbus-ref> SHOULD appear in the value of this
     *   property, together with any other contacts invited at the same time
     *   (if that information is known).</p>
     * 
     * <p>This property is immutable.</p>
     * 
     * <p>InitialInviteeHandles, InitialInviteeIDs and InitialChannels MAY be
     *   combined in a single request.</p>
     * 
     * <tp:rationale>
     *   <p>For example, if you have a 1-1 channel C1 with Rob, and you want
     *     to invite Sjoerd to join the discussion, you can do so by
     *     requesting a channel with InitialChannels=[C1] and
     *     InitialInviteeHandles=[sjoerd],
     *     or InitialChannels=[C1] and
     *     InitialInviteeIDs=[&quot;sjoerd@example.com&quot;].</p>
     * </tp:rationale>
     * 
     * <p>If a request includes some combination of InitialInviteeHandles,
     *   InitialInviteeIDs and InitialChannels, then the value of
     *   InitialInviteeHandles on the resulting channel SHOULD be the union of
     *   the handles from InitialInviteeHandles, the handles corresponding
     *   to the InitialInviteeIDs, and the target handles of the
     *   InitialChannels, with any duplicate handles removed. Because this
     *   property is immutable, its value SHOULD be computed before the
     *   channel is announced via the NewChannels signal.</p>
     * 
     * <tp:rationale>
     *   <p>This simplifies identification of new channels in clients - they
     *     only have to look at one of the properties, not both. For example,
     *     after either of the requests mentioned above, the NewChannels
     *     signal would announce the channel with InitialChannels=[C1],
     *     InitialInviteeHandles=[rob, sjoerd], and
     *     InitialInviteeIDs=[&quot;rob@example.net&quot;, &quot;sjoerd.example.com&quot;].</p>
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
    {
        return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
    }

    /**
     * Represents property "InitialInviteeIDs" on the remote object.
     * 
     * <p>A list of additional contacts invited to this conference when it
     *   was created.</p>
     * 
     * <p>This property SHOULD be requestable if and only if
     *   <tp:member-ref>InitialInviteeHandles</tp:member-ref> is requestable.
     *   Its semantics are the same, except that it takes a list of the
     *   string representations of contact handles; invitations are sent to
     *   any contact present in either or both of these properties.</p>
     * 
     * <p>When a channel is created, the values of InitialInviteeHandles and
     *   InitialInviteeIDs MUST correspond to each other. In particular, this
     *   means that the value of InitialInviteeIDs will include the TargetID
     *   of each channel in InitialChannels, and the ID corresponding to each
     *   handle in InitialInviteeHandles.</p>
     * 
     * <p>This property is immutable.</p>
     */
    Q_PROPERTY(QStringList InitialInviteeIDs READ _deprecated_InitialInviteeIDs)

    /**
     * Getter for the remote object property "InitialInviteeIDs".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialInviteeIDs() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QStringList InitialInviteeIDs() const
    {
        return _deprecated_InitialInviteeIDs();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialInviteeIDs" of type QStringList.
     *
     * 
     * <p>A list of additional contacts invited to this conference when it
     *   was created.</p>
     * 
     * <p>This property SHOULD be requestable if and only if
     *   <tp:member-ref>InitialInviteeHandles</tp:member-ref> is requestable.
     *   Its semantics are the same, except that it takes a list of the
     *   string representations of contact handles; invitations are sent to
     *   any contact present in either or both of these properties.</p>
     * 
     * <p>When a channel is created, the values of InitialInviteeHandles and
     *   InitialInviteeIDs MUST correspond to each other. In particular, this
     *   means that the value of InitialInviteeIDs will include the TargetID
     *   of each channel in InitialChannels, and the ID corresponding to each
     *   handle in InitialInviteeHandles.</p>
     * 
     * <p>This property is immutable.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
    {
        return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
    }

    /**
     * Represents property "InvitationMessage" on the remote object.
     * 
     * <p>The message that was sent to the
     *   <tp:member-ref>InitialInviteeHandles</tp:member-ref> when they were
     *   invited.</p>
     * 
     * <p>This property SHOULD be requestable, and appear in the allowed
     *   properties in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>, in protocols where
     *   invitations can have an accompanying text message.</p>
     * 
     * <tp:rationale>
     *   <p>This allows invitations with a message to be sent when using
     *     <tp:member-ref>InitialInviteeHandles</tp:member-ref> or
     *     <tp:member-ref>InitialInviteeIDs</tp:member-ref>.</p>
     * </tp:rationale>
     * 
     * <p>If the local user was not the initiator of this channel, the
     *   message with which they were invited (if any) SHOULD appear in the
     *   value of this property.</p>
     * 
     * <p>This property is immutable.</p>
     */
    Q_PROPERTY(QString InvitationMessage READ _deprecated_InvitationMessage)

    /**
     * Getter for the remote object property "InvitationMessage".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInvitationMessage() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString InvitationMessage() const
    {
        return _deprecated_InvitationMessage();
    }

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

    /**
     * Asynchronous getter for the remote object property "InvitationMessage" of type QString.
     *
     * 
     * <p>The message that was sent to the
     *   <tp:member-ref>InitialInviteeHandles</tp:member-ref> when they were
     *   invited.</p>
     * 
     * <p>This property SHOULD be requestable, and appear in the allowed
     *   properties in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>, in protocols where
     *   invitations can have an accompanying text message.</p>
     * 
     * <tp:rationale>
     *   <p>This allows invitations with a message to be sent when using
     *     <tp:member-ref>InitialInviteeHandles</tp:member-ref> or
     *     <tp:member-ref>InitialInviteeIDs</tp:member-ref>.</p>
     * </tp:rationale>
     * 
     * <p>If the local user was not the initiator of this channel, the
     *   message with which they were invited (if any) SHOULD appear in the
     *   value of this property.</p>
     * 
     * <p>This property is immutable.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInvitationMessage() const
    {
        return internalRequestProperty(QLatin1String("InvitationMessage"));
    }

    /**
     * Represents property "OriginalChannels" on the remote object.
     * 
     * <p>On GSM conference calls, it is possible to have the same phone
     *   number in a conference twice; for instance, it could be the number of
     *   a corporate switchboard. This is represented using channel-specific
     *   handles; whether or not a channel uses channel-specific handles is
     *   reported in <tp:dbus-ref namespace="ofdT.Channel.Interface">Group.GroupFlags</tp:dbus-ref>.
     *   The <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.HandleOwners</tp:dbus-ref>
     *   property specifies the mapping from opaque channel-specific handles
     *   to actual numbers; this property specifies the original 1-1 channel
     *   corresponding to each channel-specific handle in the conference.</p>
     * 
     * <p>In protocols where this situation cannot arise, such as XMPP,
     *   this property MAY remain empty.</p>
     * 
     * <p>For example, consider this situation:</p>
     * 
     * <ol>
     *   <li>Place a call (with path <tt>/call/to/simon</tt>) to the contact
     *     <tt>+441234567890</tt> (which is assigned the handle <var>h</var>,
     *     say), and ask to be put through to Simon McVittie;</li>
     *   <li>Put that call on hold;</li>
     *   <li>Place another call (with path <tt>/call/to/jonny</tt>) to
     *     <tt>+441234567890</tt>, and ask to be put
     *     through to Jonny Lamb;</li>
     *   <li>Request a new channel with
     *     <tp:member-ref>InitialChannels</tp:member-ref>:
     *     <tt>['/call/to/simon', '/call/to/jonny']</tt>.</li>
     * </ol>
     * 
     * <p>The new channel will have the following properties, for some handles
     *   <var>s</var> and <var>j</var>:</p>
     * 
     * <blockquote>
     *   <code>{<br/>
     *     ...<tp:dbus-ref namespace="ofdT.Channel.Interface">Group.GroupFlags</tp:dbus-ref>:
     *         Channel_Specific_Handles | (other flags),<br/>
     *     ...<tp:dbus-ref namespace="ofdT.Channel.Interface">Group.Members</tp:dbus-ref>:
     *         [self_handle, s, j],<br/>
     *     ...<tp:dbus-ref namespace="ofdT.Channel.Interface">Group.HandleOwners</tp:dbus-ref>:
     *         { s: h, j: h },<br/>
     *     ...<tp:member-ref>InitialChannels</tp:member-ref>:
     *         ['/call/to/simon', '/call/to/jonny'],<br/>
     *     ...<tp:member-ref>Channels</tp:member-ref>:
     *         ['/call/to/simon', '/call/to/jonny'],<br/>
     *     ...<tp:member-ref>OriginalChannels</tp:member-ref>:
     *         { s: '/call/to/simon', j: '/call/to/jonny' },<br/>
     *     # ...standard properties like ChannelType: Group elided...<br/>
     *   }</code>
     * </blockquote>
     * 
     * <p>Change notification is via the
     *   <tp:member-ref>ChannelMerged</tp:member-ref> and
     *   <tp:member-ref>ChannelRemoved</tp:member-ref> signals: if
     *   <var>Channel_Specific_Handle</var> in the former is non-zero, this
     *   property SHOULD be updated to map that handle to the merged channel's
     *   path.</p>
     */
    Q_PROPERTY(Tp::ChannelOriginatorMap OriginalChannels READ _deprecated_OriginalChannels)

    /**
     * Getter for the remote object property "OriginalChannels".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyOriginalChannels() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::ChannelOriginatorMap OriginalChannels() const
    {
        return _deprecated_OriginalChannels();
    }

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

    /**
     * Asynchronous getter for the remote object property "OriginalChannels" of type Tp::ChannelOriginatorMap.
     *
     * 
     * <p>On GSM conference calls, it is possible to have the same phone
     *   number in a conference twice; for instance, it could be the number of
     *   a corporate switchboard. This is represented using channel-specific
     *   handles; whether or not a channel uses channel-specific handles is
     *   reported in <tp:dbus-ref namespace="ofdT.Channel.Interface">Group.GroupFlags</tp:dbus-ref>.
     *   The <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.HandleOwners</tp:dbus-ref>
     *   property specifies the mapping from opaque channel-specific handles
     *   to actual numbers; this property specifies the original 1-1 channel
     *   corresponding to each channel-specific handle in the conference.</p>
     * 
     * <p>In protocols where this situation cannot arise, such as XMPP,
     *   this property MAY remain empty.</p>
     * 
     * <p>For example, consider this situation:</p>
     * 
     * <ol>
     *   <li>Place a call (with path <tt>/call/to/simon</tt>) to the contact
     *     <tt>+441234567890</tt> (which is assigned the handle <var>h</var>,
     *     say), and ask to be put through to Simon McVittie;</li>
     *   <li>Put that call on hold;</li>
     *   <li>Place another call (with path <tt>/call/to/jonny</tt>) to
     *     <tt>+441234567890</tt>, and ask to be put
     *     through to Jonny Lamb;</li>
     *   <li>Request a new channel with
     *     <tp:member-ref>InitialChannels</tp:member-ref>:
     *     <tt>['/call/to/simon', '/call/to/jonny']</tt>.</li>
     * </ol>
     * 
     * <p>The new channel will have the following properties, for some handles
     *   <var>s</var> and <var>j</var>:</p>
     * 
     * <blockquote>
     *   <code>{<br/>
     *     ...<tp:dbus-ref namespace="ofdT.Channel.Interface">Group.GroupFlags</tp:dbus-ref>:
     *         Channel_Specific_Handles | (other flags),<br/>
     *     ...<tp:dbus-ref namespace="ofdT.Channel.Interface">Group.Members</tp:dbus-ref>:
     *         [self_handle, s, j],<br/>
     *     ...<tp:dbus-ref namespace="ofdT.Channel.Interface">Group.HandleOwners</tp:dbus-ref>:
     *         { s: h, j: h },<br/>
     *     ...<tp:member-ref>InitialChannels</tp:member-ref>:
     *         ['/call/to/simon', '/call/to/jonny'],<br/>
     *     ...<tp:member-ref>Channels</tp:member-ref>:
     *         ['/call/to/simon', '/call/to/jonny'],<br/>
     *     ...<tp:member-ref>OriginalChannels</tp:member-ref>:
     *         { s: '/call/to/simon', j: '/call/to/jonny' },<br/>
     *     # ...standard properties like ChannelType: Group elided...<br/>
     *   }</code>
     * </blockquote>
     * 
     * <p>Change notification is via the
     *   <tp:member-ref>ChannelMerged</tp:member-ref> and
     *   <tp:member-ref>ChannelRemoved</tp:member-ref> signals: if
     *   <var>Channel_Specific_Handle</var> in the former is non-zero, this
     *   property SHOULD be updated to map that handle to the merged channel's
     *   path.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyOriginalChannels() const
    {
        return internalRequestProperty(QLatin1String("OriginalChannels"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

Q_SIGNALS:
    /**
     * Represents the signal "ChannelMerged" on the remote object.
     * 
     * <p>Emitted when a new channel is added to the value of
     *   <tp:member-ref>Channels</tp:member-ref>.</p>
     *
     * \param channel
     *     
     *     The channel that was added to Channels.
     *
     * \param channelSpecificHandle
     *     
     *     A new channel-specific handle for the TargetHandle of Channel, as 
     *     will appear in OriginalChannels, or 0 if a global handle is used 
     *     for Channel&apos;s TargetHandle on the Group interface of this 
     *     channel.
     *
     * \param properties
     *     
     *     Channel&apos;s immutable properties.
     */
    void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);

    /**
     * Represents the signal "ChannelRemoved" on the remote object.
     * 
     * <p>Emitted when a channel is removed from the value of
     *   <tp:member-ref>Channels</tp:member-ref>, either because it closed
     *   or because it was split using the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Splittable.DRAFT.Split</tp:dbus-ref> method.</p>
     * 
     * <p>If a channel is removed because it was closed, <tp:dbus-ref namespace="ofdT.Channel">Closed</tp:dbus-ref> should be emitted
     *   before this signal.</p>
     *
     * \param channel
     *     
     *     The channel that was removed from Channels.
     *
     * \param details
     *     
     *     Additional information about the removal, which may include
     *     the same well-known keys as the Details argument of
     *     <tp:dbus-ref namespace="ofdT.Channel.Interface.Group">MembersChangedDetailed</tp:dbus-ref>, with the same semantics.
     */
    void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);

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

/**
 * \class ChannelInterfaceDTMFInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.DTMF."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.DTMF", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
    }

    /**
     * Creates a ChannelInterfaceDTMFInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceDTMFInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceDTMFInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceDTMFInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceDTMFInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceDTMFInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceDTMFInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "CurrentlySendingTones" on the remote object.
     * 
     * Indicates whether there are DTMF tones currently being sent in the 
     * channel. If so, the client should wait for StoppedTones signal before 
     * trying to send more tones.
     */
    Q_PROPERTY(bool CurrentlySendingTones READ _deprecated_CurrentlySendingTones)

    /**
     * Getter for the remote object property "CurrentlySendingTones".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyCurrentlySendingTones() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED bool CurrentlySendingTones() const
    {
        return _deprecated_CurrentlySendingTones();
    }

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

    /**
     * Asynchronous getter for the remote object property "CurrentlySendingTones" of type bool.
     *
     * 
     * Indicates whether there are DTMF tones currently being sent in the 
     * channel. If so, the client should wait for StoppedTones signal before 
     * trying to send more tones.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
    {
        return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
    }

    /**
     * Represents property "InitialTones" on the remote object.
     * 
     * If non-empty in a channel request that will create a new channel, the 
     * connection manager should send the tones immediately after at least one 
     * eligible audio stream has been created in the channel. This property is 
     * immutable (cannot change).
     */
    Q_PROPERTY(QString InitialTones READ _deprecated_InitialTones)

    /**
     * Getter for the remote object property "InitialTones".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialTones() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString InitialTones() const
    {
        return _deprecated_InitialTones();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialTones" of type QString.
     *
     * 
     * If non-empty in a channel request that will create a new channel, the 
     * connection manager should send the tones immediately after at least one 
     * eligible audio stream has been created in the channel. This property is 
     * immutable (cannot change).
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialTones() const
    {
        return internalRequestProperty(QLatin1String("InitialTones"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "StartTone" on the remote object.
     * 
     * Start sending a DTMF tone to all eligible streams in the channel. Where 
     * possible, the tone will continue until StopTone is called. On certain 
     * protocols, it may only be possible to send events with a predetermined 
     * length. In this case, the implementation MAY emit a fixed-length tone, 
     * and the StopTone method call SHOULD return NotAvailable. The client may 
     * wish to control the exact duration and timing of the tones sent as a 
     * result of user&apos;s interaction with the dialpad, thus starting and 
     * stopping the tone sending explicitly. Tone overlaping or queueing is 
     * not supported, so this method can only be called if no DTMF tones are 
     * already being played.
     *
     * \param streamID
     *     
     *     A stream ID as defined in the StreamedMedia channel type. This 
     *     argument is included for backwards compatibility and MUST be 
     *     ignored by the implementations - the tone SHOULD be sent to all 
     *     eligible streams in the channel.
     *
     * \param event
     *     
     *     A numeric event code from the DTMF_Event enum.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "StopTone" on the remote object.
     * 
     * Stop sending any DTMF tones which have been started using the StartTone 
     * or MultipleTones methods. If there is no current tone, this method will 
     * do nothing. If MultipleTones was used, the client should not assume the 
     * sending has stopped immediately; instead, the client should wait for 
     * the StoppedTones signal. On some protocols it might be impossible to 
     * cancel queued tones immediately.
     *
     * \param streamID
     *     
     *     A stream ID as defined in the StreamedMedia channel type. This 
     *     argument is included for backwards compatibility and MUST be 
     *     ignored by the implementations - the sending SHOULD be stoped in 
     *     all eligible streams in the channel.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "MultipleTones" on the remote object.
     * 
     * Send multiple DTMF events to all eligible streams in the channel. Each 
     * character in the Tones string must be a valid DTMF event (as defined by 
     * RFC4733). Each tone will be played for a pre-defined number of 
     * milliseconds, followed by a pause before the next tone is played. The 
     * duration/pause is defined by the protocol or connection manager. In 
     * cases where the client knows in advance the tone sequence it wants to 
     * send, it&apos;s easier to use this method than manually start and stop 
     * each tone in the sequence. Tone overlaping or queueing is not 
     * supported, so this method can only be called if no DTMF tones are 
     * already being played.
     *
     * \param tones
     *     
     *     A string representation of one or more DTMF events.
     */
    inline QDBusPendingReply<> MultipleTones(const QString& tones)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "SendingTones" on the remote object.
     * 
     * <p>DTMF tone(s)are being sent to all eligible streams in the channel.
     * The signal is provided to indicating the fact that the streams are
     * currently being used to send one or more DTMF tones, so any other
     * media input is not getting through to the audio stream. It also
     * serves as a cue for the
     * <tp:member-ref>StopTone</tp:member-ref> method.</p>
     *
     * \param tones
     *     
     *     DTMF string (one or more events) that is to be played.
     */
    void SendingTones(const QString& tones);

    /**
     * Represents the signal "StoppedTones" on the remote object.
     * 
     * <p>DTMF tones have finished playing on streams in this channel.</p>
     *
     * \param cancelled
     *     
     *     True if the DTMF tones were actively cancelled via StopTone.
     */
    void StoppedTones(bool cancelled);

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

/**
 * \class ChannelInterfaceGroupInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.Group."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.Group", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.Group";
    }

    /**
     * Creates a ChannelInterfaceGroupInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceGroupInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceGroupInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceGroupInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceGroupInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceGroupInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceGroupInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "GroupFlags" on the remote object.
     * 
     * An integer representing the bitwise-OR of flags on this channel. The 
     * user interface can use this to present information about which 
     * operations are currently valid. Change notification is via the 
     * GroupFlagsChanged signal.
     */
    Q_PROPERTY(uint GroupFlags READ _deprecated_GroupFlags)

    /**
     * Getter for the remote object property "GroupFlags".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyGroupFlags() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint GroupFlags() const
    {
        return _deprecated_GroupFlags();
    }

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

    /**
     * Asynchronous getter for the remote object property "GroupFlags" of type uint.
     *
     * 
     * An integer representing the bitwise-OR of flags on this channel. The 
     * user interface can use this to present information about which 
     * operations are currently valid. Change notification is via the 
     * GroupFlagsChanged signal.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyGroupFlags() const
    {
        return internalRequestProperty(QLatin1String("GroupFlags"));
    }

    /**
     * Represents property "HandleOwners" on the remote object.
     * 
     * A map from channel-specific handles to their owners, including at least 
     * all of the channel-specific handles in this channel&apos;s members, 
     * local-pending or remote-pending sets as keys. Any handle not in the 
     * keys of this mapping is not channel-specific in this channel. Handles 
     * which are channel-specific, but for which the owner is unknown, MUST 
     * appear in this mapping with 0 as owner. Change notification is via the 
     * HandleOwnersChanged signal.
     */
    Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ _deprecated_HandleOwners)

    /**
     * Getter for the remote object property "HandleOwners".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyHandleOwners() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::HandleOwnerMap HandleOwners() const
    {
        return _deprecated_HandleOwners();
    }

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

    /**
     * Asynchronous getter for the remote object property "HandleOwners" of type Tp::HandleOwnerMap.
     *
     * 
     * A map from channel-specific handles to their owners, including at least 
     * all of the channel-specific handles in this channel&apos;s members, 
     * local-pending or remote-pending sets as keys. Any handle not in the 
     * keys of this mapping is not channel-specific in this channel. Handles 
     * which are channel-specific, but for which the owner is unknown, MUST 
     * appear in this mapping with 0 as owner. Change notification is via the 
     * HandleOwnersChanged signal.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyHandleOwners() const
    {
        return internalRequestProperty(QLatin1String("HandleOwners"));
    }

    /**
     * Represents property "LocalPendingMembers" on the remote object.
     * 
     * An array of structs containing handles representing contacts requesting 
     * channel membership and awaiting local approval with AddMembers.
     */
    Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ _deprecated_LocalPendingMembers)

    /**
     * Getter for the remote object property "LocalPendingMembers".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyLocalPendingMembers() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::LocalPendingInfoList LocalPendingMembers() const
    {
        return _deprecated_LocalPendingMembers();
    }

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

    /**
     * Asynchronous getter for the remote object property "LocalPendingMembers" of type Tp::LocalPendingInfoList.
     *
     * 
     * An array of structs containing handles representing contacts requesting 
     * channel membership and awaiting local approval with AddMembers.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
    {
        return internalRequestProperty(QLatin1String("LocalPendingMembers"));
    }

    /**
     * Represents property "Members" on the remote object.
     * 
     * The members of this channel.
     */
    Q_PROPERTY(Tp::UIntList Members READ _deprecated_Members)

    /**
     * Getter for the remote object property "Members".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyMembers() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::UIntList Members() const
    {
        return _deprecated_Members();
    }

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

    /**
     * Asynchronous getter for the remote object property "Members" of type Tp::UIntList.
     *
     * 
     * The members of this channel.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMembers() const
    {
        return internalRequestProperty(QLatin1String("Members"));
    }

    /**
     * Represents property "RemotePendingMembers" on the remote object.
     * 
     * An array of handles representing contacts who have been invited to the 
     * channel and are awaiting remote approval.
     */
    Q_PROPERTY(Tp::UIntList RemotePendingMembers READ _deprecated_RemotePendingMembers)

    /**
     * Getter for the remote object property "RemotePendingMembers".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyRemotePendingMembers() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::UIntList RemotePendingMembers() const
    {
        return _deprecated_RemotePendingMembers();
    }

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

    /**
     * Asynchronous getter for the remote object property "RemotePendingMembers" of type Tp::UIntList.
     *
     * 
     * An array of handles representing contacts who have been invited to the 
     * channel and are awaiting remote approval.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
    {
        return internalRequestProperty(QLatin1String("RemotePendingMembers"));
    }

    /**
     * Represents property "SelfHandle" on the remote object.
     * 
     * The handle for the user on this channel (which can also be a local or 
     * remote pending member), or 0 if the user is not a member at all (which 
     * is likely to be the case, for instance, on ContactList channels). Note 
     * that this is different from the result of Connection.GetSelfHandle on 
     * some protocols, so the value of this handle should always be used with 
     * the methods of this interface.
     */
    Q_PROPERTY(uint SelfHandle READ _deprecated_SelfHandle)

    /**
     * Getter for the remote object property "SelfHandle".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertySelfHandle() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint SelfHandle() const
    {
        return _deprecated_SelfHandle();
    }

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

    /**
     * Asynchronous getter for the remote object property "SelfHandle" of type uint.
     *
     * 
     * The handle for the user on this channel (which can also be a local or 
     * remote pending member), or 0 if the user is not a member at all (which 
     * is likely to be the case, for instance, on ContactList channels). Note 
     * that this is different from the result of Connection.GetSelfHandle on 
     * some protocols, so the value of this handle should always be used with 
     * the methods of this interface.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySelfHandle() const
    {
        return internalRequestProperty(QLatin1String("SelfHandle"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "AddMembers" on the remote object.
     * 
     * <p>Invite all the given contacts into the channel, or accept requests for
     *   channel membership for contacts on the pending local list.</p>
     * 
     * <p>A message may be provided along with the request, which will be sent
     * to the server if supported. See the CHANNEL_GROUP_FLAG_MESSAGE_ADD and
     * CHANNEL_GROUP_FLAG_MESSAGE_ACCEPT
     * <tp:member-ref>GroupFlags</tp:member-ref> to see in which cases this
     * message should be provided.</p>
     * 
     * <p>Attempting to add contacts who are already members is allowed;
     *   connection managers must silently accept this, without error.</p>
     *
     * \param contacts
     *     
     *     An array of contact handles to invite to the channel
     *
     * \param message
     *     
     *     A string message, which can be blank if desired
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "GetAllMembers" on the remote object.
     * 
     * Returns arrays of all current, local and remote pending channel members.
     *
     * \return
     *     
     *     array of handles of current members
     *
     * \return
     *     
     *     array of handles of local pending members
     *
     * \return
     *     
     *     array of handles of remote pending members
     */
    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"));
    }

    /**
     * Begins a call to the D-Bus method "GetGroupFlags" on the remote object.
     * 
     * Returns the value of the GroupFlags property.
     *
     * \return
     *     
     *     The value of the GroupFlags property
     */
    inline QDBusPendingReply<uint> GetGroupFlags()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetHandleOwners" on the remote object.
     * 
     * If the CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES flag is set on the 
     * channel, then the handles of the group members are specific to this 
     * channel, and are not meaningful in a connection-wide context such as 
     * contact lists. This method allows you to find the owner of the handle 
     * if it can be discovered in this channel, or 0 if the owner is not 
     * available.
     *
     * \param handles
     *     
     *     A list of integer handles representing members of the channel
     *
     * \return
     *     
     *     An array of integer handles representing the owner handles of the 
     *     given room members, in the same order, or 0 if the owner is not 
     *     available
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "GetLocalPendingMembers" on the remote object.
     * 
     * Returns the To_Be_Added handle (only) for each structure in the 
     * LocalPendingMembers property.
     */
    inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetLocalPendingMembersWithInfo" on the remote object.
     * 
     * Returns the LocalPendingMembers property.
     *
     * \return
     *     
     *     An array of structs containing: A handle representing the contact 
     *     requesting channel membership A handle representing the contact 
     *     making the request, or 0 if unknown The reason for the request: one 
     *     of the values of Channel_Group_Change_Reason A string message 
     *     containing the reason for the request if any (or blank if none)
     */
    inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetMembers" on the remote object.
     * 
     * Returns the Members property.
     */
    inline QDBusPendingReply<Tp::UIntList> GetMembers()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetRemotePendingMembers" on the remote object.
     * 
     * Returns an array of handles representing contacts who have been invited 
     * to the channel and are awaiting remote approval.
     */
    inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetSelfHandle" on the remote object.
     * 
     * Returns the value of the SelfHandle property.
     */
    inline QDBusPendingReply<uint> GetSelfHandle()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RemoveMembers" on the remote object.
     * 
     * <p>Requests the removal of contacts from a channel, reject their
     *   request for channel membership on the pending local list, or
     *   rescind their invitation on the pending remote list.</p>
     * 
     * <p>If the <tp:member-ref>SelfHandle</tp:member-ref> is in a Group,
     *   it can be removed via this method, in order to leave the group
     *   gracefully. This is the recommended way to leave a chatroom, close
     *   or reject a <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">StreamedMedia</tp:dbus-ref>
     *   call, and so on.</p>
     * 
     * <p>Accordingly, connection managers SHOULD support
     *   doing this, regardless of the value of
     *   <tp:member-ref>GroupFlags</tp:member-ref>.
     *   If doing so fails with PermissionDenied, this is considered to a bug
     *   in the connection manager, but clients MUST recover by falling back
     *   to closing the channel with the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">Close</tp:dbus-ref>
     *   method.</p>
     * 
     * <p>Removing any contact from the local pending list is always
     *   allowed. Removing contacts other than the
     *   <tp:member-ref>SelfHandle</tp:member-ref> from the channel's members
     *   is allowed if and only if Channel_Group_Flag_Can_Remove is in the
     *   <tp:member-ref>GroupFlags</tp:member-ref>,
     *   while removing contacts other than the
     *   <tp:member-ref>SelfHandle</tp:member-ref> from the remote pending list
     *   is allowed if and only if Channel_Group_Flag_Can_Rescind is in the
     *   <tp:member-ref>GroupFlags</tp:member-ref>.</p>
     * 
     * <p>A message may be provided along with the request, which will be
     *   sent to the server if supported. See the
     *   Channel_Group_Flag_Message_Remove,
     *   Channel_Group_Flag_Message_Depart,
     *   Channel_Group_Flag_Message_Reject and
     *   Channel_Group_Flag_Message_Rescind
     *   <tp:member-ref>GroupFlags</tp:member-ref> to see in which cases this
     *   message should be provided.</p>
     *
     * \param contacts
     *     
     *     An array of contact handles to remove from the channel
     *
     * \param message
     *     
     *     A string message, which can be blank if desired
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "RemoveMembersWithReason" on the remote object.
     * 
     * As RemoveMembers, but a reason code may be provided where appropriate. 
     * The reason code may be ignored if the underlying protocol is unable to 
     * represent the given reason.
     *
     * \param contacts
     *     
     *     An array of contact handles to remove from the channel
     *
     * \param message
     *     
     *     A string message, which can be blank if desired
     *
     * \param reason
     *     
     *     A reason for the change
     */
    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:
    /**
     * Represents the signal "HandleOwnersChanged" on the remote object.
     * 
     * Emitted whenever the HandleOwners property changes.
     *
     * \param added
     *     
     *     A map from channel-specific handles to their owners, in which the 
     *     keys include all the handles that were added to the keys of the 
     *     HandleOwners property, and all the handles in that property whose 
     *     owner has changed
     *
     * \param removed
     *     
     *     The channel-specific handles that were removed from the keys of the 
     *     HandleOwners property, as a result of the contact leaving this 
     *     group in a previous MembersChanged signal
     */
    void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);

    /**
     * Represents the signal "SelfHandleChanged" on the remote object.
     * 
     * Emitted whenever the SelfHandle property changes.
     *
     * \param selfHandle
     *     
     *     The new value of the SelfHandle property.
     */
    void SelfHandleChanged(uint selfHandle);

    /**
     * Represents the signal "GroupFlagsChanged" on the remote object.
     * 
     * Emitted when the flags as returned by GetGroupFlags are changed. The 
     * user interface should be updated as appropriate.
     *
     * \param added
     *     
     *     A bitwise OR of the flags which have been set
     *
     * \param removed
     *     
     *     A bitwise OR of the flags which have been cleared
     */
    void GroupFlagsChanged(uint added, uint removed);

    /**
     * Represents the signal "MembersChanged" on the remote object.
     * 
     * <p>Emitted when contacts join any of the three lists (members, local
     *   pending or remote pending) or when they leave any of the three lists.
     *   There may also be a message from the server regarding this change,
     *   which may be displayed to the user if desired.</p>
     * 
     * <p>All channel-specific handles that are mentioned in this signal
     *   MUST be represented in the value of the
     *   <tp:member-ref>HandleOwners</tp:member-ref> property.
     *   In practice, this will mean that
     *   <tp:member-ref>HandleOwnersChanged</tp:member-ref> is
     *   emitted <em>before</em> emitting a MembersChanged signal in which
     *   channel-specific handles are added, but that it is emitted
     *   <em>after</em> emitting a MembersChanged signal in which
     *   channel-specific handles are removed.</p>
     * 
     * <p>See <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">StreamedMedia</tp:dbus-ref>
     *   for an overview of how group state changes are used to indicate the
     *   progress of a call.</p>
     *
     * \param message
     *     
     *     A string message from the server, or blank if not
     *
     * \param added
     *     
     *     A list of members added to the channel
     *
     * \param removed
     *     
     *     A list of members removed from the channel
     *
     * \param localPending
     *     
     *     A list of members who are pending local approval
     *
     * \param remotePending
     *     
     *     A list of members who are pending remote approval
     *
     * \param actor
     *     
     *     The contact handle of the person who made the change, or 0 if not 
     *     known
     *
     * \param reason
     *     
     *     A reason for the change
     */
    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);

    /**
     * Represents the signal "MembersChangedDetailed" on the remote object.
     * 
     * <p>Emitted when contacts join any of the three lists (members, local
     *   pending or remote pending) or when they leave any of the three
     *   lists. This signal provides a superset of the information provided by
     *   <tp:member-ref>MembersChanged</tp:member-ref>;
     *   if the channel's <tp:member-ref>GroupFlags</tp:member-ref>
     *   contains Members_Changed_Detailed, then clients may listen exclusively
     *   to this signal in preference to that signal.</p>
     * 
     * <p>All channel-specific handles that are mentioned in this signal
     *   MUST be represented in the value of the
     *   <tp:member-ref>HandleOwners</tp:member-ref> property.  In practice,
     *   this will mean that
     *   <tp:member-ref>HandleOwnersChanged</tp:member-ref> is emitted
     *   <em>before</em> emitting a MembersChangedDetailed signal in which
     *   channel-specific handles are added, but that it is emitted
     *   <em>after</em> emitting a MembersChangedDetailed signal in which
     *   channel-specific handles are removed.</p>
     * 
     * <p>See <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">StreamedMedia</tp:dbus-ref>
     *   for an overview of how group state changes are used to indicate the
     *   progress of a call.</p>
     *
     * \param added
     *     
     *     A list of members added to the channel
     *
     * \param removed
     *     
     *     A list of members removed from the channel
     *
     * \param localPending
     *     
     *     A list of members who are pending local approval
     *
     * \param remotePending
     *     
     *     A list of members who are pending remote approval
     *
     * \param details
     *     
     *     <p>Information about the change, which may include the following
     *       well-known keys:</p>
     *     
     *     <dl>
     *       <dt>actor (u — <tp:type>Contact_Handle</tp:type>)</dt>
     *       <dd>The contact handle of the person who made the change; 0 or
     *         omitted if unknown or not applicable.</dd>
     *     
     *       <dt>change-reason (u — <tp:type>Channel_Group_Change_Reason</tp:type>)</dt>
     *       <dd>A reason for the change.</dd>
     *     
     *       <dt>contact-ids (a{us} — <tp:type>Handle_Identifier_Map</tp:type>)</dt>
     *       <dd>
     *         <p>The string identifiers for handles mentioned in this signal, to
     *         give clients the minimal information necessary to react to the
     *         event without waiting for round-trips.  Connection managers
     *         SHOULD include the identifiers for members added to the group and
     *         for the actor (if any); they MAY omit the identifiers for handles
     *         which have been removed from the group.</p>
     *     
     *         <tp:rationale>
     *           <p>On IRC, an event such as a netsplit could cause the vast
     *           majority of a channel to leave.  Given that clients should
     *           already know the identifiers of a channel's members, including
     *           potentially hundreds of strings in the netsplit signal is
     *           unnecessary.</p>
     *         </tp:rationale>
     *     
     *         <p>Clients MUST NOT assume that the presence or absence of a
     *           handle in this mapping is meaningful. This mapping is merely
     *           an optimization for round-trip reduction, and connection
     *           managers MAY add additional handles, omit some handles, or
     *           omit the mapping completely.</p>
     *       </dd>
     *     
     *       <dt>message (s)</dt>
     *       <dd>A string message from the server regarding the change</dd>
     *     
     *       <dt>error (s — <tp:type>DBus_Error_Name</tp:type>)</dt>
     *       <dd>A (possibly implementation-specific) DBus error describing the
     *         change, providing more specific information than the
     *         <tp:type>Channel_Group_Change_Reason</tp:type> enum allows. This
     *         MUST only be present if it is strictly more informative than
     *         'change-reason'; if present, 'change-reason' MUST be set to the
     *         closest available reason.
     *     
     *         <tp:rationale>
     *           A SIP connection manager might want to signal &quot;402 Payment
     *           required&quot; as something more specific than Error or
     *           Permission_Denied so that a SIP-aware UI could handle it
     *           specially; including a namespaced error permits this to be done
     *           without <tp:type>Channel_Group_Change_Reason</tp:type> being
     *           extended to encompass every error any CM ever wants to report.
     *         </tp:rationale>
     *       </dd>
     *     
     *       <dt>debug-message (s)</dt>
     *       <dd>Debugging information on the change. SHOULD NOT be shown to
     *         users in normal circumstances.</dd>
     *     </dl>
     */
    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 ChannelInterfaceHoldInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.Hold."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.Hold", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.Hold";
    }

    /**
     * Creates a ChannelInterfaceHoldInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceHoldInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceHoldInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceHoldInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceHoldInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceHoldInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceHoldInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "GetHoldState" on the remote object.
     * 
     * Return whether the local user has placed the channel on hold.
     *
     * \return
     *     
     *     The state of the channel
     *
     * \return
     *     
     *     The reason why the channel is in that state
     */
    inline QDBusPendingReply<uint, uint> GetHoldState()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestHold" on the remote object.
     * 
     * <p>Request that the channel be put on hold (be instructed not to send
     *   any media streams to you) or be taken off hold.</p>
     * 
     * <p>If the connection manager can immediately tell that the requested
     *   state change could not possibly succeed, this method SHOULD
     *   return the NotAvailable error. If the requested state is the
     *   same as the current state, this method SHOULD return successfully
     *   without doing anything.</p>
     * 
     * <p>Otherwise, this method SHOULD immediately set the hold state to
     *   Local_Hold_State_Pending_Hold or Local_Hold_State_Pending_Unhold
     *   (as appropriate), emitting
     *   <tp:member-ref>HoldStateChanged</tp:member-ref> if this is a change,
     *   and return successfully.</p>
     * 
     * <p>The eventual success or failure of the request is indicated by a
     *   subsequent HoldStateChanged signal, changing the hold state to
     *   Local_Hold_State_Held or Local_Hold_State_Unheld.</p>
     * 
     * <p>If the channel has multiple streams, and the connection manager
     *   succeeds in changing the hold state of one stream but fails to
     *   change the hold state of another, it SHOULD attempt to revert
     *   all streams to their previous hold states.</p>
     * 
     * <p>The following state transitions SHOULD be used, where
     *   appropriate:</p>
     * 
     * <ul>
     *   <li>Successful hold:
     *     (Unheld, any reason) → (Pending_Hold, Requested) →
     *     (Held, Requested)
     *   </li>
     *   <li>Successful unhold:
     *     (Held, any reason) → (Pending_Unhold, Requested) →
     *     (Unheld, Requested)
     *   </li>
     *   <li>Attempting to unhold fails at the first attempt to acquire a
     *     resource:
     *     (Held, any reason) → (Pending_Unhold, Requested) →
     *     (Held, Resource_Not_Available)
     *   </li>
     *   <li>Attempting to unhold acquires one resource, but fails to acquire
     *     a second, and takes time to release the first:
     *     (Held, any reason) → (Pending_Unhold, Requested) →
     *     (Pending_Hold, Resource_Not_Available) →
     *     (Held, Resource_Not_Available)
     *   </li>
     * </ul>
     *
     * \param hold
     *     
     *     A boolean indicating whether or not the channel should be on hold
     */
    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:
    /**
     * Represents the signal "HoldStateChanged" on the remote object.
     * 
     * Emitted to indicate that the hold state has changed for this channel. 
     * This may occur as a consequence of you requesting a change with 
     * RequestHold, or the state changing as a result of a request from 
     * another process.
     *
     * \param holdState
     *     
     *     The state of the channel
     *
     * \param reason
     *     
     *     The reason for the state change
     */
    void HoldStateChanged(uint holdState, uint reason);

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

/**
 * \class ChannelInterfaceMediaSignallingInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
    }

    /**
     * Creates a ChannelInterfaceMediaSignallingInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceMediaSignallingInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceMediaSignallingInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceMediaSignallingInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceMediaSignallingInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceMediaSignallingInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceMediaSignallingInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "GetSessionHandlers" on the remote object.
     * 
     * Returns all currently active session handlers on this channel as a list 
     * of (session_handler_path, type).
     */
    inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "NewSessionHandler" on the remote object.
     * 
     * Signal that a session handler object has been created. The client 
     * should create a session object and create streams for the streams 
     * within.
     *
     * \param sessionHandler
     *     
     *     Object path of the new Media.SessionHandler object
     *
     * \param sessionType
     *     
     *     String indicating type of session, eg &quot;rtp&quot;
     */
    void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);

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

/**
 * \class ChannelInterfaceMessagesInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.Messages."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.Messages", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.Messages";
    }

    /**
     * Creates a ChannelInterfaceMessagesInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceMessagesInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceMessagesInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceMessagesInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceMessagesInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceMessagesInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceMessagesInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "SupportedContentTypes" on the remote object.
     * 
     * <p>A list of MIME types supported by this channel, with more preferred
     *   MIME types appearing earlier in the list. The list MAY include &quot;&#42;&#47;*&quot;
     *   to indicate that attachments with arbitrary MIME types can be sent.
     *   This list MUST NOT be empty, since all Messages implementations
     *   MUST accept messages containing a single &quot;text/plain&quot; part.</p>
     * 
     * <p>Some examples of how this property interacts with the
     *   <tp:member-ref>MessagePartSupportFlags</tp:member-ref>:</p>
     * 
     * <dl>
     *   <dt>A simple IM implementation: only plain text messages are
     *     allowed</dt>
     *   <dd>SupportedContentTypes = ['text/plain'],
     *     MessagePartSupportFlags = 0</dd>
     * 
     *   <dt>Formatted text with a plain text alternative is allowed (see the
     *     HTML interface draft)</dt>
     *   <dd>SupportedContentTypes = ['text/html', 'text/plain'],
     *     MessagePartSupportFlags = 0</dd>
     * 
     *   <dt>JPEG or PNG images may be sent, but without any attached
     *     text</dt>
     *   <dd>SupportedContentTypes = ['text/plain', 'image/jpeg',
     *     'image/png'], MessagePartSupportFlags = 0</dd>
     * 
     *   <dt>Unformatted text to which an optional JPEG or PNG image may be
     *     attached</dt>
     *   <dd>SupportedContentTypes = ['text/plain', 'image/jpeg',
     *     'image/png'], MessagePartSupportFlags = One_Attachment</dd>
     * 
     *   <dt>Formatted text to which arbitrarily many images may be
     *     attached</dt>
     *   <dd>SupportedContentTypes = ['text/html', 'text/plain', 'image/jpeg',
     *     'image/png', 'image/x-ms-bmp'], MessagePartSupportFlags =
     *     One_Attachment | Multiple_Attachments</dd>
     * 
     *   <dt>A full SIP implementation: arbitrary MIME messages are
     *     allowed</dt>
     *   <dd>SupportedContentTypes = ['&#42;&#47;*'], MessagePartSupportFlags =
     *     One_Attachment | Multiple_Attachments</dd>
     * </dl>
     */
    Q_PROPERTY(QStringList SupportedContentTypes READ _deprecated_SupportedContentTypes)

    /**
     * Getter for the remote object property "SupportedContentTypes".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertySupportedContentTypes() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QStringList SupportedContentTypes() const
    {
        return _deprecated_SupportedContentTypes();
    }

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

    /**
     * Asynchronous getter for the remote object property "SupportedContentTypes" of type QStringList.
     *
     * 
     * <p>A list of MIME types supported by this channel, with more preferred
     *   MIME types appearing earlier in the list. The list MAY include &quot;&#42;&#47;*&quot;
     *   to indicate that attachments with arbitrary MIME types can be sent.
     *   This list MUST NOT be empty, since all Messages implementations
     *   MUST accept messages containing a single &quot;text/plain&quot; part.</p>
     * 
     * <p>Some examples of how this property interacts with the
     *   <tp:member-ref>MessagePartSupportFlags</tp:member-ref>:</p>
     * 
     * <dl>
     *   <dt>A simple IM implementation: only plain text messages are
     *     allowed</dt>
     *   <dd>SupportedContentTypes = ['text/plain'],
     *     MessagePartSupportFlags = 0</dd>
     * 
     *   <dt>Formatted text with a plain text alternative is allowed (see the
     *     HTML interface draft)</dt>
     *   <dd>SupportedContentTypes = ['text/html', 'text/plain'],
     *     MessagePartSupportFlags = 0</dd>
     * 
     *   <dt>JPEG or PNG images may be sent, but without any attached
     *     text</dt>
     *   <dd>SupportedContentTypes = ['text/plain', 'image/jpeg',
     *     'image/png'], MessagePartSupportFlags = 0</dd>
     * 
     *   <dt>Unformatted text to which an optional JPEG or PNG image may be
     *     attached</dt>
     *   <dd>SupportedContentTypes = ['text/plain', 'image/jpeg',
     *     'image/png'], MessagePartSupportFlags = One_Attachment</dd>
     * 
     *   <dt>Formatted text to which arbitrarily many images may be
     *     attached</dt>
     *   <dd>SupportedContentTypes = ['text/html', 'text/plain', 'image/jpeg',
     *     'image/png', 'image/x-ms-bmp'], MessagePartSupportFlags =
     *     One_Attachment | Multiple_Attachments</dd>
     * 
     *   <dt>A full SIP implementation: arbitrary MIME messages are
     *     allowed</dt>
     *   <dd>SupportedContentTypes = ['&#42;&#47;*'], MessagePartSupportFlags =
     *     One_Attachment | Multiple_Attachments</dd>
     * </dl>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
    {
        return internalRequestProperty(QLatin1String("SupportedContentTypes"));
    }

    /**
     * Represents property "MessagePartSupportFlags" on the remote object.
     * 
     * Flags indicating the level of support for message parts on this channel.
     */
    Q_PROPERTY(uint MessagePartSupportFlags READ _deprecated_MessagePartSupportFlags)

    /**
     * Getter for the remote object property "MessagePartSupportFlags".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyMessagePartSupportFlags() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint MessagePartSupportFlags() const
    {
        return _deprecated_MessagePartSupportFlags();
    }

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

    /**
     * Asynchronous getter for the remote object property "MessagePartSupportFlags" of type uint.
     *
     * 
     * Flags indicating the level of support for message parts on this channel.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
    {
        return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
    }

    /**
     * Represents property "PendingMessages" on the remote object.
     * 
     * A list of incoming messages that have neither been acknowledged nor 
     * rejected. This list is a more detailed version of the one returned by 
     * Text.ListPendingMessages, and contains the same messages, uniquely 
     * identified by the same pending message IDs. Its items can be removed 
     * using Text.AcknowledgePendingMessages.
     */
    Q_PROPERTY(Tp::MessagePartListList PendingMessages READ _deprecated_PendingMessages)

    /**
     * Getter for the remote object property "PendingMessages".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyPendingMessages() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::MessagePartListList PendingMessages() const
    {
        return _deprecated_PendingMessages();
    }

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

    /**
     * Asynchronous getter for the remote object property "PendingMessages" of type Tp::MessagePartListList.
     *
     * 
     * A list of incoming messages that have neither been acknowledged nor 
     * rejected. This list is a more detailed version of the one returned by 
     * Text.ListPendingMessages, and contains the same messages, uniquely 
     * identified by the same pending message IDs. Its items can be removed 
     * using Text.AcknowledgePendingMessages.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyPendingMessages() const
    {
        return internalRequestProperty(QLatin1String("PendingMessages"));
    }

    /**
     * Represents property "DeliveryReportingSupport" on the remote object.
     * 
     * A bitfield indicating features supported by this channel.
     */
    Q_PROPERTY(uint DeliveryReportingSupport READ _deprecated_DeliveryReportingSupport)

    /**
     * Getter for the remote object property "DeliveryReportingSupport".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyDeliveryReportingSupport() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint DeliveryReportingSupport() const
    {
        return _deprecated_DeliveryReportingSupport();
    }

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

    /**
     * Asynchronous getter for the remote object property "DeliveryReportingSupport" of type uint.
     *
     * 
     * A bitfield indicating features supported by this channel.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
    {
        return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "SendMessage" on the remote object.
     * 
     * <p>Submit a message to the server for sending.
     *   If this method returns successfully, the message has been submitted
     *   to the server and the <tp:member-ref>MessageSent</tp:member-ref>
     *   signal is emitted. A corresponding
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.Text">Sent</tp:dbus-ref>
     *   signal on the Text interface MUST also be emitted.</p>
     * 
     * <p>This method MUST return before the MessageSent signal is
     *   emitted.</p>
     * 
     * <tp:rationale>
     *   <p>This means that the process sending the message is the first
     *     to see the <tp:type>Protocol_Message_Token</tp:type>, and can
     *     relate the message to the corresponding
     *     <tp:member-ref>MessageSent</tp:member-ref> signal by comparing
     *     message tokens (if supported by the protocol).</p>
     * </tp:rationale>
     * 
     * <p>If this method fails, message submission to the server has failed
     *   and no signal on this interface (or the Text interface) is
     *   emitted.</p>
     *
     * \param message
     *     
     *     The message content, including any attachments or alternatives
     *
     * \param flags
     *     
     *     Flags affecting how the message is sent. The channel MAY ignore 
     *     some or all flags, depending on DeliveryReportingSupport; the flags 
     *     that were handled by the CM are provided in MessageSent.
     *
     * \return
     *     
     *     An opaque token used to match any incoming delivery or failure 
     *     reports against this message, or an empty string if the message is 
     *     not readily identifiable.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "GetPendingMessageContent" on the remote object.
     * 
     * Retrieve the content of one or more parts of a pending message. Note 
     * that this function may take a considerable amount of time to return if 
     * the part&apos;s &apos;needs-retrieval&apos; flag is true; consider 
     * extending the default D-Bus method call timeout. Additional API is 
     * likely to be added in future, to stream large message parts.
     *
     * \param messageID
     *     
     *     The ID of a pending message
     *
     * \param parts
     *     
     *     The desired entries in the array of message parts, identified by 
     *     their position. The &quot;headers&quot; part (which is not a valid 
     *     argument to this method) is considered to be part 0, so the valid 
     *     part numbers start at 1 (for the second Message_Part).
     *
     * \return
     *     
     *     <p>The content of the requested parts. The keys in this mapping
     *       are positions in the array of message parts; the values are
     *       either of type 's' or 'ay' (UTF-8 text string, or byte array),
     *       following the same rules as for the value of the 'content' key in
     *       the <tp:type>Message_Part</tp:type> mappings.</p>
     *     
     *     <p>If the one of the requested part numbers was greater than zero
     *       but referred to a part that had no content (i.e. it had no
     *       'content-type' key or no 'content' key), it is simply omitted from
     *       this mapping; this is not considered to be an error condition.</p>
     */
    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:
    /**
     * Represents the signal "MessageSent" on the remote object.
     * 
     * <p>Signals that a message has been submitted for sending. This
     *   MUST be emitted exactly once per emission of the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.Text">Sent</tp:dbus-ref>
     *   signal on the Text interface, for backwards-compatibility; clients
     *   SHOULD ignore the latter if this interface is present, as mentioned
     *   in the introduction.</p>
     * 
     * <p>This SHOULD be emitted as soon as the CM determines it's
     *   theoretically possible to send the message (e.g. the parameters are
     *   supported and correct).</p>
     * 
     * <tp:rationale>
     *   <p>This signal allows a process that is not the caller of
     *     SendMessage to log sent messages.</p>
     * </tp:rationale>
     *
     * \param content
     *     
     *     <p>The message content (see <tp:type>Message_Part</tp:type> for full
     *       details). If the message that was passed to
     *       <tp:member-ref>SendMessage</tp:member-ref> has a formatted text
     *       part that the connection manager recognises, but no
     *       <tt>text/plain</tt> alternative, the CM MUST use the formatted text
     *       part to generate a <tt>text/plain</tt> alternative which is also
     *       included in this signal argument.</p>
     *     
     *     <p>If the connection manager can predict that the message will be
     *       altered during transmission, this argument SHOULD reflect what
     *       other contacts will receive, rather than being a copy of the
     *       argument to SendMessage (if the message is truncated,
     *       formatting or alternatives are dropped, etc., then the edited
     *       version SHOULD appear in this signal).</p>
     *
     * \param flags
     *     
     *     Flags affecting how the message was sent. The flags might be a 
     *     subset of those passed to SendMessage if the caller requested 
     *     unsupported flags.
     *
     * \param messageToken
     *     
     *     An opaque token used to match any incoming delivery or failure 
     *     reports against this message, or an empty string if the message is 
     *     not readily identifiable.
     */
    void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);

    /**
     * Represents the signal "PendingMessagesRemoved" on the remote object.
     * 
     * The messages with the given IDs have been removed from the 
     * PendingMessages list. Clients SHOULD NOT attempt to acknowledge those 
     * messages. This completes change notification for the PendingMessages 
     * property (previously, there was change notification when pending 
     * messages were added, but not when they were removed).
     *
     * \param messageIDs
     *     
     *     The messages that have been removed from the pending message list.
     */
    void PendingMessagesRemoved(const Tp::UIntList& messageIDs);

    /**
     * Represents the signal "MessageReceived" on the remote object.
     * 
     * Signals that a message has been received and added to the pending 
     * messages queue. This MUST be emitted exactly once per emission of the 
     * Received signal on the Text interface, for backwards-compatibility; 
     * clients SHOULD ignore the latter in favour of this signal if this 
     * interface is present, as mentioned in the introduction.
     *
     * \param message
     *     
     *     <p>The message content, including any attachments or alternatives. If
     *       the incoming message contains formatted text without a plain text
     *       alternative, the connection manager MUST generate a
     *       <tt>text/plain</tt> alternative from the formatted text, and
     *       include it in this message (both here, and in the
     *       <tp:member-ref>PendingMessages</tp:member-ref> property).</p>
     */
    void MessageReceived(const Tp::MessagePartList& message);

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

/**
 * \class ChannelInterfacePasswordInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.Password."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.Password", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.Password";
    }

    /**
     * Creates a ChannelInterfacePasswordInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfacePasswordInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfacePasswordInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfacePasswordInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfacePasswordInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfacePasswordInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfacePasswordInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "GetPasswordFlags" on the remote object.
     * 
     * Returns the bitwise-OR of the flags relevant to the password on this 
     * channel. The user interface can use this to present information about 
     * which operations are currently valid.
     *
     * \return
     *     
     *     An integer with the logical OR of all the flags set (values of 
     *     ChannelPasswordFlags)
     */
    inline QDBusPendingReply<uint> GetPasswordFlags()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ProvidePassword" on the remote object.
     * 
     * Provide the password so that the channel can be joined. Must be called 
     * with the correct password in order for channel joining to proceed if 
     * the &apos;provide&apos; password flag is set.
     *
     * \param password
     *     
     *     The password
     *
     * \return
     *     
     *     A boolean indicating whether or not the password was correct
     */
    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:
    /**
     * Represents the signal "PasswordFlagsChanged" on the remote object.
     * 
     * Emitted when the flags as returned by GetPasswordFlags are changed. The 
     * user interface should be updated as appropriate.
     *
     * \param added
     *     
     *     A bitwise OR of the flags which have been set
     *
     * \param removed
     *     
     *     A bitwise OR of the flags which have been cleared
     */
    void PasswordFlagsChanged(uint added, uint removed);

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

/**
 * \class ChannelInterfaceServicePointInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.ServicePoint."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.ServicePoint", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.ServicePoint";
    }

    /**
     * Creates a ChannelInterfaceServicePointInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceServicePointInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceServicePointInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceServicePointInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceServicePointInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceServicePointInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceServicePointInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "InitialServicePoint" on the remote object.
     * 
     * <p>This property is used to indicate that the channel target is a
     * well-known service point.  Please note that the CM (or lower layers
     * of the stack or network) may forward the connection to other other
     * service points, which the CM SHOULD indicate via
     * <tp:member-ref>ServicePointChanged</tp:member-ref>
     * signal.</p>
     * 
     * <p>This property SHOULD be set for channel requests that are
     * specifically targeting service points.</p>
     */
    Q_PROPERTY(Tp::ServicePoint InitialServicePoint READ _deprecated_InitialServicePoint)

    /**
     * Getter for the remote object property "InitialServicePoint".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialServicePoint() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::ServicePoint InitialServicePoint() const
    {
        return _deprecated_InitialServicePoint();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialServicePoint" of type Tp::ServicePoint.
     *
     * 
     * <p>This property is used to indicate that the channel target is a
     * well-known service point.  Please note that the CM (or lower layers
     * of the stack or network) may forward the connection to other other
     * service points, which the CM SHOULD indicate via
     * <tp:member-ref>ServicePointChanged</tp:member-ref>
     * signal.</p>
     * 
     * <p>This property SHOULD be set for channel requests that are
     * specifically targeting service points.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
    {
        return internalRequestProperty(QLatin1String("InitialServicePoint"));
    }

    /**
     * Represents property "CurrentServicePoint" on the remote object.
     * 
     * The service point that the channel is connected to. If the channel is 
     * not connected to a service point, the CM MUST set the 
     * Service_Point_Type field to None; for instance, this will be the case 
     * for ordinary calls.
     */
    Q_PROPERTY(Tp::ServicePoint CurrentServicePoint READ _deprecated_CurrentServicePoint)

    /**
     * Getter for the remote object property "CurrentServicePoint".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyCurrentServicePoint() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::ServicePoint CurrentServicePoint() const
    {
        return _deprecated_CurrentServicePoint();
    }

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

    /**
     * Asynchronous getter for the remote object property "CurrentServicePoint" of type Tp::ServicePoint.
     *
     * 
     * The service point that the channel is connected to. If the channel is 
     * not connected to a service point, the CM MUST set the 
     * Service_Point_Type field to None; for instance, this will be the case 
     * for ordinary calls.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
    {
        return internalRequestProperty(QLatin1String("CurrentServicePoint"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

Q_SIGNALS:
    /**
     * Represents the signal "ServicePointChanged" on the remote object.
     * 
     * Emitted when a channel changes the service point that it&apos;s 
     * connected to. This might be a new call being connected to a service, a 
     * call connected to a service being routed to a different service (ie, an 
     * emergency call being routed from a generic emergency PSAP to a poison 
     * control PSAP), or any number of other things. Note that this should be 
     * emitted as soon as the CM has been notified of the switch, and has 
     * updated its internal state. The CM MAY still be in the process of 
     * connecting to the new service point.
     *
     * \param servicePoint
     *     
     *     The new service point that is being used.
     */
    void ServicePointChanged(const Tp::ServicePoint& servicePoint);

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

/**
 * \class ChannelInterfaceTubeInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Interface.Tube."
 */
class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Interface.Tube", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Interface.Tube";
    }

    /**
     * Creates a ChannelInterfaceTubeInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceTubeInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceTubeInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceTubeInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelInterfaceTubeInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelInterfaceTubeInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelInterfaceTubeInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "Parameters" on the remote object.
     * 
     *         <p>Each tube has a dictionary of arbitrary parameters. Parameters are
     *           commonly used to bootstrap legacy protocols where you can't
     *           negotiate parameters in-band. The allowable keys,
     *           types and values are defined by the service, but connection managers
     *           must support the value being a string (D-Bus type <tt>'s'</tt>),
     *           array of bytes (D-Bus type <tt>'ay'</tt>), unsigned integer (D-Bus
     *           type <tt>'u'</tt>), integer (D-Bus type <tt>'i'</tt>) and boolean
     *           (D-Bus type <tt>'b'</tt>).</p>
     * 
     *         <p>When the tube is offered, the parameters are transmitted with the
     *           offer and appear as a property of the incoming tube for other
     *           participants.</p>
     * 
     *         <p>For example, a stream tube for <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.StreamTube">Service</tp:dbus-ref>
     *           <tt>&quot;smb&quot;</tt> (<cite>Server Message Block over TCP/IP</cite>) might
     *           use the following properties, as defined in <a href="http://www.dns-sd.org/ServiceTypes.html">DNS SRV (RFC 2782)
     *           Service Types</a>:</p>
     * 
     *         <pre>
     * { 'u': 'some-username',
     *   'p': 'top-secret-password',
     *   'path': '/etc/passwd',
     * }</pre>
     * 
     *         <p>When requesting a tube with
     *           <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">CreateChannel</tp:dbus-ref>,
     *           this property MUST NOT be included in the request; instead, it is set
     *           when <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">StreamTube.Offer</tp:dbus-ref>
     *           or <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">DBusTube.Offer</tp:dbus-ref>
     *           (as appropriate) is called. Its value is undefined until the tube is
     *           offered; once set, its value MUST NOT change.</p>
     * 
     *         <p>When receiving an incoming tube, this property is immutable and so advertised in the
     *           <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">NewChannels</tp:dbus-ref>
     *           signal.</p>
     */
    Q_PROPERTY(QVariantMap Parameters READ _deprecated_Parameters)

    /**
     * Getter for the remote object property "Parameters".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyParameters() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QVariantMap Parameters() const
    {
        return _deprecated_Parameters();
    }

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

    /**
     * Asynchronous getter for the remote object property "Parameters" of type QVariantMap.
     *
     * 
     *         <p>Each tube has a dictionary of arbitrary parameters. Parameters are
     *           commonly used to bootstrap legacy protocols where you can't
     *           negotiate parameters in-band. The allowable keys,
     *           types and values are defined by the service, but connection managers
     *           must support the value being a string (D-Bus type <tt>'s'</tt>),
     *           array of bytes (D-Bus type <tt>'ay'</tt>), unsigned integer (D-Bus
     *           type <tt>'u'</tt>), integer (D-Bus type <tt>'i'</tt>) and boolean
     *           (D-Bus type <tt>'b'</tt>).</p>
     * 
     *         <p>When the tube is offered, the parameters are transmitted with the
     *           offer and appear as a property of the incoming tube for other
     *           participants.</p>
     * 
     *         <p>For example, a stream tube for <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.StreamTube">Service</tp:dbus-ref>
     *           <tt>&quot;smb&quot;</tt> (<cite>Server Message Block over TCP/IP</cite>) might
     *           use the following properties, as defined in <a href="http://www.dns-sd.org/ServiceTypes.html">DNS SRV (RFC 2782)
     *           Service Types</a>:</p>
     * 
     *         <pre>
     * { 'u': 'some-username',
     *   'p': 'top-secret-password',
     *   'path': '/etc/passwd',
     * }</pre>
     * 
     *         <p>When requesting a tube with
     *           <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">CreateChannel</tp:dbus-ref>,
     *           this property MUST NOT be included in the request; instead, it is set
     *           when <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">StreamTube.Offer</tp:dbus-ref>
     *           or <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">DBusTube.Offer</tp:dbus-ref>
     *           (as appropriate) is called. Its value is undefined until the tube is
     *           offered; once set, its value MUST NOT change.</p>
     * 
     *         <p>When receiving an incoming tube, this property is immutable and so advertised in the
     *           <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">NewChannels</tp:dbus-ref>
     *           signal.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyParameters() const
    {
        return internalRequestProperty(QLatin1String("Parameters"));
    }

    /**
     * Represents property "State" on the remote object.
     * 
     * <p>State of the tube in this channel.</p>
     * 
     * <p>When requesting a tube with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">CreateChannel</tp:dbus-ref>,
     *   this property MUST NOT be included in the request.</p>
     */
    Q_PROPERTY(uint State READ _deprecated_State)

    /**
     * Getter for the remote object property "State".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyState() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint State() const
    {
        return _deprecated_State();
    }

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

    /**
     * Asynchronous getter for the remote object property "State" of type uint.
     *
     * 
     * <p>State of the tube in this channel.</p>
     * 
     * <p>When requesting a tube with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">CreateChannel</tp:dbus-ref>,
     *   this property MUST NOT be included in the request.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyState() const
    {
        return internalRequestProperty(QLatin1String("State"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

Q_SIGNALS:
    /**
     * Represents the signal "TubeChannelStateChanged" on the remote object.
     * 
     * Emitted when the state of the tube channel changes. Valid state 
     * transitions are documented with Tube_Channel_State.
     *
     * \param state
     *     
     *     The new state of the tube.
     */
    void TubeChannelStateChanged(uint state);

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

/**
 * \class ChannelTypeContactListInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.ContactList."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.ContactList", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.ContactList";
    }

    /**
     * Creates a ChannelTypeContactListInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeContactListInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeContactListInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeContactListInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeContactListInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeContactListInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeContactListInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeContactListInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

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

/**
 * \class ChannelTypeContactSearchInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.ContactSearch."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.ContactSearch", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.ContactSearch";
    }

    /**
     * Creates a ChannelTypeContactSearchInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeContactSearchInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeContactSearchInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeContactSearchInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeContactSearchInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeContactSearchInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeContactSearchInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "SearchState" on the remote object.
     * 
     * The current state of this search channel object. Change notification is 
     * via SearchStateChanged.
     */
    Q_PROPERTY(uint SearchState READ _deprecated_SearchState)

    /**
     * Getter for the remote object property "SearchState".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertySearchState() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint SearchState() const
    {
        return _deprecated_SearchState();
    }

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

    /**
     * Asynchronous getter for the remote object property "SearchState" of type uint.
     *
     * 
     * The current state of this search channel object. Change notification is 
     * via SearchStateChanged.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySearchState() const
    {
        return internalRequestProperty(QLatin1String("SearchState"));
    }

    /**
     * Represents property "Limit" on the remote object.
     * 
     * <p>If supported by the protocol, the maximum number of results that
     *   should be returned, where <code>0</code> represents no limit. If the
     *   protocol does not support limiting results, this should be
     *   <code>0</code>.</p>
     * 
     * <p>For example, if the terms passed to
     *   <tp:member-ref>Search</tp:member-ref> match <i>Antonius</i>,
     *   <i>Bridget</i> and <i>Charles</i> and this property is
     *   <code>2</code>, the search service SHOULD only return <i>Antonius</i>
     *   and <i>Bridget</i>.</p>
     * 
     * <p>This property cannot change during the lifetime of the channel.
     *   This property SHOULD be in the Allowed_Properties of a
     *   <tp:type>Requestable_Channel_Class</tp:type> if and only if the
     *   protocol supports specifying a limit; implementations SHOULD use
     *   <code>0</code> as the default if possible, or a protocol-specific
     *   sensible default otherwise.</p>
     */
    Q_PROPERTY(uint Limit READ _deprecated_Limit)

    /**
     * Getter for the remote object property "Limit".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyLimit() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint Limit() const
    {
        return _deprecated_Limit();
    }

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

    /**
     * Asynchronous getter for the remote object property "Limit" of type uint.
     *
     * 
     * <p>If supported by the protocol, the maximum number of results that
     *   should be returned, where <code>0</code> represents no limit. If the
     *   protocol does not support limiting results, this should be
     *   <code>0</code>.</p>
     * 
     * <p>For example, if the terms passed to
     *   <tp:member-ref>Search</tp:member-ref> match <i>Antonius</i>,
     *   <i>Bridget</i> and <i>Charles</i> and this property is
     *   <code>2</code>, the search service SHOULD only return <i>Antonius</i>
     *   and <i>Bridget</i>.</p>
     * 
     * <p>This property cannot change during the lifetime of the channel.
     *   This property SHOULD be in the Allowed_Properties of a
     *   <tp:type>Requestable_Channel_Class</tp:type> if and only if the
     *   protocol supports specifying a limit; implementations SHOULD use
     *   <code>0</code> as the default if possible, or a protocol-specific
     *   sensible default otherwise.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyLimit() const
    {
        return internalRequestProperty(QLatin1String("Limit"));
    }

    /**
     * Represents property "AvailableSearchKeys" on the remote object.
     * 
     * The set of search keys supported by this channel. Example values 
     * include [&quot;&quot;] (for protocols where several address fields are 
     * implicitly searched) or [&quot;x-n-given&quot;, &quot;x-n-family&quot;, 
     * &quot;nickname&quot;, &quot;email&quot;] (for XMPP XEP-0055, without 
     * extensibility via Data Forms). This property cannot change during the 
     * lifetime of a channel. It can be in the NewChannels signal for 
     * round-trip reduction.
     */
    Q_PROPERTY(QStringList AvailableSearchKeys READ _deprecated_AvailableSearchKeys)

    /**
     * Getter for the remote object property "AvailableSearchKeys".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyAvailableSearchKeys() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QStringList AvailableSearchKeys() const
    {
        return _deprecated_AvailableSearchKeys();
    }

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

    /**
     * Asynchronous getter for the remote object property "AvailableSearchKeys" of type QStringList.
     *
     * 
     * The set of search keys supported by this channel. Example values 
     * include [&quot;&quot;] (for protocols where several address fields are 
     * implicitly searched) or [&quot;x-n-given&quot;, &quot;x-n-family&quot;, 
     * &quot;nickname&quot;, &quot;email&quot;] (for XMPP XEP-0055, without 
     * extensibility via Data Forms). This property cannot change during the 
     * lifetime of a channel. It can be in the NewChannels signal for 
     * round-trip reduction.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
    {
        return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
    }

    /**
     * Represents property "Server" on the remote object.
     * 
     * For protocols which support searching for contacts on multiple servers 
     * with different DNS names (like XMPP), the DNS name of the server being 
     * searched by this channel, e.g. &quot;characters.shakespeare.lit&quot;. 
     * Otherwise, the empty string. XEP 0055 defines a mechanism for XMPP 
     * clients to search services of their choice for contacts, such as 
     * users.jabber.org (the &quot;Jabber User Directory&quot;). This property 
     * cannot change during the lifetime of the channel. This property SHOULD 
     * be in the Allowed_Properties of a Requestable_Channel_Class if and only 
     * if the protocol supports querying multiple different servers; 
     * implementations SHOULD use a sensible default if possible if this 
     * property is not specified in a channel request. This allows a client to 
     * perform searches on a protocol it knows nothing about without requiring 
     * the user to guess a valid server&apos;s hostname.
     */
    Q_PROPERTY(QString Server READ _deprecated_Server)

    /**
     * Getter for the remote object property "Server".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyServer() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString Server() const
    {
        return _deprecated_Server();
    }

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

    /**
     * Asynchronous getter for the remote object property "Server" of type QString.
     *
     * 
     * For protocols which support searching for contacts on multiple servers 
     * with different DNS names (like XMPP), the DNS name of the server being 
     * searched by this channel, e.g. &quot;characters.shakespeare.lit&quot;. 
     * Otherwise, the empty string. XEP 0055 defines a mechanism for XMPP 
     * clients to search services of their choice for contacts, such as 
     * users.jabber.org (the &quot;Jabber User Directory&quot;). This property 
     * cannot change during the lifetime of the channel. This property SHOULD 
     * be in the Allowed_Properties of a Requestable_Channel_Class if and only 
     * if the protocol supports querying multiple different servers; 
     * implementations SHOULD use a sensible default if possible if this 
     * property is not specified in a channel request. This allows a client to 
     * perform searches on a protocol it knows nothing about without requiring 
     * the user to guess a valid server&apos;s hostname.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyServer() const
    {
        return internalRequestProperty(QLatin1String("Server"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "Search" on the remote object.
     * 
     * Send a request to start a search for contacts on this connection. This 
     * may only be called while the SearchState is Not_Started; a valid search 
     * request will cause the SearchStateChanged signal to be emitted with the 
     * state In_Progress.
     *
     * \param terms
     *     
     *     A dictionary mapping search key names to the desired values
     */
    inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "More" on the remote object.
     * 
     * Request that a search in <tp:member-ref>SearchState</tp:member-ref>
     * <code>More_Available</code> move back to state <code>In_Progress</code>
     * and continue listing up to <tp:member-ref>Limit</tp:member-ref> more results.
     */
    inline QDBusPendingReply<> More()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "Stop" on the remote object.
     * 
     * <p>Stop the current search. This may not be called while the
     *   <tp:member-ref>SearchState</tp:member-ref> is Not_Started. If called
     *   while the SearchState is In_Progress,
     *   <tp:member-ref>SearchStateChanged</tp:member-ref> will be emitted,
     *   with the state Failed and the error
     *   <code>org.freedesktop.Telepathy.Errors.Cancelled</code>.</p>
     * 
     * <p>Calling this method on a search in state Completed or Failed
     *   succeeds, but has no effect.</p>
     * 
     * <tp:rationale>
     *   <p>Specifying Stop to succeed when the search has finished means that
     *     clients who call Stop just before receiving
     *     <tp:member-ref>SearchStateChanged</tp:member-ref> don't have to
     *     handle a useless error.</p>
     * </tp:rationale>
     * 
     * <p>Depending on the protocol, the connection manager may not be
     *   able to prevent the server from sending further results after this
     *   method returns; if this is the case, it MUST ignore any further
     *   results.</p>
     */
    inline QDBusPendingReply<> Stop()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "SearchStateChanged" on the remote object.
     * 
     * <p>Emitted when the <tp:member-ref>SearchState</tp:member-ref> property
     *   changes. The implementation MUST NOT make transitions other than the
     *   following:</p>
     * 
     * <ul>
     *   <li><code>Not_Started</code> → <code>In_Progress</code></li>
     *   <li><code>In_Progress</code> → <code>More_Available</code></li>
     *   <li><code>More_Available</code> → <code>In_Progress</code></li>
     *   <li><code>In_Progress</code> → <code>Completed</code></li>
     *   <li><code>In_Progress</code> → <code>Failed</code></li>
     * </ul>
     *
     * \param state
     *     
     *     The new search state
     *
     * \param error
     *     
     *     If the new state is <code>Failed</code>, the name of a D-Bus error
     *     describing what went wrong. Otherwise, the empty string.
     *
     * \param details
     *     
     *     <p>Additional information about the state transition, which may
     *       include the following well-known keys:</p>
     *     
     *     <dl>
     *       <dt>debug-message (s)</dt>
     *       <dd>Debugging information on the change, corresponding to the
     *         message part of a D-Bus error message, which SHOULD NOT be
     *         displayed to users under normal circumstances</dd>
     *     </dl>
     *     
     *     <tp:rationale>
     *       <p>This argument allows for future extensions. For instance,
     *         if moving to state <code>Failed</code> because the server
     *         rejected one of our search terms, we could define a key
     *         that indicates which terms were invalid.</p>
     *     </tp:rationale>
     */
    void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);

    /**
     * Represents the signal "SearchResultReceived" on the remote object.
     * 
     * Emitted when a some search results are received from the server. This 
     * signal can be fired arbitrarily many times so clients MUST NOT assume 
     * they&apos;ll get only one signal.
     *
     * \param result
     *     
     *     A mapping from contact identifier to an array of fields 
     *     representing information about this contact.
     */
    void SearchResultReceived(const Tp::ContactSearchResultMap& result);

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

/**
 * \class ChannelTypeFileTransferInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.FileTransfer."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.FileTransfer", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
    }

    /**
     * Creates a ChannelTypeFileTransferInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeFileTransferInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeFileTransferInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeFileTransferInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeFileTransferInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeFileTransferInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeFileTransferInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "State" on the remote object.
     * 
     * <p>The state of the file transfer as described by the
     * File_Transfer_State enum.</p>
     */
    Q_PROPERTY(uint State READ _deprecated_State)

    /**
     * Getter for the remote object property "State".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyState() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint State() const
    {
        return _deprecated_State();
    }

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

    /**
     * Asynchronous getter for the remote object property "State" of type uint.
     *
     * 
     * <p>The state of the file transfer as described by the
     * File_Transfer_State enum.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyState() const
    {
        return internalRequestProperty(QLatin1String("State"));
    }

    /**
     * Represents property "ContentType" on the remote object.
     * 
     * <p>The file's MIME type. This cannot change once the channel has
     * been created.</p>
     * 
     * <p>This property is mandatory when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. Protocols which do not have a content-type property with file
     * transfers should set this value to application/octet-stream.</p>
     */
    Q_PROPERTY(QString ContentType READ _deprecated_ContentType)

    /**
     * Getter for the remote object property "ContentType".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyContentType() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString ContentType() const
    {
        return _deprecated_ContentType();
    }

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

    /**
     * Asynchronous getter for the remote object property "ContentType" of type QString.
     *
     * 
     * <p>The file's MIME type. This cannot change once the channel has
     * been created.</p>
     * 
     * <p>This property is mandatory when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. Protocols which do not have a content-type property with file
     * transfers should set this value to application/octet-stream.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyContentType() const
    {
        return internalRequestProperty(QLatin1String("ContentType"));
    }

    /**
     * Represents property "Filename" on the remote object.
     * 
     * <p>The name of the file on the sender's side. This is therefore given
     * as a suggested filename for the receiver. This cannot change
     * once the channel has been created.</p>
     * 
     * <p>This property should be the basename of the file being sent. For example,
     * if the sender sends the file /home/user/monkey.pdf then this property should
     * be set to monkey.pdf.</p>
     * 
     * <p>This property is mandatory when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. This property cannot be empty and MUST be set to a sensible value.</p>
     */
    Q_PROPERTY(QString Filename READ _deprecated_Filename)

    /**
     * Getter for the remote object property "Filename".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyFilename() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString Filename() const
    {
        return _deprecated_Filename();
    }

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

    /**
     * Asynchronous getter for the remote object property "Filename" of type QString.
     *
     * 
     * <p>The name of the file on the sender's side. This is therefore given
     * as a suggested filename for the receiver. This cannot change
     * once the channel has been created.</p>
     * 
     * <p>This property should be the basename of the file being sent. For example,
     * if the sender sends the file /home/user/monkey.pdf then this property should
     * be set to monkey.pdf.</p>
     * 
     * <p>This property is mandatory when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. This property cannot be empty and MUST be set to a sensible value.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyFilename() const
    {
        return internalRequestProperty(QLatin1String("Filename"));
    }

    /**
     * Represents property "Size" on the remote object.
     * 
     * <p>The size of the file. If this property is set, then the file
     * transfer is guaranteed to be this size. This cannot change once
     * the channel has been created.</p>
     * 
     * <p>When you are creating a channel with this property, its value
     * MUST be accurate and in bytes. However, when receiving a file, this
     * property still MUST be in bytes but might not be entirely accurate
     * to the byte.</p>
     * 
     * <p>This property is mandatory when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. If this information isn't provided in the protocol, connection managers MUST set it
     * to UINT64_MAX.</p>
     */
    Q_PROPERTY(qulonglong Size READ _deprecated_Size)

    /**
     * Getter for the remote object property "Size".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertySize() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED qulonglong Size() const
    {
        return _deprecated_Size();
    }

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

    /**
     * Asynchronous getter for the remote object property "Size" of type qulonglong.
     *
     * 
     * <p>The size of the file. If this property is set, then the file
     * transfer is guaranteed to be this size. This cannot change once
     * the channel has been created.</p>
     * 
     * <p>When you are creating a channel with this property, its value
     * MUST be accurate and in bytes. However, when receiving a file, this
     * property still MUST be in bytes but might not be entirely accurate
     * to the byte.</p>
     * 
     * <p>This property is mandatory when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. If this information isn't provided in the protocol, connection managers MUST set it
     * to UINT64_MAX.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySize() const
    {
        return internalRequestProperty(QLatin1String("Size"));
    }

    /**
     * Represents property "ContentHashType" on the remote object.
     * 
     * <p>The type of the <tp:member-ref>ContentHash</tp:member-ref> property.</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. However, if you wish to include the <tp:member-ref>ContentHash</tp:member-ref>
     * property you MUST also include this property. If you omit this property from a
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method call then its value will be assumed to be File_Hash_Type_None.</p>
     * 
     * <p>For each supported hash type, implementations SHOULD include an entry
     *   in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>
     *   with this property fixed to that hash type. If the protocol supports
     *   offering a file without a content hash, implementations SHOULD list
     *   this property in Allowed in a requestable channel class, mapping hash
     *   types they don't understand to None.
     * </p>
     */
    Q_PROPERTY(uint ContentHashType READ _deprecated_ContentHashType)

    /**
     * Getter for the remote object property "ContentHashType".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyContentHashType() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED uint ContentHashType() const
    {
        return _deprecated_ContentHashType();
    }

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

    /**
     * Asynchronous getter for the remote object property "ContentHashType" of type uint.
     *
     * 
     * <p>The type of the <tp:member-ref>ContentHash</tp:member-ref> property.</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. However, if you wish to include the <tp:member-ref>ContentHash</tp:member-ref>
     * property you MUST also include this property. If you omit this property from a
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method call then its value will be assumed to be File_Hash_Type_None.</p>
     * 
     * <p>For each supported hash type, implementations SHOULD include an entry
     *   in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>
     *   with this property fixed to that hash type. If the protocol supports
     *   offering a file without a content hash, implementations SHOULD list
     *   this property in Allowed in a requestable channel class, mapping hash
     *   types they don't understand to None.
     * </p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyContentHashType() const
    {
        return internalRequestProperty(QLatin1String("ContentHashType"));
    }

    /**
     * Represents property "ContentHash" on the remote object.
     * 
     * <p>Hash of the contents of the file transfer, of type described
     * in the value of the <tp:member-ref>ContentHashType</tp:member-ref>
     * property.</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. Its value MUST correspond to the appropriate type of the
     * <tp:member-ref>ContentHashType</tp:member-ref> property. If the
     * ContentHashType property is not set, or set to File_Hash_Type_None,
     * then this property will not even be looked at.</p>
     */
    Q_PROPERTY(QString ContentHash READ _deprecated_ContentHash)

    /**
     * Getter for the remote object property "ContentHash".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyContentHash() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString ContentHash() const
    {
        return _deprecated_ContentHash();
    }

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

    /**
     * Asynchronous getter for the remote object property "ContentHash" of type QString.
     *
     * 
     * <p>Hash of the contents of the file transfer, of type described
     * in the value of the <tp:member-ref>ContentHashType</tp:member-ref>
     * property.</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. Its value MUST correspond to the appropriate type of the
     * <tp:member-ref>ContentHashType</tp:member-ref> property. If the
     * ContentHashType property is not set, or set to File_Hash_Type_None,
     * then this property will not even be looked at.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyContentHash() const
    {
        return internalRequestProperty(QLatin1String("ContentHash"));
    }

    /**
     * Represents property "Description" on the remote object.
     * 
     * <p>Description of the file transfer. This cannot change once the
     * channel has been created.</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. If this property was not provided by the remote party, connection managers MUST set it to
     * the empty string.</p>
     */
    Q_PROPERTY(QString Description READ _deprecated_Description)

    /**
     * Getter for the remote object property "Description".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyDescription() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString Description() const
    {
        return _deprecated_Description();
    }

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

    /**
     * Asynchronous getter for the remote object property "Description" of type QString.
     *
     * 
     * <p>Description of the file transfer. This cannot change once the
     * channel has been created.</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method. If this property was not provided by the remote party, connection managers MUST set it to
     * the empty string.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyDescription() const
    {
        return internalRequestProperty(QLatin1String("Description"));
    }

    /**
     * Represents property "Date" on the remote object.
     * 
     * <p>The last modification time of the file being transferred. This
     * cannot change once the channel has been created</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method.</p>
     */
    Q_PROPERTY(qlonglong Date READ _deprecated_Date)

    /**
     * Getter for the remote object property "Date".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyDate() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED qlonglong Date() const
    {
        return _deprecated_Date();
    }

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

    /**
     * Asynchronous getter for the remote object property "Date" of type qlonglong.
     *
     * 
     * <p>The last modification time of the file being transferred. This
     * cannot change once the channel has been created</p>
     * 
     * <p>This property is optional when requesting the channel with the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>
     * method.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyDate() const
    {
        return internalRequestProperty(QLatin1String("Date"));
    }

    /**
     * Represents property "AvailableSocketTypes" on the remote object.
     * 
     * <p>A mapping from address types (members of Socket_Address_Type) to
     * arrays of access-control type (members of Socket_Access_Control)
     * that the connection manager supports for sockets with that
     * address type. For simplicity, if a CM supports offering a
     * particular type of file transfer, it is assumed to support accepting
     * it. Connection Managers MUST support at least Socket_Address_Type_IPv4.</p>
     * 
     * <p>A typical value for a host without IPv6 support:</p>
     * 
     * <pre>
     *   {
     *     Socket_Address_Type_IPv4:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Port,
     *        Socket_Access_Control_Netmask],
     *     Socket_Address_Type_Unix:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials]
     *   }
     * </pre>
     */
    Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ _deprecated_AvailableSocketTypes)

    /**
     * Getter for the remote object property "AvailableSocketTypes".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyAvailableSocketTypes() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::SupportedSocketMap AvailableSocketTypes() const
    {
        return _deprecated_AvailableSocketTypes();
    }

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

    /**
     * Asynchronous getter for the remote object property "AvailableSocketTypes" of type Tp::SupportedSocketMap.
     *
     * 
     * <p>A mapping from address types (members of Socket_Address_Type) to
     * arrays of access-control type (members of Socket_Access_Control)
     * that the connection manager supports for sockets with that
     * address type. For simplicity, if a CM supports offering a
     * particular type of file transfer, it is assumed to support accepting
     * it. Connection Managers MUST support at least Socket_Address_Type_IPv4.</p>
     * 
     * <p>A typical value for a host without IPv6 support:</p>
     * 
     * <pre>
     *   {
     *     Socket_Address_Type_IPv4:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Port,
     *        Socket_Access_Control_Netmask],
     *     Socket_Address_Type_Unix:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials]
     *   }
     * </pre>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
    {
        return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
    }

    /**
     * Represents property "TransferredBytes" on the remote object.
     * 
     * <p>The number of bytes that have been transferred at the time of
     * requesting the property. This will be updated as the file transfer
     * continues.</p>
     */
    Q_PROPERTY(qulonglong TransferredBytes READ _deprecated_TransferredBytes)

    /**
     * Getter for the remote object property "TransferredBytes".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyTransferredBytes() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED qulonglong TransferredBytes() const
    {
        return _deprecated_TransferredBytes();
    }

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

    /**
     * Asynchronous getter for the remote object property "TransferredBytes" of type qulonglong.
     *
     * 
     * <p>The number of bytes that have been transferred at the time of
     * requesting the property. This will be updated as the file transfer
     * continues.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyTransferredBytes() const
    {
        return internalRequestProperty(QLatin1String("TransferredBytes"));
    }

    /**
     * Represents property "InitialOffset" on the remote object.
     * 
     * <p>The offset in bytes from where the file should be sent. This MUST
     * be respected by both the receiver and the sender after the state
     * becomes Open, but before any data is sent or received. Until the
     * <tp:member-ref>InitialOffsetDefined</tp:member-ref> signal
     * is emitted, this property is undefined.</p>
     * 
     * <p>Before setting the <tp:member-ref>State</tp:member-ref> property to
     * Open, the connection manager MUST set the InitialOffset property,
     * possibly to 0.</p>
     * 
     * <p>This property MUST NOT change after the state of the transfer has
     * changed to Open.</p>
     */
    Q_PROPERTY(qulonglong InitialOffset READ _deprecated_InitialOffset)

    /**
     * Getter for the remote object property "InitialOffset".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialOffset() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED qulonglong InitialOffset() const
    {
        return _deprecated_InitialOffset();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialOffset" of type qulonglong.
     *
     * 
     * <p>The offset in bytes from where the file should be sent. This MUST
     * be respected by both the receiver and the sender after the state
     * becomes Open, but before any data is sent or received. Until the
     * <tp:member-ref>InitialOffsetDefined</tp:member-ref> signal
     * is emitted, this property is undefined.</p>
     * 
     * <p>Before setting the <tp:member-ref>State</tp:member-ref> property to
     * Open, the connection manager MUST set the InitialOffset property,
     * possibly to 0.</p>
     * 
     * <p>This property MUST NOT change after the state of the transfer has
     * changed to Open.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialOffset() const
    {
        return internalRequestProperty(QLatin1String("InitialOffset"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "AcceptFile" on the remote object.
     * 
     * Accept a file transfer that&apos;s in the Pending state. The file 
     * transfer&apos;s state becomes Accepted after this method is called. At 
     * this point the client can connect to the socket. CM MUST emit 
     * InitialOffsetDefined and change the state to Open before writing to the 
     * socket. Then InitialOffset should be respected in case its value 
     * differs from the offset that was specified as an argument to AcceptFile.
     *
     * \param addressType
     *     
     *     The type of address the connection manager should listen on.
     *
     * \param accessControl
     *     
     *     The type of access control the connection manager should apply to 
     *     the socket.
     *
     * \param accessControlParam
     *     
     *     A parameter for the access control type, to be interpreted as 
     *     specified in the documentation for the Socket_Access_Control enum.
     *
     * \param offset
     *     
     *     The desired offset in bytes where the file transfer should start. 
     *     The offset is taken from the beginning of the file. Specifying an 
     *     offset of zero will start the transfer from the beginning of the 
     *     file. The offset that is actually given in the InitialOffset 
     *     property can differ from this argument where the requested offset 
     *     is not supported. (For example, some protocols do not support 
     *     offsets at all so the InitialOffset property will always be 0.)
     *
     * \return
     *     
     *     The address on which the connection manager will listen for 
     *     connections for this file transfer.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "ProvideFile" on the remote object.
     * 
     * Provide the file for an outgoing file transfer which has been offered. 
     * Opens a socket that the client can use to provide a file to the 
     * connection manager. The channel MUST have been requested, and will 
     * change state to Open when this method is called if its state was 
     * Accepted.
     *
     * \param addressType
     *     
     *     The type of address the connection manager should listen on.
     *
     * \param accessControl
     *     
     *     The type of access control the connection manager should apply to 
     *     the socket.
     *
     * \param accessControlParam
     *     
     *     A parameter for the access control type, to be interpreted as 
     *     specified in the documentation for the Socket_Access_Control enum.
     *
     * \return
     *     
     *     The address on which the connection manager will listen for 
     *     connections for this file transfer.
     */
    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:
    /**
     * Represents the signal "FileTransferStateChanged" on the remote object.
     * 
     * Emitted when the state of a file transfer changes.
     *
     * \param state
     *     
     *     The new state of the file transfer; see the File_Transfer_State 
     *     enumeration.
     *
     * \param reason
     *     
     *     The reason for the state change; see the 
     *     File_Transfer_State_Change_Reason enumeration. The value will 
     *     always be File_Transfer_State_Change_Reason_None, except when 
     *     changing state to cancelled.
     */
    void FileTransferStateChanged(uint state, uint reason);

    /**
     * Represents the signal "TransferredBytesChanged" on the remote object.
     * 
     * Emitted when the number of transferred bytes changes. This will not be 
     * signalled with every single byte change. Instead, the most frequent 
     * this signal will be emitted is once a second. This should be 
     * sufficient, and the TransferredBytes property SHOULD NOT be polled.
     *
     * \param count
     *     
     *     The number of already transferred bytes.
     */
    void TransferredBytesChanged(qulonglong count);

    /**
     * Represents the signal "InitialOffsetDefined" on the remote object.
     * 
     * Emitted when the value of the InitialOffset property has been 
     * negotiated. This signal MUST be emitted before the channel becomes Open 
     * and clients have to use this offset when transferring the file.
     *
     * \param initialOffset
     *     
     *     The value of the InitialOffset property.
     */
    void InitialOffsetDefined(qulonglong initialOffset);

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

/**
 * \class ChannelTypeRoomListInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.RoomList."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.RoomList", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.RoomList";
    }

    /**
     * Creates a ChannelTypeRoomListInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeRoomListInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeRoomListInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeRoomListInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeRoomListInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeRoomListInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeRoomListInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "Server" on the remote object.
     * 
     * For protocols with a concept of chatrooms on multiple servers with 
     * different DNS names (like XMPP), the DNS name of the server whose rooms 
     * are listed by this channel, e.g. &quot;conference.jabber.org&quot;. 
     * Otherwise, the empty string. This property cannot change during the 
     * lifetime of the channel.
     */
    Q_PROPERTY(QString Server READ _deprecated_Server)

    /**
     * Getter for the remote object property "Server".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyServer() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString Server() const
    {
        return _deprecated_Server();
    }

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

    /**
     * Asynchronous getter for the remote object property "Server" of type QString.
     *
     * 
     * For protocols with a concept of chatrooms on multiple servers with 
     * different DNS names (like XMPP), the DNS name of the server whose rooms 
     * are listed by this channel, e.g. &quot;conference.jabber.org&quot;. 
     * Otherwise, the empty string. This property cannot change during the 
     * lifetime of the channel.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyServer() const
    {
        return internalRequestProperty(QLatin1String("Server"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "GetListingRooms" on the remote object.
     * 
     * Check to see if there is already a room list request in progress on 
     * this channel.
     *
     * \return
     *     
     *     A boolean indicating if room listing is in progress
     */
    inline QDBusPendingReply<bool> GetListingRooms()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<bool>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ListRooms" on the remote object.
     * 
     * Request the list of rooms from the server. The ListingRooms (True) 
     * signal should be emitted when this request is being processed, GotRooms 
     * when any room information is received, and ListingRooms (False) when 
     * the request is complete.
     */
    inline QDBusPendingReply<> ListRooms()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "StopListing" on the remote object.
     * 
     * Stop the room listing if it&apos;s in progress, but don&apos;t close 
     * the channel. The ListingRooms (False) signal should be emitted when the 
     * listing stops.
     */
    inline QDBusPendingReply<> StopListing()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "GotRooms" on the remote object.
     * 
     * <p>Emitted when information about rooms on the server becomes available.
     * The array contains the room handle (as can be passed to the
     * <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">RequestChannel</tp:dbus-ref>
     * method with HANDLE_TYPE_ROOM), the channel
     * type, and a dictionary containing further information about the
     * room as available. The following well-known keys and types are
     * recommended for use where appropriate:</p>
     * 
     * <dl>
     *   <dt>handle-name (s)</dt>
     *   <dd>The identifier of the room (as would be returned by
     *     <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">InspectHandles</tp:dbus-ref>)</dd>
     * 
     *   <dt>name (s)</dt>
     *   <dd>The human-readable name of the room if different from the handle</dd>
     * 
     *   <dt>description (s)</dt>
     *   <dd>A description of the room's overall purpose</dd>
     * 
     *   <dt>subject (s)</dt>
     *   <dd>The current subject of conversation in the room (as would
     *     be returned by getting the string part of the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Room.DRAFT">Subject</tp:dbus-ref> property)</dd>
     * 
     *   <dt>members (u)</dt>
     *   <dd>The number of members in the room</dd>
     * 
     *   <dt>password (b)</dt>
     *   <dd>True if the room requires a password to enter</dd>
     * 
     *   <dt>invite-only (b)</dt>
     *   <dd>True if you cannot join the room, but must be invited</dd>
     * 
     *   <dt>room-id (s)</dt>
     *   <dd>The human-readable identifier of a chat room (as would be
     *     returned by getting the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Room.DRAFT">RoomID</tp:dbus-ref> property)</dd>
     * 
     *   <dt>server (s)</dt>
     *   <dd>The DNS name of the server hosting these channels (as would be
     *     returned by getting the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Room.DRAFT">Server</tp:dbus-ref> property)</dd>
     * </dl>
     *
     * \param rooms
     *     
     *     An array of structs containing:
     *     <ul>
     *       <li>an integer room handle</li>
     *       <li>a string representing the D-Bus interface name of the channel type</li>
     *       <li>a dictionary mapping string keys to variant boxed information</li>
     *     </ul>
     */
    void GotRooms(const Tp::RoomInfoList& rooms);

    /**
     * Represents the signal "ListingRooms" on the remote object.
     * 
     * Emitted to indicate whether or not room listing request is currently in 
     * progress.
     *
     * \param listing
     *     
     *     A boolean indicating if room listing is in progress
     */
    void ListingRooms(bool listing);

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

/**
 * \class ChannelTypeServerTLSConnectionInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection";
    }

    /**
     * Creates a ChannelTypeServerTLSConnectionInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeServerTLSConnectionInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeServerTLSConnectionInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeServerTLSConnectionInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeServerTLSConnectionInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeServerTLSConnectionInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeServerTLSConnectionInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "ServerCertificate" on the remote object.
     * 
     * A TLSCertificate containing the certificate chain as sent by the 
     * server, and other relevant information. This property is immutable.
     */
    Q_PROPERTY(QDBusObjectPath ServerCertificate READ _deprecated_ServerCertificate)

    /**
     * Getter for the remote object property "ServerCertificate".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyServerCertificate() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QDBusObjectPath ServerCertificate() const
    {
        return _deprecated_ServerCertificate();
    }

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

    /**
     * Asynchronous getter for the remote object property "ServerCertificate" of type QDBusObjectPath.
     *
     * 
     * A TLSCertificate containing the certificate chain as sent by the 
     * server, and other relevant information. This property is immutable.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyServerCertificate() const
    {
        return internalRequestProperty(QLatin1String("ServerCertificate"));
    }

    /**
     * Represents property "Hostname" on the remote object.
     * 
     * The hostname of the server we expect ServerCertificate to certify; 
     * clients SHOULD verify ServerCertificate against 	this hostname when 
     * checking its validity.
     */
    Q_PROPERTY(QString Hostname READ _deprecated_Hostname)

    /**
     * Getter for the remote object property "Hostname".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyHostname() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString Hostname() const
    {
        return _deprecated_Hostname();
    }

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

    /**
     * Asynchronous getter for the remote object property "Hostname" of type QString.
     *
     * 
     * The hostname of the server we expect ServerCertificate to certify; 
     * clients SHOULD verify ServerCertificate against 	this hostname when 
     * checking its validity.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyHostname() const
    {
        return internalRequestProperty(QLatin1String("Hostname"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

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

/**
 * \class ChannelTypeStreamTubeInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.StreamTube."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.StreamTube", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
    }

    /**
     * Creates a ChannelTypeStreamTubeInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeStreamTubeInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeStreamTubeInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeStreamTubeInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeStreamTubeInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeStreamTubeInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeStreamTubeInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "Service" on the remote object.
     * 
     * <p> A string representing the service name that will be used over the
     *   tube.  It should be a well-known TCP service name as defined by
     *   <a href="http://www.iana.org/assignments/port-numbers">
     *     http://www.iana.org/assignments/port-numbers</a> or
     *   <a href="http://www.dns-sd.org/ServiceTypes.html">
     *     http://www.dns-sd.org/ServiceTypes.html</a>, for instance
     *   &quot;rsync&quot; or &quot;daap&quot;.</p>
     * <p>When the tube is offered, the service name is transmitted to the
     *   other end.</p>
     * <p>When requesting a channel with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>,
     *   this property MUST be included in the request.</p>
     */
    Q_PROPERTY(QString Service READ _deprecated_Service)

    /**
     * Getter for the remote object property "Service".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyService() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED QString Service() const
    {
        return _deprecated_Service();
    }

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

    /**
     * Asynchronous getter for the remote object property "Service" of type QString.
     *
     * 
     * <p> A string representing the service name that will be used over the
     *   tube.  It should be a well-known TCP service name as defined by
     *   <a href="http://www.iana.org/assignments/port-numbers">
     *     http://www.iana.org/assignments/port-numbers</a> or
     *   <a href="http://www.dns-sd.org/ServiceTypes.html">
     *     http://www.dns-sd.org/ServiceTypes.html</a>, for instance
     *   &quot;rsync&quot; or &quot;daap&quot;.</p>
     * <p>When the tube is offered, the service name is transmitted to the
     *   other end.</p>
     * <p>When requesting a channel with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>,
     *   this property MUST be included in the request.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyService() const
    {
        return internalRequestProperty(QLatin1String("Service"));
    }

    /**
     * Represents property "SupportedSocketTypes" on the remote object.
     * 
     * <p>A mapping from address types (members of Socket_Address_Type) to
     * arrays of access-control type (members of Socket_Access_Control)
     * that the connection manager supports for stream tubes with that
     * address type. For simplicity, if a CM supports offering a
     * particular type of tube, it is assumed to support accepting it.</p>
     * 
     * <p>A typical value for a host without IPv6 support:</p>
     * 
     * <pre>
     *   {
     *     Socket_Address_Type_IPv4:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Port,
     *        Socket_Access_Control_Netmask],
     *     Socket_Address_Type_Unix:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials]
     *   }
     * </pre>
     * 
     * <p>Connection Managers MUST support at least IPv4 with the localhost
     *   access control.</p>
     * 
     * <p>When requesting a channel with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>,
     *   this property MUST NOT be included in the request.</p>
     */
    Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ _deprecated_SupportedSocketTypes)

    /**
     * Getter for the remote object property "SupportedSocketTypes".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertySupportedSocketTypes() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED Tp::SupportedSocketMap SupportedSocketTypes() const
    {
        return _deprecated_SupportedSocketTypes();
    }

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

    /**
     * Asynchronous getter for the remote object property "SupportedSocketTypes" of type Tp::SupportedSocketMap.
     *
     * 
     * <p>A mapping from address types (members of Socket_Address_Type) to
     * arrays of access-control type (members of Socket_Access_Control)
     * that the connection manager supports for stream tubes with that
     * address type. For simplicity, if a CM supports offering a
     * particular type of tube, it is assumed to support accepting it.</p>
     * 
     * <p>A typical value for a host without IPv6 support:</p>
     * 
     * <pre>
     *   {
     *     Socket_Address_Type_IPv4:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Port,
     *        Socket_Access_Control_Netmask],
     *     Socket_Address_Type_Unix:
     *       [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials]
     *   }
     * </pre>
     * 
     * <p>Connection Managers MUST support at least IPv4 with the localhost
     *   access control.</p>
     * 
     * <p>When requesting a channel with
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.Interface.Requests.CreateChannel</tp:dbus-ref>,
     *   this property MUST NOT be included in the request.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
    {
        return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "Offer" on the remote object.
     * 
     * Offer a stream tube exporting the local socket specified.
     *
     * \param addresstype
     *     
     *     The type of the listening address of the local service, as a member 
     *     of Socket_Address_Type.
     *
     * \param address
     *     
     *     The listening address of the local service, as indicated by the 
     *     address_type.
     *
     * \param accesscontrol
     *     
     *     The access control the local service applies to the local socket, 
     *     specified so the connection manager can behave appropriately when 
     *     it connects.
     *
     * \param parameters
     *     
     *     The dictionary of arbitrary Parameters to send with the tube offer.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "Accept" on the remote object.
     * 
     * Accept a stream tube that&apos;s in the &quot;local pending&quot; 
     * state. The connection manager will attempt to open the tube. The tube 
     * remains in the &quot;local pending&quot; state until the 
     * TubeChannelStateChanged signal is emitted.
     *
     * \param addresstype
     *     
     *     The type of address the connection manager should listen on.
     *
     * \param accesscontrol
     *     
     *     <p>The type of access control the connection manager should apply to
     *     the socket.</p>
     *     
     *     <p>Note that if you plan to establish more than one connection
     *     through the tube, the Socket_Access_Control_Port access control
     *     can't be used as you can't connect more than once from the same
     *     port.</p>
     *
     * \param accesscontrolparam
     *     
     *     A parameter for the access control type, to be interpreted as 
     *     specified in the documentation for the Socket_Access_Control enum.
     *
     * \return
     *     
     *     The address on which the connection manager will listen for 
     *     connections to this tube. The client should not attempt to connect 
     *     to the address until the tube is open.
     */
    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:
    /**
     * Represents the signal "NewRemoteConnection" on the remote object.
     * 
     * <p>Emitted each time a participant opens a new connection to its
     * socket.</p>
     * 
     * <p>This signal is only fired on the offering side.</p>
     *
     * \param handle
     *     
     *     The handle of the participant who opened the new connection
     *
     * \param connectionParam
     *     
     *     <p>A parameter which can be used by the listening process to identify
     *     the connection. Note that this parameter has a meaningful value
     *     only in the Socket_Access_Control_Port and
     *     Socket_Access_Control_Credentials cases. If a different
     *     Socket_Access_Control has been chosen when offering the tube, this
     *     parameter should be ignored.</p>
     *     
     *     <p>In the Socket_Access_Control_Port case, the variant
     *     contains a struct Socket_Address_IPv4 (or Socket_Address_IPv6)
     *     containing the address from which the CM is connected to the client
     *     application.</p>
     *     
     *     <p>In the Socket_Access_Control_Credentials case, the variant
     *     contains the byte (D-Bus signature 'y') that has been sent with
     *     the credentials.</p>
     *
     * \param connectionID
     *     
     *     The unique ID associated with this connection. This ID will be used 
     *     to identifiy the connection when reporting errors with 
     *     ConnectionClosed.
     */
    void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);

    /**
     * Represents the signal "NewLocalConnection" on the remote object.
     * 
     * <p>Emitted when the tube application connects to the CM's socket.</p>
     * 
     * <p>This signal is only fired on the accepting side.</p>
     *
     * \param connectionID
     *     
     *     The unique ID associated with this connection. This ID will be used 
     *     to identifiy the connection when reporting errors with 
     *     ConnectionClosed.
     */
    void NewLocalConnection(uint connectionID);

    /**
     * Represents the signal "ConnectionClosed" on the remote object.
     * 
     * <p>Emitted when a connection has been closed.</p>
     *
     * \param connectionID
     *     
     *     The ID of the connection.
     *
     * \param error
     *     
     *     <p>The name of a D-Bus error describing the error that occurred.</p>
     *     
     *     <p>The following errors can be used:</p>
     *     <ul>
     *       <li><code>org.freedesktop.Telepathy.Error.Cancelled</code>:
     *          user closed the socket or the tube.</li>
     *       <li><code>org.freedesktop.Telepathy.Error.ConnectionLost</code>:
     *          the bytestream relaying connection's data has been broken.</li>
     *       <li><code>org.freedesktop.Telepathy.Error.ConnectionRefused</code>:
     *          the tube offer refused the connection.</li>
     *     </ul>
     *
     * \param message
     *     
     *     A debug message.
     */
    void ConnectionClosed(uint connectionID, const QString& error, const QString& message);

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

/**
 * \class ChannelTypeStreamedMediaInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.StreamedMedia."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.StreamedMedia", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
    }

    /**
     * Creates a ChannelTypeStreamedMediaInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeStreamedMediaInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeStreamedMediaInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeStreamedMediaInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeStreamedMediaInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeStreamedMediaInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeStreamedMediaInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Represents property "InitialAudio" on the remote object.
     * 
     * <p>If set to true in a channel request that will create a new channel,
     *   the connection manager should immediately attempt to establish an
     *   audio stream to the remote contact, making it unnecessary for the
     *   client to call <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.StreamedMedia">RequestStreams</tp:dbus-ref>.</p>
     * 
     * <p>If this property, or InitialVideo, is passed to EnsureChannel
     *   (as opposed to CreateChannel), the connection manager SHOULD ignore
     *   these properties when checking whether it can return an existing
     *   channel as suitable; these properties only become significant when
     *   the connection manager has decided to create a new channel.</p>
     * 
     * <p>If true on a requested channel, this indicates that the audio
     *   stream has already been requested and the client does not need to
     *   call RequestStreams, although it MAY still do so.</p>
     * 
     * <p>If true on an unrequested (incoming) channel, this indicates that
     *   the remote contact initially requested an audio stream; this does
     *   not imply that that audio stream is still active (as indicated by
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.StreamedMedia">ListStreams</tp:dbus-ref>).</p>
     * 
     * <p>This property is immutable (cannot change), and therefore SHOULD
     *   appear wherever immutable properties are reported, e.g. <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">NewChannels</tp:dbus-ref>
     *   signals.</p>
     * 
     * <tp:rationale><p>This reduces D-Bus round trips.</p></tp:rationale>
     * 
     * <p>Connection managers capable of signalling audio calls to contacts
     *   SHOULD include a channel class in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>
     *   with <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">ChannelType</tp:dbus-ref>
     *   = <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">StreamedMedia</tp:dbus-ref>
     *   and <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandleType</tp:dbus-ref>
     *   = Contact in the fixed properties dictionary, and InitialAudio
     *   (and also InitialVideo, if applicable) in the allowed properties
     *   list. Clients wishing to discover whether a connection manager
     *   can signal audio and/or video calls SHOULD use this information.</p>
     * 
     * <tp:rationale>
     *   <p>Not all protocols support signalling video calls, and it would be
     *     possible (although unlikely) to have a protocol where only video,
     *     and not audio, could be signalled.</p>
     * </tp:rationale>
     * 
     * <p>Connection managers that support the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface">ContactCapabilities</tp:dbus-ref>
     *   interface SHOULD represent the capabilities of receiving audio
     *   and/or video calls by including a channel class in
     *   a contact's capabilities with ChannelType = StreamedMedia
     *   in the fixed properties dictionary, and InitialAudio and/or
     *   InitialVideo in the allowed properties list. Clients wishing to
     *   discover whether a particular contact is likely to be able to
     *   receive audio and/or video calls SHOULD use this information.</p>
     * 
     * <tp:rationale>
     *   <p>Not all clients support video calls, and it would also be
     *     possible (although unlikely) to have a client which could only
     *     stream video, not audio.</p>
     * </tp:rationale>
     * 
     * <p>Clients that are willing to receive audio and/or video calls
     *   SHOULD include the following among their channel classes if
     *   calling <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities">UpdateCapabilities</tp:dbus-ref>
     *   (clients of a <tp:dbus-ref namespace="org.freedesktop.Telepathy">ChannelDispatcher</tp:dbus-ref>
     *   SHOULD instead arrange for the ChannelDispatcher to do this,
     *   by including the filters in their <tp:dbus-ref namespace="org.freedesktop.Telepathy.Client.Handler">HandlerChannelFilter</tp:dbus-ref>
     *   properties):</p>
     * 
     * <ul>
     *   <li>{ ChannelType = StreamedMedia }</li>
     *   <li>{ ChannelType = StreamedMedia, InitialAudio = true }
     *     if receiving calls with audio is supported</li>
     *   <li>{ ChannelType = StreamedMedia, InitialVideo = true }
     *     if receiving calls with video is supported</li>
     * </ul>
     * 
     * <tp:rationale>
     *   <p>Connection managers for protocols with capability discovery,
     *     like XMPP, need this information to advertise the appropriate
     *     capabilities for their protocol.</p>
     * </tp:rationale>
     */
    Q_PROPERTY(bool InitialAudio READ _deprecated_InitialAudio)

    /**
     * Getter for the remote object property "InitialAudio".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialAudio() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED bool InitialAudio() const
    {
        return _deprecated_InitialAudio();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialAudio" of type bool.
     *
     * 
     * <p>If set to true in a channel request that will create a new channel,
     *   the connection manager should immediately attempt to establish an
     *   audio stream to the remote contact, making it unnecessary for the
     *   client to call <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.StreamedMedia">RequestStreams</tp:dbus-ref>.</p>
     * 
     * <p>If this property, or InitialVideo, is passed to EnsureChannel
     *   (as opposed to CreateChannel), the connection manager SHOULD ignore
     *   these properties when checking whether it can return an existing
     *   channel as suitable; these properties only become significant when
     *   the connection manager has decided to create a new channel.</p>
     * 
     * <p>If true on a requested channel, this indicates that the audio
     *   stream has already been requested and the client does not need to
     *   call RequestStreams, although it MAY still do so.</p>
     * 
     * <p>If true on an unrequested (incoming) channel, this indicates that
     *   the remote contact initially requested an audio stream; this does
     *   not imply that that audio stream is still active (as indicated by
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type.StreamedMedia">ListStreams</tp:dbus-ref>).</p>
     * 
     * <p>This property is immutable (cannot change), and therefore SHOULD
     *   appear wherever immutable properties are reported, e.g. <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">NewChannels</tp:dbus-ref>
     *   signals.</p>
     * 
     * <tp:rationale><p>This reduces D-Bus round trips.</p></tp:rationale>
     * 
     * <p>Connection managers capable of signalling audio calls to contacts
     *   SHOULD include a channel class in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">RequestableChannelClasses</tp:dbus-ref>
     *   with <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">ChannelType</tp:dbus-ref>
     *   = <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">StreamedMedia</tp:dbus-ref>
     *   and <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandleType</tp:dbus-ref>
     *   = Contact in the fixed properties dictionary, and InitialAudio
     *   (and also InitialVideo, if applicable) in the allowed properties
     *   list. Clients wishing to discover whether a connection manager
     *   can signal audio and/or video calls SHOULD use this information.</p>
     * 
     * <tp:rationale>
     *   <p>Not all protocols support signalling video calls, and it would be
     *     possible (although unlikely) to have a protocol where only video,
     *     and not audio, could be signalled.</p>
     * </tp:rationale>
     * 
     * <p>Connection managers that support the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface">ContactCapabilities</tp:dbus-ref>
     *   interface SHOULD represent the capabilities of receiving audio
     *   and/or video calls by including a channel class in
     *   a contact's capabilities with ChannelType = StreamedMedia
     *   in the fixed properties dictionary, and InitialAudio and/or
     *   InitialVideo in the allowed properties list. Clients wishing to
     *   discover whether a particular contact is likely to be able to
     *   receive audio and/or video calls SHOULD use this information.</p>
     * 
     * <tp:rationale>
     *   <p>Not all clients support video calls, and it would also be
     *     possible (although unlikely) to have a client which could only
     *     stream video, not audio.</p>
     * </tp:rationale>
     * 
     * <p>Clients that are willing to receive audio and/or video calls
     *   SHOULD include the following among their channel classes if
     *   calling <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities">UpdateCapabilities</tp:dbus-ref>
     *   (clients of a <tp:dbus-ref namespace="org.freedesktop.Telepathy">ChannelDispatcher</tp:dbus-ref>
     *   SHOULD instead arrange for the ChannelDispatcher to do this,
     *   by including the filters in their <tp:dbus-ref namespace="org.freedesktop.Telepathy.Client.Handler">HandlerChannelFilter</tp:dbus-ref>
     *   properties):</p>
     * 
     * <ul>
     *   <li>{ ChannelType = StreamedMedia }</li>
     *   <li>{ ChannelType = StreamedMedia, InitialAudio = true }
     *     if receiving calls with audio is supported</li>
     *   <li>{ ChannelType = StreamedMedia, InitialVideo = true }
     *     if receiving calls with video is supported</li>
     * </ul>
     * 
     * <tp:rationale>
     *   <p>Connection managers for protocols with capability discovery,
     *     like XMPP, need this information to advertise the appropriate
     *     capabilities for their protocol.</p>
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialAudio() const
    {
        return internalRequestProperty(QLatin1String("InitialAudio"));
    }

    /**
     * Represents property "InitialVideo" on the remote object.
     * 
     * <p>The same as <tp:member-ref>InitialAudio</tp:member-ref>, but for
     *   a video stream. This property is immutable (cannot change).</p>
     * 
     * <p>In particular, note that if this property is false, this does not
     *   imply that an active video stream has not been added, only that no
     *   video stream was active at the time the channel appeared.</p>
     * 
     * <p>This property is the correct way to discover whether connection
     *   managers, contacts etc. support video calls; it appears in
     *   capabilities structures in the same way as InitialAudio.</p>
     */
    Q_PROPERTY(bool InitialVideo READ _deprecated_InitialVideo)

    /**
     * Getter for the remote object property "InitialVideo".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyInitialVideo() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED bool InitialVideo() const
    {
        return _deprecated_InitialVideo();
    }

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

    /**
     * Asynchronous getter for the remote object property "InitialVideo" of type bool.
     *
     * 
     * <p>The same as <tp:member-ref>InitialAudio</tp:member-ref>, but for
     *   a video stream. This property is immutable (cannot change).</p>
     * 
     * <p>In particular, note that if this property is false, this does not
     *   imply that an active video stream has not been added, only that no
     *   video stream was active at the time the channel appeared.</p>
     * 
     * <p>This property is the correct way to discover whether connection
     *   managers, contacts etc. support video calls; it appears in
     *   capabilities structures in the same way as InitialAudio.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyInitialVideo() const
    {
        return internalRequestProperty(QLatin1String("InitialVideo"));
    }

    /**
     * Represents property "ImmutableStreams" on the remote object.
     * 
     * <p>If <tt>True</tt>, once streams have been requested for this channel
     *   (either by setting <tp:member-ref>InitialAudio</tp:member-ref> or
     *   <tp:member-ref>InitialVideo</tp:member-ref> when the channel is
     *   requested, or by calling
     *   <tp:member-ref>RequestStreams</tp:member-ref> on a channel with no
     *   streams), a stream of a different content type cannot be added;
     *   subsequent calls to <tp:member-ref>RequestStreams</tp:member-ref>
     *   that attempt to do so will fail.</p>
     * 
     * <p>If this property is missing, clients SHOULD assume that it is false,
     *   and thus that the channel's streams can be changed once the call has
     *   started.</p>
     * 
     * <p>If this property is present in the &quot;allowed&quot; set in all of the
     *   StreamedMedia entries in a contact's capabilities, then user
     *   interfaces MAY choose to show a separate &quot;call&quot; option for each
     *   class of call.</p>
     * 
     *   <tp:rationale>
     *     <p>For example, once an audio-only Google Talk call has started,
     *       it is not possible to add a video stream; both audio and video
     *       must be requested at the start of the call if video is desired.
     *       User interfaces may use this pseudo-capability as a hint to
     *       display separate &quot;Audio call&quot; and &quot;Video call&quot; buttons, rather
     *       than a single &quot;Call&quot; button with the option to add and remove
     *       video once the call has started for contacts without this flag.
     *     </p>
     *   </tp:rationale>
     * 
     * <p>This property is immutable, and therefore SHOULD be announced
     *   in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">NewChannels</tp:dbus-ref>,
     *   etc.</p>
     */
    Q_PROPERTY(bool ImmutableStreams READ _deprecated_ImmutableStreams)

    /**
     * Getter for the remote object property "ImmutableStreams".
     *
     * Don't use this: it blocks the main loop. Use the asynchronous
     * requestPropertyImmutableStreams() instead.
     *
     * \return The value of the property, or a default-constructed value
     *          if the property is not readable.
     */
    inline TELEPATHY_QT4_DEPRECATED bool ImmutableStreams() const
    {
        return _deprecated_ImmutableStreams();
    }

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

    /**
     * Asynchronous getter for the remote object property "ImmutableStreams" of type bool.
     *
     * 
     * <p>If <tt>True</tt>, once streams have been requested for this channel
     *   (either by setting <tp:member-ref>InitialAudio</tp:member-ref> or
     *   <tp:member-ref>InitialVideo</tp:member-ref> when the channel is
     *   requested, or by calling
     *   <tp:member-ref>RequestStreams</tp:member-ref> on a channel with no
     *   streams), a stream of a different content type cannot be added;
     *   subsequent calls to <tp:member-ref>RequestStreams</tp:member-ref>
     *   that attempt to do so will fail.</p>
     * 
     * <p>If this property is missing, clients SHOULD assume that it is false,
     *   and thus that the channel's streams can be changed once the call has
     *   started.</p>
     * 
     * <p>If this property is present in the &quot;allowed&quot; set in all of the
     *   StreamedMedia entries in a contact's capabilities, then user
     *   interfaces MAY choose to show a separate &quot;call&quot; option for each
     *   class of call.</p>
     * 
     *   <tp:rationale>
     *     <p>For example, once an audio-only Google Talk call has started,
     *       it is not possible to add a video stream; both audio and video
     *       must be requested at the start of the call if video is desired.
     *       User interfaces may use this pseudo-capability as a hint to
     *       display separate &quot;Audio call&quot; and &quot;Video call&quot; buttons, rather
     *       than a single &quot;Call&quot; button with the option to add and remove
     *       video once the call has started for contacts without this flag.
     *     </p>
     *   </tp:rationale>
     * 
     * <p>This property is immutable, and therefore SHOULD be announced
     *   in <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Requests">NewChannels</tp:dbus-ref>,
     *   etc.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyImmutableStreams() const
    {
        return internalRequestProperty(QLatin1String("ImmutableStreams"));
    }

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "ListStreams" on the remote object.
     * 
     * Returns an array of structs representing the streams currently active 
     * within this channel. Each stream is identified by an unsigned integer 
     * which is unique for each stream within the channel.
     *
     * \return
     *     
     *     An array of structs containing:
     *     <ul>
     *     <li>the stream identifier</li>
     *     <li>the contact handle who the stream is with (or 0 if the stream
     *       represents more than a single member)</li>
     *     <li>the type of the stream</li>
     *     <li>the current stream state</li>
     *     <li>the current direction of the stream</li>
     *     <li>the current pending send flags</li>
     *     </ul>
     */
    inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RemoveStreams" on the remote object.
     * 
     * <p>Request that the given streams are removed. If all streams are
     *   removed, the channel MAY close.</p>
     * 
     * <p>Clients SHOULD NOT attempt to terminate calls by removing all the
     *   streams; instead, clients SHOULD terminate calls by removing the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Group.SelfHandle</tp:dbus-ref>
     *   from the channel, using either
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Group">RemoveMembers</tp:dbus-ref>
     *   or
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface.Group">RemoveMembersWithReason</tp:dbus-ref>.
     *   </p>
     *
     * \param streams
     *     
     *     An array of stream identifiers (as defined in 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);
    }

    /**
     * Begins a call to the D-Bus method "RequestStreamDirection" on the remote object.
     * 
     * <p>Request a change in the direction of an existing stream. In particular,
     * this might be useful to stop sending media of a particular type,
     * or inform the peer that you are no longer using media that is being
     * sent to you.</p>
     * 
     * <p>Depending on the protocol, streams which are no longer sending in
     * either direction should be removed and a
     * <tp:member-ref>StreamRemoved</tp:member-ref> signal emitted.
     * Some direction changes can be enforced locally (for example,
     * BIDIRECTIONAL -&gt; RECEIVE can be achieved by merely stopping sending),
     * others may not be possible on some protocols, and some need agreement
     * from the remote end. In this case, the MEDIA_STREAM_PENDING_REMOTE_SEND
     * flag will be set in the
     * <tp:member-ref>StreamDirectionChanged</tp:member-ref> signal, and the
     * signal
     * emitted again without the flag to indicate the resulting direction when
     * the remote end has accepted or rejected the change.</p>
     *
     * \param streamID
     *     
     *     The stream identifier (as defined in ListStreams)
     *
     * \param streamDirection
     *     
     *     The desired stream direction (a value of MediaStreamDirection)
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "RequestStreams" on the remote object.
     * 
     * <p>Request that streams be established to exchange the given types of
     * media with the given member. In general this will try and establish a
     * bidirectional stream, but on some protocols it may not be possible to
     * indicate to the peer that you would like to receive media, so a
     * send-only stream will be created initially. In the cases where the
     * stream requires remote agreement (eg you wish to receive media from
     * them), the <tp:member-ref>StreamDirectionChanged</tp:member-ref> signal
     * will be emitted with the
     * MEDIA_STREAM_PENDING_REMOTE_SEND flag set, and the signal emitted again
     * with the flag cleared when the remote end has replied.</p>
     * 
     * <p>If streams of the requested types already exist, calling this
     *   method results in the creation of additional streams. Accordingly,
     *   clients wishing to have exactly one audio stream or exactly one
     *   video stream SHOULD check for the current streams using
     *   <tp:member-ref>ListStreams</tp:member-ref> before calling this
     *   method.</p>
     *
     * \param contactHandle
     *     
     *     A contact handle with whom to establish the streams
     *
     * \param types
     *     
     *     An array of stream types (values of MediaStreamType)
     *
     * \return
     *     
     *     An array of structs (in the same order as the given stream types)
     *     containing:
     *     <ul>
     *       <li>the stream identifier</li>
     *       <li>the contact handle who the stream is with (or 0 if the stream
     *         represents more than a single member)</li>
     *       <li>the type of the stream</li>
     *       <li>the current stream state</li>
     *       <li>the current direction of the stream</li>
     *       <li>the current pending send flags</li>
     *     </ul>
     */
    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:
    /**
     * Represents the signal "StreamAdded" on the remote object.
     * 
     * <p>Emitted when a new stream has been added to this channel.
     *   Clients SHOULD assume that the stream's
     *   <tp:type>Media_Stream_State</tp:type> is initially Disconnected.</p>
     * 
     * <p>If a connection manager needs to represent the addition of a stream
     *   whose state is already Connecting or Connected, it MUST do this
     *   by emitting StreamAdded, closely followed by
     *   <tp:member-ref>StreamStateChanged</tp:member-ref> indicating a
     *   change to the appropriate state.</p>
     * 
     * <tp:rationale>
     *   <p>Historically, it was not clear from the StreamAdded signal what
     *     the state of the stream was. telepathy-spec 0.17.22
     *     clarified this.</p>
     * </tp:rationale>
     * 
     * <p>Similarly, clients SHOULD assume that the initial
     *   <tp:type>Media_Stream_Direction</tp:type> of a newly added stream
     *   is Receive, and that the initial
     *   <tp:type>Media_Stream_Pending_Send</tp:type> is
     *   Pending_Local_Send.</p>
     * 
     * <p>If a connection manager needs to represent the addition of a stream
     *   whose direction or pending-send differs from those initial values,
     *   it MUST do so by emitting StreamAdded, closely followed by
     *   <tp:member-ref>StreamDirectionChanged</tp:member-ref> indicating a
     *   change to the appropriate direction and pending-send state.</p>
     * 
     * <tp:rationale>
     *   <p>StreamAdded doesn't itself indicate the stream's direction; this
     *     is unfortunate, but is preserved for compatibility.</p>
     * 
     *   <p>This is the appropriate direction for streams added by a remote
     *     contact on existing connection managers, and does not violate
     *     user privacy by automatically sending audio or video (audio streams
     *     start off muted, video streams start off not sending). For
     *     streams added by the local user using the client receiving the
     *     signal, the true direction can also be determined from the return
     *     value of the <tp:member-ref>RequestStreams</tp:member-ref>
     *     method.</p>
     * 
     *   <p>Existing clients typically operate by maintaining a separate
     *     idea of the directions that they would like the streams to have,
     *     and enforcing these intended directions by calling
     *     <tp:member-ref>RequestStreamDirection</tp:member-ref> whenever
     *     needed.</p>
     * </tp:rationale>
     *
     * \param streamID
     *     
     *     The stream identifier (as defined in ListStreams)
     *
     * \param contactHandle
     *     
     *     The contact handle who the stream is with (or 0 if it represents 
     *     more than a single member)
     *
     * \param streamType
     *     
     *     The stream type (a value from MediaStreamType)
     */
    void StreamAdded(uint streamID, uint contactHandle, uint streamType);

    /**
     * Represents the signal "StreamDirectionChanged" on the remote object.
     * 
     * <p>Emitted when the direction or pending flags of a stream are
     *   changed.</p>
     * 
     * <p>If the MEDIA_STREAM_PENDING_LOCAL_SEND flag is set, the remote user
     *   has requested that we begin sending on this stream.
     *   <tp:member-ref>RequestStreamDirection</tp:member-ref>
     *   should be called to indicate whether or not this change is
     *   acceptable.</p>
     * 
     * <tp:rationale>
     *   <p>This allows for a MSN-style user interface, &quot;Fred has asked you
     *     to enable your webcam. (Accept | Reject)&quot;, if desired.</p>
     * </tp:rationale>
     *
     * \param streamID
     *     
     *     The stream identifier (as defined in ListStreams)
     *
     * \param streamDirection
     *     
     *     The new stream direction (as defined in ListStreams)
     *
     * \param pendingFlags
     *     
     *     The new pending send flags (as defined in ListStreams)
     */
    void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);

    /**
     * Represents the signal "StreamError" on the remote object.
     * 
     * Emitted when a stream encounters an error.
     *
     * \param streamID
     *     
     *     The stream identifier (as defined in ListStreams)
     *
     * \param errorCode
     *     
     *     A stream error number, one of the values of MediaStreamError
     *
     * \param message
     *     
     *     A string describing the error (for debugging purposes only)
     */
    void StreamError(uint streamID, uint errorCode, const QString& message);

    /**
     * Represents the signal "StreamRemoved" on the remote object.
     * 
     * Emitted when a stream has been removed from this channel.
     *
     * \param streamID
     *     
     *     stream_id - the stream identifier (as defined in ListStreams)
     */
    void StreamRemoved(uint streamID);

    /**
     * Represents the signal "StreamStateChanged" on the remote object.
     * 
     * Emitted when a member&apos;s stream&apos;s state changes.
     *
     * \param streamID
     *     
     *     The stream identifier (as defined in ListStreams)
     *
     * \param streamState
     *     
     *     The new stream state (as defined in ListStreams)
     */
    void StreamStateChanged(uint streamID, uint streamState);

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

/**
 * \class ChannelTypeTextInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.Text."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.Text", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.Text";
    }

    /**
     * Creates a ChannelTypeTextInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeTextInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeTextInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeTextInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeTextInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeTextInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeTextInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeTextInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "AcknowledgePendingMessages" on the remote object.
     * 
     * Inform the channel that you have handled messages by displaying them to 
     * the user (or equivalent), so they can be removed from the pending queue.
     *
     * \param IDs
     *     
     *     The IDs of the messages to acknowledge
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "GetMessageTypes" on the remote object.
     * 
     * Return an array indicating which types of message may be sent on this 
     * channel.
     *
     * \return
     *     
     *     An array of integer message types (ChannelTextMessageType)
     */
    inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ListPendingMessages" on the remote object.
     * 
     * List the messages currently in the pending queue, and optionally remove 
     * then all.
     *
     * \param clear
     *     
     *     If true, behave as if AcknowledgePendingMessages had also been 
     *     called.
     *
     * \return
     *     
     *     An array of structs representing the pending queue. Each contains:
     *     <ul>
     *       <li>a numeric identifier</li>
     *       <li>a Unix timestamp indicating when the message was received</li>
     *       <li>the contact handle for the contact who sent the message</li>
     *       <li>the message type, taken from ChannelTextMessageType</li>
     *       <li>the bitwise-OR of the message flags from ChannelTextMessageFlags</li>
     *       <li>the text of the message</li>
     *     </ul>
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "Send" on the remote object.
     * 
     * <p>Request that a message be sent on this channel. When the message has
     *   been submitted for delivery, this method will return and the
     *   <tp:member-ref>Sent</tp:member-ref> signal will be emitted. If the
     *   message cannot be submitted for delivery, the method returns an error
     *   and no signal is emitted.</p>
     * 
     * <p>This method SHOULD return before the Sent signal is
     *   emitted.</p>
     * 
     * <tp:rationale>
     *   <p>When a Text channel implements the <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Interface">Messages</tp:dbus-ref>
     *     interface, that &quot;SHOULD&quot; becomes a &quot;MUST&quot;.</p>
     * </tp:rationale>
     *
     * \param type
     *     
     *     An integer indicating the type of the message
     *
     * \param text
     *     
     *     The message to send
     */
    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:
    /**
     * Represents the signal "LostMessage" on the remote object.
     * 
     * This signal is emitted to indicate that an incoming message was not 
     * able to be stored and forwarded by the connection manager due to lack 
     * of memory.
     */
    void LostMessage();

    /**
     * Represents the signal "Received" on the remote object.
     * 
     * Signals that a message with the given id, timestamp, sender, type and 
     * text has been received on this channel. Applications that catch this 
     * signal and reliably inform the user of the message should acknowledge 
     * that they have dealt with the message with the 
     * AcknowledgePendingMessages method.
     *
     * \param ID
     *     
     *     A numeric identifier for acknowledging the message
     *
     * \param timestamp
     *     
     *     A Unix timestamp indicating when the message was received
     *
     * \param sender
     *     
     *     The handle of the contact who sent the message
     *
     * \param type
     *     
     *     The type of the message (normal, action, notice, etc.)
     *
     * \param flags
     *     
     *     A bitwise OR of the message flags
     *
     * \param text
     *     
     *     The text of the message
     */
    void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);

    /**
     * Represents the signal "SendError" on the remote object.
     * 
     * <p>Signals that an outgoing message has failed to send. The error
     *   will be one of the values from ChannelTextSendError.</p>
     * 
     * <p>This signal should only be emitted for messages for which
     *   <tp:member-ref>Sent</tp:member-ref> has already been emitted and
     *   <tp:member-ref>Send</tp:member-ref> has already returned success.</p>
     *
     * \param error
     *     
     *     The error that occurred
     *
     * \param timestamp
     *     
     *     The Unix timestamp indicating when the message was sent
     *
     * \param type
     *     
     *     The message type
     *
     * \param text
     *     
     *     The text of the message
     */
    void SendError(uint error, uint timestamp, uint type, const QString& text);

    /**
     * Represents the signal "Sent" on the remote object.
     * 
     * <p>Signals that a message has been submitted for sending.</p>
     *
     * \param timestamp
     *     
     *     Unix timestamp indicating when the message was sent
     *
     * \param type
     *     
     *     The message type (normal, action, notice, etc) from 
     *     ChannelTextMessageType
     *
     * \param text
     *     
     *     The text of the message. If the message was, or will be, altered 
     *     during transmission, this argument SHOULD reflect what other 
     *     contacts will receive rather than being a copy of the argument to 
     *     Send.
     */
    void Sent(uint timestamp, uint type, const QString& text);

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

/**
 * \class ChannelTypeTubesInterface
 * \headerfile TelepathyQt4/channel.h <TelepathyQt4/Channel>
 * \ingroup clientchannel
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Channel.Type.Tubes."
 */
class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    /**
     * Returns the name of the interface "org.freedesktop.Telepathy.Channel.Type.Tubes", which this class
     * represents.
     *
     * \return The D-Bus interface name.
     */
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Channel.Type.Tubes";
    }

    /**
     * Creates a ChannelTypeTubesInterface associated with the given object on the session bus.
     *
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeTubesInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeTubesInterface associated with the given object on the given bus.
     *
     * \param connection The bus via which the object can be reached.
     * \param busName Name of the service the object is on.
     * \param objectPath Path to the object on the service.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeTubesInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ChannelTypeTubesInterface associated with the same object as the given proxy.
     *
     * \param proxy The proxy to use. It will also be the QObject::parent()
     *               for this object.
     */
    ChannelTypeTubesInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ChannelTypeTubesInterface associated with the same object as the given proxy.
     * Additionally, the created proxy will have the same parent as the given
     * proxy.
     *
     * \param mainInterface The proxy to use.
     */
    explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);

    /**
     * Creates a ChannelTypeTubesInterface associated with the same object as the given proxy.
     * However, a different parent object can be specified.
     *
     * \param mainInterface The proxy to use.
     * \param parent Passed to the parent class constructor.
     */
    ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);

    /**
     * Request all of the DBus properties on the interface.
     *
     * \return A pending variant map which will emit finished when the properties have
     *          been retrieved.
     */
    Tp::PendingVariantMap *requestAllProperties() const
    {
        return internalRequestAllProperties();
    }

public Q_SLOTS:
    /**
     * Begins a call to the D-Bus method "GetAvailableStreamTubeTypes" on the remote object.
     * 
     * List the available address types and access-control types for stream 
     * tubes.
     *
     * \return
     *     
     *     <p>A mapping from address types (members of Socket_Address_Type) to
     *     arrays of access-control type (members of Socket_Access_Control)
     *     that the connection manager supports for stream tubes with that
     *     address type. For simplicity, if a CM supports offering a
     *     particular type of tube, it is assumed to support accepting it.</p>
     *     
     *     <p>A typical value for a host without IPv6 support:</p>
     *     
     *     <pre>
     *       {
     *         Socket_Address_Type_IPv4:
     *           [Socket_Access_Control_Localhost, Socket_Access_Control_Port,
     *            Socket_Access_Control_Netmask],
     *         Socket_Address_Type_Unix:
     *           [Socket_Access_Control_Localhost, Socket_Access_Control_Credentials]
     *       }
     *     </pre>
     *     
     *     <p>If stream tubes are not supported, this will be an empty
     *       dictionary.</p>
     */
    inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetAvailableTubeTypes" on the remote object.
     *
     * \return
     *     
     *     An array of the available tube types, as defined by the Tube_Type 
     *     enum.
     */
    inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ListTubes" on the remote object.
     *
     * \return
     *     
     *     Return an array of tuples, each representing a tube, with the 
     *     following members: the tube&apos;s ID the tube&apos;s initiator the 
     *     tube&apos;s type the tube&apos;s service the tube&apos;s parameters 
     *     the tube&apos;s state
     */
    inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "OfferDBusTube" on the remote object.
     * 
     * Offers a D-Bus tube providing the service specified.
     *
     * \param service
     *     
     *     A string representing the service name that will be used over the 
     *     tube. It should be a well-known D-Bus service name, of the form 
     *     com.example.ServiceName.
     *
     * \param parameters
     *     
     *     A dictionary of properties for the new tube; the allowable keys, 
     *     types and values are defined by the service. Connection managers 
     *     must support the value being any primitive (non-container) D-Bus 
     *     type, or a byte array &apos;ay&apos;.
     *
     * \return
     *     
     *     The ID of the new tube.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "OfferStreamTube" on the remote object.
     * 
     * Offer a stream tube exporting the local socket specified.
     *
     * \param service
     *     
     *     A string representing the service name that will be used over the
     *     tube.
     *     It should be a well-known TCP service name as defined by
     *     <a href="http://www.iana.org/assignments/port-numbers">
     *       http://www.iana.org/assignments/port-numbers</a> or
     *     <a href="http://www.dns-sd.org/ServiceTypes.html">
     *       http://www.dns-sd.org/ServiceTypes.html</a>, for instance
     *     &quot;rsync&quot; or &quot;daap&quot;.
     *
     * \param parameters
     *     
     *     <p>A dictionary of properties for the new tube; the allowable keys,
     *     types and values are defined by the service. Connection managers
     *     must support the value being any primitive (non-container)
     *     D-Bus type, or a byte array 'ay'.</p>
     *     <p>These should usually be the same key-value pairs specified for
     *     use in the DNS-SD TXT record for that service.</p>
     *
     * \param addressType
     *     
     *     The type of the listening address of the local service, as a member 
     *     of Socket_Address_Type.
     *
     * \param address
     *     
     *     The listening address of the local service, as indicated by the 
     *     address_type.
     *
     * \param accessControl
     *     
     *     The access control the local service applies to the local socket, 
     *     specified so the connection manager can behave appropriately when 
     *     it connects.
     *
     * \param accessControlParam
     *     
     *     A parameter for the access control type, to be interpreted as 
     *     specified in the documentation for the Socket_Access_Control enum.
     *
     * \return
     *     
     *     The ID of the new tube.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "AcceptDBusTube" on the remote object.
     * 
     * Accept a D-Bus tube that&apos;s in the &quot;local pending&quot; state. 
     * The connection manager will attempt to open the tube. The tube remains 
     * in the &quot;local pending&quot; state until the TubeStateChanged 
     * signal is emitted.
     *
     * \param ID
     *     
     *     The ID of the tube to accept.
     *
     * \return
     *     
     *     The string describing the address of the private bus. The client 
     *     should not attempt to connect to the address until the tube is open.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "AcceptStreamTube" on the remote object.
     * 
     * Accept a stream tube that&apos;s in the &quot;local pending&quot; 
     * state. The connection manager will attempt to open the tube. The tube 
     * remains in the &quot;local pending&quot; state until the 
     * TubeStateChanged signal is emitted.
     *
     * \param ID
     *     
     *     The ID of the tube to accept.
     *
     * \param addressType
     *     
     *     The type of address the connection manager should listen on.
     *
     * \param accessControl
     *     
     *     The type of access control the connection manager should apply to 
     *     the socket.
     *
     * \param accessControlParam
     *     
     *     A parameter for the access control type, to be interpreted as 
     *     specified in the documentation for the Socket_Access_Control enum.
     *
     * \return
     *     
     *     The address on which the connection manager will listen for 
     *     connections to this tube. The client should not attempt to connect 
     *     to the address until the tube is open.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "CloseTube" on the remote object.
     * 
     * Close a tube.
     *
     * \param ID
     *     
     *     The ID of the tube to close.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "GetDBusTubeAddress" on the remote object.
     * 
     * For a D-Bus tube, return a string describing the address of the private 
     * bus.
     *
     * \param ID
     *     
     *     The ID of the tube to get an address for.
     *
     * \return
     *     
     *     The bus address.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "GetDBusNames" on the remote object.
     * 
     * For a multi-user (i.e. Handle_Type_Room) D-Bus tube, obtain a mapping 
     * between contact handles and their unique bus names on this tube.
     *
     * \param ID
     *     
     *     The ID of the tube to get names for.
     *
     * \return
     *     
     *     An array of structures, each containing a contact handle and a 
     *     D-Bus bus name.
     */
    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);
    }

    /**
     * Begins a call to the D-Bus method "GetStreamTubeSocketAddress" on the remote object.
     * 
     * For a stream tube, obtain the address of the socket used to communicate 
     * over this tube.
     *
     * \param ID
     *     
     *     The ID of the stream tube to get the socket for.
     *
     * \return
     *     
     *     The type of the listening address of the socket, as a member of 
     *     Socket_Address_Type.
     *
     * \return
     *     
     *     The listening address of the socket, as indicated by the 
     *     address_type.
     */
    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:
    /**
     * Represents the signal "NewTube" on the remote object.
     * 
     * Emitted when a tube is created.
     *
     * \param ID
     *     
     *     The ID of the new tube.
     *
     * \param initiator
     *     
     *     The handle of the contact who initiated the tube.
     *
     * \param type
     *     
     *     The tube type, as defined by the Tube_Type enum.
     *
     * \param service
     *     
     *     A string representing the service that will be used over the tube.
     *
     * \param parameters
     *     
     *     The new tube&apos;s properties.
     *
     * \param state
     *     
     *     The new tube&apos;s state.
     */
    void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);

    /**
     * Represents the signal "TubeStateChanged" on the remote object.
     * 
     * Emitted when the state of a tube changes.
     *
     * \param ID
     *     
     *     The ID of the tube that changed state.
     *
     * \param state
     *     
     *     The new state of the tube; see the Tube_State enumeration.
     */
    void TubeStateChanged(uint ID, uint state);

    /**
     * Represents the signal "TubeClosed" on the remote object.
     * 
     * Emitted when a tube has been closed. The ID of a closed tube is no 
     * longer valid. The ID may later be reused for a new tube.
     *
     * \param ID
     *     
     *     The ID of the tube that was closed.
     */
    void TubeClosed(uint ID);

    /**
     * Represents the signal "DBusNamesChanged" on the remote object.
     * 
     * Emitted on a multi-user (i.e. Handle_Type_Room) D-Bus tube when a 
     * participant opens or closes the tube.
     *
     * \param ID
     *     
     *     The ID of the tube whose names have changed.
     *
     * \param added
     *     
     *     Array of handles and D-Bus names of new participants.
     *
     * \param removed
     *     
     *     Array of handles of former participants.
     */
    void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);

    /**
     * Represents the signal "StreamTubeNewConnection" on the remote object.
     * 
     * Emitted on a stream tube when a participant opens a new connection to 
     * its socket.
     *
     * \param ID
     *     
     *     The ID of the tube
     *
     * \param handle
     *     
     *     The handle of the participant who opened the new connection
     */
    void StreamTubeNewConnection(uint ID, uint handle);

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