/*
 * 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 ConnectionInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterface 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.
     */
    ConnectionInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterface 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.
     */
    ConnectionInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterface 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.
     */
    ConnectionInterface(Tp::DBusProxy *proxy);

    /**
     * Represents property "Interfaces" on the remote object.
     * 
     * <p>The set of optional interfaces supported by this connection.
     *   Before the connection status changes to CONNECTED,
     *   this property may change at any time, but it is guaranteed that
     *   interfaces will only be added, not removed. After the connection
     *   status changes to CONNECTED, this property cannot
     *   change further.</p>
     * 
     * <p>There is no explicit change notification; reasonable behaviour
     *   for a client would be to retrieve the interfaces list once
     *   initially, and once more when it becomes CONNECTED.</p>
     * 
     * <tp:rationale>
     *   <p>In some connection managers, certain capabilities of a connection
     *     are known to be implemented for all connections (e.g. support
     *     for SimplePresence), and some interfaces (like SimplePresence) can
     *     even be used before connecting. Other capabilities may
     *     or may not exist, depending on server functionality; by the time
     *     the connection goes CONNECTED, the connection manager is expected
     *     to have evaluated the server's functionality and enabled any extra
     *     interfaces for the remainder of the Connection's lifetime.</p>
     * </tp:rationale>
     */
    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>The set of optional interfaces supported by this connection.
     *   Before the connection status changes to CONNECTED,
     *   this property may change at any time, but it is guaranteed that
     *   interfaces will only be added, not removed. After the connection
     *   status changes to CONNECTED, this property cannot
     *   change further.</p>
     * 
     * <p>There is no explicit change notification; reasonable behaviour
     *   for a client would be to retrieve the interfaces list once
     *   initially, and once more when it becomes CONNECTED.</p>
     * 
     * <tp:rationale>
     *   <p>In some connection managers, certain capabilities of a connection
     *     are known to be implemented for all connections (e.g. support
     *     for SimplePresence), and some interfaces (like SimplePresence) can
     *     even be used before connecting. Other capabilities may
     *     or may not exist, depending on server functionality; by the time
     *     the connection goes CONNECTED, the connection manager is expected
     *     to have evaluated the server's functionality and enabled any extra
     *     interfaces for the remainder of the Connection's lifetime.</p>
     * </tp:rationale>
     *
     * \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 "SelfHandle" on the remote object.
     * 
     * The handle which represents the user on this connection, which will 
     * remain valid for the lifetime of this connection, or until a change in 
     * the user&apos;s identifier is signalled by the SelfHandleChanged 
     * signal. If the connection is not yet in the CONNECTED state, the value 
     * of this property MAY be zero.
     */
    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 which represents the user on this connection, which will 
     * remain valid for the lifetime of this connection, or until a change in 
     * the user&apos;s identifier is signalled by the SelfHandleChanged 
     * signal. If the connection is not yet in the CONNECTED state, the value 
     * of this property MAY be zero.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySelfHandle() const
    {
        return internalRequestProperty(QLatin1String("SelfHandle"));
    }

    /**
     * Represents property "Status" on the remote object.
     * 
     * <p>The current status of the connection. Change notification is via
     *   the <tp:member-ref>StatusChanged</tp:member-ref> signal.</p>
     * 
     * <p>If retrieval of property succeeds and yields the value Disconnected,
     *   this indicates that the connection has not yet been established.
     *   If connection has been attempted and failed, the Connection object
     *   SHOULD be removed from the bus entirely, meaning that retrieval of
     *   this property SHOULD fail.</p>
     */
    Q_PROPERTY(uint Status READ _deprecated_Status)

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

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

    /**
     * Asynchronous getter for the remote object property "Status" of type uint.
     *
     * 
     * <p>The current status of the connection. Change notification is via
     *   the <tp:member-ref>StatusChanged</tp:member-ref> signal.</p>
     * 
     * <p>If retrieval of property succeeds and yields the value Disconnected,
     *   this indicates that the connection has not yet been established.
     *   If connection has been attempted and failed, the Connection object
     *   SHOULD be removed from the bus entirely, meaning that retrieval of
     *   this property SHOULD fail.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyStatus() const
    {
        return internalRequestProperty(QLatin1String("Status"));
    }

    /**
     * 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 "Connect" on the remote object.
     * 
     * <p>Request that the connection be established. This will be done
     *   asynchronously and errors will be returned by emitting
     *   <tp:member-ref>StatusChanged</tp:member-ref> signals.</p>
     * 
     * <p>Calling this method on a Connection that is already connecting
     *   or connected is allowed, and has no effect.</p>
     */
    inline QDBusPendingReply<> Connect()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "Disconnect" on the remote object.
     * 
     * Request that the connection be closed. This closes the connection if 
     * it&apos;s not already in DISCONNECTED state, and destroys the 
     * connection object.
     */
    inline QDBusPendingReply<> Disconnect()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetInterfaces" on the remote object.
     * 
     * <p>Returns the set of optional interfaces supported by this
     *   connection. See <tp:member-ref>Interfaces</tp:member-ref> for more
     *   details.</p>
     *
     * \return
     *     
     *     The value of the Interfaces property
     */
    inline QDBusPendingReply<QStringList> GetInterfaces()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetProtocol" on the remote object.
     * 
     * Get the protocol this connection is using.
     *
     * \return
     *     
     *     A string identifier for the protocol
     */
    inline QDBusPendingReply<QString> GetProtocol()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetSelfHandle" on the remote object.
     * 
     * Returns the value of the SelfHandle property. Change notification is 
     * via the SelfHandleChanged signal.
     *
     * \return
     *     
     *     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 "GetStatus" on the remote object.
     * 
     * Get the current status as defined in the StatusChanged signal.
     *
     * \return
     *     
     *     The value of the Status property
     */
    inline QDBusPendingReply<uint> GetStatus()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "HoldHandles" on the remote object.
     * 
     * <p>Notify the connection manger that your client is holding a copy
     * of handles which may not be in use in any existing channel or
     * list, and were not obtained by using the
     * <tp:member-ref>RequestHandles</tp:member-ref> method. For
     * example, a handle observed in an emitted signal, or displayed
     * somewhere in the UI that is not associated with a channel. The
     * connection manager must not deallocate a handle where any clients
     * have used this method to indicate it is in use until the
     * <tp:member-ref>ReleaseHandles</tp:member-ref>
     * method is called, or the clients disappear from the bus.</p>
     * 
     * <p>Note that HoldHandles is idempotent - calling it multiple times
     *   is equivalent to calling it once. If a handle is &quot;referenced&quot; by
     *   several components which share a D-Bus unique name, the client
     *   should perform reference counting internally, and only call
     *   ReleaseHandles when none of the cooperating components need the
     *   handle any longer.</p>
     *
     * \param handleType
     *     
     *     The type of handle to be held
     *
     * \param handles
     *     
     *     A array of integer handles to hold
     */
    inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "InspectHandles" on the remote object.
     * 
     * Return a string representation for a number of handles of a given type.
     *
     * \param handleType
     *     
     *     The type of handle to be inspected
     *
     * \param handles
     *     
     *     An array of integer handles of this type
     *
     * \return
     *     
     *     An array of identifiers corresponding to the given handles, in the 
     *     same order.
     */
    inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ListChannels" on the remote object.
     * 
     * List all the channels which currently exist on this connection.
     *
     * \return
     *     
     *     An array of structs representing channels.
     */
    inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ReleaseHandles" on the remote object.
     * 
     * Explicitly notify the connection manager that your client is no longer 
     * holding any references to the given handles, and that they may be 
     * deallocated if they are not held by any other clients or referenced by 
     * any existing channels. See HoldHandles for notes.
     *
     * \param handleType
     *     
     *     An integer handle type (as defined in RequestHandle)
     *
     * \param handles
     *     
     *     An array of integer handles being held by the client
     */
    inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestChannel" on the remote object.
     * 
     * <p>Request a channel satisfying the specified type and communicating
     *   with the contact, room, list etc. indicated by the given
     *   handle_type and handle. The handle_type and handle may both be
     *   zero to request the creation of a new, empty channel, which may
     *   or may not be possible, depending on the protocol and channel
     *   type.</p>
     * 
     * <p>On success, the returned channel will always be of the requested
     *   type (i.e. implement the requested channel-type interface).</p>
     * 
     * <p>If a new, empty channel is requested, on success the returned
     *   channel will always be an &quot;anonymous&quot; channel for which the type
     *   and handle are both zero.</p>
     * 
     * <p>If a channel to a contact, room etc. is requested, on success, the
     *   returned channel may either be a new or existing channel to
     *   the requested entity (i.e. its
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandleType</tp:dbus-ref>
     *   and <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">TargetHandle</tp:dbus-ref>
     *   properties are the
     *   requested handle type and handle), or a newly created &quot;anonymous&quot;
     *   channel associated with the requested handle in some
     *   implementation-specific way.</p>
     * 
     * <p>For example, for a contact handle, the returned channel
     *   might be &quot;anonymous&quot;, but implement the groups interface and have
     *   the requested contact already present among the members.</p>
     * 
     * <p>If the request cannot be satisfied, an error is raised and no
     *   channel is created.</p>
     *
     * \param type
     *     
     *     A D-Bus interface name representing base channel type
     *
     * \param handleType
     *     
     *     An integer representing the handle type, or Handle_Type_None if no 
     *     handle is specified
     *
     * \param handle
     *     
     *     A nonzero integer handle representing a contact, room, list etc. 
     *     according to handle_type, or zero if the handle_type is 
     *     Handle_Type_None
     *
     * \param suppressHandler
     *     
     *     Clients SHOULD always set this to true. The historical meaning was 
     *     that clients that did not intend to take responsibility for 
     *     displaying the channel to the user could set this to FALSE, in 
     *     which case the channel dispatcher would launch an appropriate 
     *     channel handler. However, clients whose functionality relies on 
     *     having a working channel dispatcher should obtain that 
     *     functionality by calling methods on the channel dispatcher, so that 
     *     they will get an appropriate error if the channel dispatcher is 
     *     missing or not working. The channel dispatcher itself should set 
     *     this to true too, so that it will ignore the NewChannel signal that 
     *     results from the creation of the channel. It can then dispatch the 
     *     channel returned from this method to an appropriate handler. So, 
     *     there is no sensible use-case for setting this to false, and 
     *     setting it to false can result in unhandled channels (in the case 
     *     where clients assume that a channel dispatcher is present, but it 
     *     isn&apos;t).
     *
     * \return
     *     
     *     The D-Bus object path for the channel created or retrieved
     */
    inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestHandles" on the remote object.
     * 
     * Request several handles from the connection manager which represent a 
     * number of contacts, rooms or server-stored lists on the service. The 
     * connection manager should record that these handles are in use by the 
     * client who invokes this method, and must not deallocate the handles 
     * until the client disconnects from the bus or calls the ReleaseHandles 
     * method. Where the identifier refers to an entity that already has a 
     * handle in this connection manager, this handle should be returned 
     * instead. The handle number 0 must not be returned by the connection 
     * manager.
     *
     * \param handleType
     *     
     *     The type of handle required
     *
     * \param identifiers
     *     
     *     An array of identifiers of entities to request handles for
     *
     * \return
     *     
     *     An array of integer handle numbers in the same order as the given 
     *     identifiers.
     */
    inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "SelfHandleChanged" on the remote object.
     * 
     * Emitted whenever the SelfHandle property changes. If the connection is 
     * not yet in the CONNECTED state, this signal is not guaranteed to be 
     * emitted.
     *
     * \param selfHandle
     *     
     *     The new value of the SelfHandle property.
     */
    void SelfHandleChanged(uint selfHandle);

    /**
     * Represents the signal "NewChannel" on the remote object.
     * 
     * Emitted when a new Channel object is created, either through user 
     * request or incoming information from the service.
     *
     * \param objectPath
     *     
     *     A D-Bus object path for the channel object on this service
     *
     * \param channelType
     *     
     *     A D-Bus interface name representing the channel type
     *
     * \param handleType
     *     
     *     An integer representing the type of handle this channel 
     *     communicates with, or Handle_Type_None if no handle is specified
     *
     * \param handle
     *     
     *     A handle indicating the specific contact, room or list this channel 
     *     communicates with, or zero if no handle is specified
     *
     * \param suppressHandler
     *     
     *     <p>If true, the channel was requested by a client that intends to
     *       present it to the user itself (i.e. it passed suppress_handler=TRUE
     *       to the <tp:member-ref>RequestChannel</tp:member-ref> method), so no
     *       other handler should be
     *       launched. Clients MAY assume that channels where this is true
     *       were created by a user request.</p>
     *     
     *     <p>If false, either the channel was created due to incoming
     *       information from the service, or the channel was requested by
     *       a local client that does not intend to handle the channel itself
     *       (this usage is deprecated).</p>
     *     
     *     <p>Clients MUST NOT assume that only incoming channels will have
     *       this flag set to false.</p>
     */
    void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);

    /**
     * Represents the signal "ConnectionError" on the remote object.
     * 
     * <p>Emitted when an error occurs that renders this connection unusable.
     * </p>
     * 
     * <p>Whenever this signal is emitted, it MUST immediately be followed by
     *   a <tp:member-ref>StatusChanged</tp:member-ref> signal with status
     *   Connection_Status_Disconnected and an appropriate reason
     *   code.</p>
     * 
     * <p>Connection managers SHOULD emit this signal on disconnection, but
     *   need not do so. Clients MUST support connection managers that emit
     *   StatusChanged(Disconnected, ...) without first emitting
     *   ConnectionError.</p>
     * 
     * <tp:rationale>
     *   <p>This signal provides additional information about the reason
     *     for disconnection. The reason for connection is always
     *     straightforward - it was requested - so it does not need further
     *     explanation. However, on errors, it can be useful to provide
     *     additional information.</p>
     * 
     *   <p>The <tp:type>Connection_Status_Reason</tp:type> is not given
     *     here, since it will be signalled in
     *     <tp:member-ref>StatusChanged</tp:member-ref>. A reasonable client
     *     implementation would be to store the information given by this
     *     signal until StatusChanged is received, at which point the
     *     information given by this signal can be used to supplement the
     *     StatusChanged signal.</p>
     * </tp:rationale>
     *
     * \param error
     *     
     *     The name of a D-Bus error describing the error that occurred, which 
     *     may correspond to a Connection_Status_Reason, or may be a more 
     *     specific Telepathy error (such as 
     *     org.freedesktop.Telepathy.Errors.ConnectionRefused for 
     *     Connection_Status_Reason_Network_Error) or a protocol-specific or 
     *     connection-manager-specific error in a suitable namespace. For 
     *     instance, a SIP connection manager could signal &quot;402 Payment 
     *     Required&quot; as an error in a connection-manager-specific 
     *     namespace, or a link-local XMPP implementation that used Avahi 
     *     could provide the error given to it by the avahi-daemon.
     *
     * \param details
     *     
     *               <p>Additional information about the error, 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>
     *     	    <dt>user-requested (b), expected-hostname (s), certificate-hostname (s)</dt>
     *     	    <dd>The same details defined in <tp:type>TLS_Certificate_Rejection</tp:type>.</dd>
     *               </dl>
     */
    void ConnectionError(const QString& error, const QVariantMap& details);

    /**
     * Represents the signal "StatusChanged" on the remote object.
     * 
     * Emitted when the status of the connection changes. All states and 
     * reasons have numerical values, as defined in ConnectionStatus and 
     * ConnectionStatusReason.
     *
     * \param status
     *     
     *     An integer indicating the new status, as defined by ConnectionStatus
     *
     * \param reason
     *     
     *     An integer indicating the reason for the status change, as defined 
     *     by ConnectionStatusReason
     */
    void StatusChanged(uint status, uint reason);

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

/**
 * \class ConnectionInterfaceAliasingInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Aliasing."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceAliasingInterface 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.
     */
    ConnectionInterfaceAliasingInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceAliasingInterface 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.
     */
    ConnectionInterfaceAliasingInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceAliasingInterface 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.
     */
    ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceAliasingInterface 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 ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceAliasingInterface 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.
     */
    ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& 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 "GetAliasFlags" on the remote object.
     * 
     * Return a bitwise OR of flags detailing the behaviour of aliases on this 
     * connection.
     *
     * \return
     *     
     *     An integer with a bitwise OR of flags from ConnectionAliasFlags
     */
    inline QDBusPendingReply<uint> GetAliasFlags()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestAliases" on the remote object.
     * 
     * Request the value of several contacts&apos; aliases at once.
     *
     * \param contacts
     *     
     *     An array of handles representing contacts
     *
     * \return
     *     
     *     A list of aliases in the same order as the contact handles
     */
    inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetAliases" on the remote object.
     * 
     * Request the value of several contacts&apos; aliases at once. This 
     * SHOULD only return cached aliases, falling back on the contact 
     * identifier (i.e. the string corresponding to the handle) if none is 
     * present. Also if there was no cached alias, a request SHOULD be started 
     * of which the result is later signalled by AliasesChanged.
     *
     * \param contacts
     *     
     *     An array of handles representing contacts
     *
     * \return
     *     
     *     A dictionary mapping contact handles to aliases
     */
    inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "SetAliases" on the remote object.
     * 
     * Request that the alias of the given contact be changed. Success will be 
     * indicated by emitting an AliasesChanged signal. On connections where 
     * the CONNECTION_ALIAS_FLAG_USER_SET flag is not set, this method will 
     * only ever succeed if the contact is the user&apos;s own handle (as 
     * returned by Connection.GetSelfHandle).
     *
     * \param aliases
     *     
     *     A dictionary mapping integer handles of contacts to strings of the 
     *     new alias to set.
     */
    inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "AliasesChanged" on the remote object.
     * 
     * Signal emitted when a contact&apos;s alias (or that of the user) is 
     * changed.
     *
     * \param aliases
     *     
     *     An array containing structs of:
     *     <ul>
     *       <li>the handle representing the contact</li>
     *       <li>the new alias</li>
     *     </ul>
     */
    void AliasesChanged(const Tp::AliasPairList& aliases);

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

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

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

    /**
     * Creates a ConnectionInterfaceAnonymityInterface 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.
     */
    ConnectionInterfaceAnonymityInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceAnonymityInterface 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.
     */
    ConnectionInterfaceAnonymityInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceAnonymityInterface 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.
     */
    ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceAnonymityInterface 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 ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceAnonymityInterface 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.
     */
    ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "SupportedAnonymityModes" on the remote object.
     * 
     * The anonymity modes supported by the CM for this connection. Once 
     * Connection.Status has moved to Connected, this property MUST NOT change.
     */
    Q_PROPERTY(uint SupportedAnonymityModes READ _deprecated_SupportedAnonymityModes)

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

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

    /**
     * Asynchronous getter for the remote object property "SupportedAnonymityModes" of type uint.
     *
     * 
     * The anonymity modes supported by the CM for this connection. Once 
     * Connection.Status has moved to Connected, this property MUST NOT change.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
    {
        return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
    }

    /**
     * Represents property "AnonymityMandatory" on the remote object.
     * 
     * This specifies whether or not the anonymity settings MUST be respected 
     * by the CM and any intermediaries between the local and remote contacts. 
     * If this is set to true but anonymity settings cannot be followed, then 
     * the session MUST be denied with a 
     * org.freedesktop.Telepathy.Errors.WouldBreakAnonymity error. Any client 
     * that sets AnonymityModes SHOULD also set this property first (rather 
     * than accepting the CM&apos;s default value). This property SHOULD also 
     * be made available as a parameter of the same (fully-qualified) name to 
     * RequestConnection, with the DBus_Property flag in its 
     * Conn_Mgr_Param_Flags. For connections managed by the AccountManager, 
     * this property SHOULD be set via the Account Manager as follows: 
     * UpdateParameters({ 
     * &quot;org.freedesktop.Telepathy.Connection.Interface.Anonymity.AnonymityMandatory&quot;: 
     * new_value }, [])
     */
    Q_PROPERTY(bool AnonymityMandatory READ _deprecated_AnonymityMandatory WRITE _deprecated_setAnonymityMandatory)

    /**
     * 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.
     *
     * 
     * This specifies whether or not the anonymity settings MUST be respected 
     * by the CM and any intermediaries between the local and remote contacts. 
     * If this is set to true but anonymity settings cannot be followed, then 
     * the session MUST be denied with a 
     * org.freedesktop.Telepathy.Errors.WouldBreakAnonymity error. Any client 
     * that sets AnonymityModes SHOULD also set this property first (rather 
     * than accepting the CM&apos;s default value). This property SHOULD also 
     * be made available as a parameter of the same (fully-qualified) name to 
     * RequestConnection, with the DBus_Property flag in its 
     * Conn_Mgr_Param_Flags. For connections managed by the AccountManager, 
     * this property SHOULD be set via the Account Manager as follows: 
     * UpdateParameters({ 
     * &quot;org.freedesktop.Telepathy.Connection.Interface.Anonymity.AnonymityMandatory&quot;: 
     * new_value }, [])
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
    {
        return internalRequestProperty(QLatin1String("AnonymityMandatory"));
    }

    /**
     * Setter for the remote object property "AnonymityMandatory".
     *
     * Don't use this: it blocks the main loop.
     *
     * \param newValue The value to set the property to.
     */
    inline TELEPATHY_QT4_DEPRECATED void setAnonymityMandatory(bool newValue)
    {
        return _deprecated_setAnonymityMandatory(newValue);
    }

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

    /**
     * Asynchronous setter for the remote object property "AnonymityMandatory" of type bool.
     *
     * 
     * This specifies whether or not the anonymity settings MUST be respected 
     * by the CM and any intermediaries between the local and remote contacts. 
     * If this is set to true but anonymity settings cannot be followed, then 
     * the session MUST be denied with a 
     * org.freedesktop.Telepathy.Errors.WouldBreakAnonymity error. Any client 
     * that sets AnonymityModes SHOULD also set this property first (rather 
     * than accepting the CM&apos;s default value). This property SHOULD also 
     * be made available as a parameter of the same (fully-qualified) name to 
     * RequestConnection, with the DBus_Property flag in its 
     * Conn_Mgr_Param_Flags. For connections managed by the AccountManager, 
     * this property SHOULD be set via the Account Manager as follows: 
     * UpdateParameters({ 
     * &quot;org.freedesktop.Telepathy.Connection.Interface.Anonymity.AnonymityMandatory&quot;: 
     * new_value }, [])
     *
     * \return A pending operation which will emit finished when the property has been
     *          set.
     */
    inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
    {
        return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
    }

    /**
     * Represents property "AnonymityModes" on the remote object.
     * 
     * The currently enabled anonymity modes for the connection. Setting has 
     * the effect of requesting new modes for the connection, and may raise an 
     * error if the unsupported modes are set. Successfully changing the modes 
     * will result in emission of AnonymityModesChanged signal. This property 
     * SHOULD also be made available as a parameter of the same 
     * (fully-qualified) name to RequestConnection, with the DBus_Property 
     * flag in its Conn_Mgr_Param_Flags. For connections managed by the 
     * AccountManager, this property SHOULD be set via the Account Manager as 
     * follows: UpdateParameters({ 
     * &quot;org.freedesktop.Telepathy.Connection.Interface.Anonymity.AnonymityModes&quot;: 
     * new_value }, [])
     */
    Q_PROPERTY(uint AnonymityModes READ _deprecated_AnonymityModes WRITE _deprecated_setAnonymityModes)

    /**
     * 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 currently enabled anonymity modes for the connection. Setting has 
     * the effect of requesting new modes for the connection, and may raise an 
     * error if the unsupported modes are set. Successfully changing the modes 
     * will result in emission of AnonymityModesChanged signal. This property 
     * SHOULD also be made available as a parameter of the same 
     * (fully-qualified) name to RequestConnection, with the DBus_Property 
     * flag in its Conn_Mgr_Param_Flags. For connections managed by the 
     * AccountManager, this property SHOULD be set via the Account Manager as 
     * follows: UpdateParameters({ 
     * &quot;org.freedesktop.Telepathy.Connection.Interface.Anonymity.AnonymityModes&quot;: 
     * new_value }, [])
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAnonymityModes() const
    {
        return internalRequestProperty(QLatin1String("AnonymityModes"));
    }

    /**
     * Setter for the remote object property "AnonymityModes".
     *
     * Don't use this: it blocks the main loop.
     *
     * \param newValue The value to set the property to.
     */
    inline TELEPATHY_QT4_DEPRECATED void setAnonymityModes(uint newValue)
    {
        return _deprecated_setAnonymityModes(newValue);
    }

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

    /**
     * Asynchronous setter for the remote object property "AnonymityModes" of type uint.
     *
     * 
     * The currently enabled anonymity modes for the connection. Setting has 
     * the effect of requesting new modes for the connection, and may raise an 
     * error if the unsupported modes are set. Successfully changing the modes 
     * will result in emission of AnonymityModesChanged signal. This property 
     * SHOULD also be made available as a parameter of the same 
     * (fully-qualified) name to RequestConnection, with the DBus_Property 
     * flag in its Conn_Mgr_Param_Flags. For connections managed by the 
     * AccountManager, this property SHOULD be set via the Account Manager as 
     * follows: UpdateParameters({ 
     * &quot;org.freedesktop.Telepathy.Connection.Interface.Anonymity.AnonymityModes&quot;: 
     * new_value }, [])
     *
     * \return A pending operation which will emit finished when the property has been
     *          set.
     */
    inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
    {
        return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
    }

    /**
     * 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 "AnonymityModesChanged" on the remote object.
     * 
     * Emitted when the anonymity mode has changed.
     *
     * \param modes
     *     
     *     The new anonymity modes for this connection.
     */
    void AnonymityModesChanged(uint modes);

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

/**
 * \class ConnectionInterfaceAvatarsInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Avatars."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceAvatarsInterface 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.
     */
    ConnectionInterfaceAvatarsInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceAvatarsInterface 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.
     */
    ConnectionInterfaceAvatarsInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceAvatarsInterface 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.
     */
    ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceAvatarsInterface 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 ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceAvatarsInterface 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.
     */
    ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "SupportedAvatarMIMETypes" on the remote object.
     * 
     * An array of supported MIME types (e.g. &quot;image/jpeg&quot;). Clients 
     * MAY assume that the first type in this array is preferred. This 
     * property cannot change after the Connection goes to the Connected state.
     */
    Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ _deprecated_SupportedAvatarMIMETypes)

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

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

    /**
     * Asynchronous getter for the remote object property "SupportedAvatarMIMETypes" of type QStringList.
     *
     * 
     * An array of supported MIME types (e.g. &quot;image/jpeg&quot;). Clients 
     * MAY assume that the first type in this array is preferred. This 
     * property cannot change after the Connection goes to the Connected state.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
    {
        return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
    }

    /**
     * Represents property "MinimumAvatarHeight" on the remote object.
     * 
     * The minimum height in pixels of an avatar on this protocol, which MAY 
     * be 0. This property cannot change after the Connection goes to the 
     * Connected state.
     */
    Q_PROPERTY(uint MinimumAvatarHeight READ _deprecated_MinimumAvatarHeight)

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

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

    /**
     * Asynchronous getter for the remote object property "MinimumAvatarHeight" of type uint.
     *
     * 
     * The minimum height in pixels of an avatar on this protocol, which MAY 
     * be 0. This property cannot change after the Connection goes to the 
     * Connected state.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
    {
        return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
    }

    /**
     * Represents property "MinimumAvatarWidth" on the remote object.
     * 
     * The minimum width in pixels of an avatar on this protocol, which MAY be 
     * 0. This property cannot change after the Connection goes to the 
     * Connected state.
     */
    Q_PROPERTY(uint MinimumAvatarWidth READ _deprecated_MinimumAvatarWidth)

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

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

    /**
     * Asynchronous getter for the remote object property "MinimumAvatarWidth" of type uint.
     *
     * 
     * The minimum width in pixels of an avatar on this protocol, which MAY be 
     * 0. This property cannot change after the Connection goes to the 
     * Connected state.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
    {
        return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
    }

    /**
     * Represents property "RecommendedAvatarHeight" on the remote object.
     * 
     * The recommended height in pixels of an avatar on this protocol, or 0 if 
     * there is no preferred height. This property cannot change after the 
     * Connection goes to the Connected state. In XMPP a recommended width is 
     * given by the protocol specification; in proprietary protocols, using 
     * the same avatar size as the proprietary client is likely to lead to the 
     * best display to other users.
     */
    Q_PROPERTY(uint RecommendedAvatarHeight READ _deprecated_RecommendedAvatarHeight)

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

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

    /**
     * Asynchronous getter for the remote object property "RecommendedAvatarHeight" of type uint.
     *
     * 
     * The recommended height in pixels of an avatar on this protocol, or 0 if 
     * there is no preferred height. This property cannot change after the 
     * Connection goes to the Connected state. In XMPP a recommended width is 
     * given by the protocol specification; in proprietary protocols, using 
     * the same avatar size as the proprietary client is likely to lead to the 
     * best display to other users.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
    {
        return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
    }

    /**
     * Represents property "RecommendedAvatarWidth" on the remote object.
     * 
     * The recommended width in pixels of an avatar on this protocol, or 0 if 
     * there is no preferred width. This property cannot change after the 
     * Connection goes to the Connected state. The rationale is the same as 
     * for RecommendedAvatarHeight.
     */
    Q_PROPERTY(uint RecommendedAvatarWidth READ _deprecated_RecommendedAvatarWidth)

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

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

    /**
     * Asynchronous getter for the remote object property "RecommendedAvatarWidth" of type uint.
     *
     * 
     * The recommended width in pixels of an avatar on this protocol, or 0 if 
     * there is no preferred width. This property cannot change after the 
     * Connection goes to the Connected state. The rationale is the same as 
     * for RecommendedAvatarHeight.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
    {
        return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
    }

    /**
     * Represents property "MaximumAvatarHeight" on the remote object.
     * 
     * The maximum height in pixels of an avatar on this protocol, or 0 if 
     * there is no limit. This property cannot change after the Connection 
     * goes to the Connected state.
     */
    Q_PROPERTY(uint MaximumAvatarHeight READ _deprecated_MaximumAvatarHeight)

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

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

    /**
     * Asynchronous getter for the remote object property "MaximumAvatarHeight" of type uint.
     *
     * 
     * The maximum height in pixels of an avatar on this protocol, or 0 if 
     * there is no limit. This property cannot change after the Connection 
     * goes to the Connected state.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
    {
        return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
    }

    /**
     * Represents property "MaximumAvatarWidth" on the remote object.
     * 
     * The maximum width in pixels of an avatar on this protocol, or 0 if 
     * there is no limit. This property cannot change after the Connection 
     * goes to the Connected state.
     */
    Q_PROPERTY(uint MaximumAvatarWidth READ _deprecated_MaximumAvatarWidth)

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

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

    /**
     * Asynchronous getter for the remote object property "MaximumAvatarWidth" of type uint.
     *
     * 
     * The maximum width in pixels of an avatar on this protocol, or 0 if 
     * there is no limit. This property cannot change after the Connection 
     * goes to the Connected state.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
    {
        return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
    }

    /**
     * Represents property "MaximumAvatarBytes" on the remote object.
     * 
     * The maximum size in bytes of an avatar on this protocol, or 0 if there 
     * is no limit. This property cannot change after the Connection goes to 
     * the Connected state.
     */
    Q_PROPERTY(uint MaximumAvatarBytes READ _deprecated_MaximumAvatarBytes)

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

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

    /**
     * Asynchronous getter for the remote object property "MaximumAvatarBytes" of type uint.
     *
     * 
     * The maximum size in bytes of an avatar on this protocol, or 0 if there 
     * is no limit. This property cannot change after the Connection goes to 
     * the Connected state.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
    {
        return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
    }

    /**
     * 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 "GetAvatarRequirements" on the remote object.
     * 
     * Get the required format of avatars on this connection.
     *
     * \return
     *     
     *     An array of supported MIME types (eg image/jpeg)
     *
     * \return
     *     
     *     The minimum image width in pixels
     *
     * \return
     *     
     *     The minimum image height in pixels
     *
     * \return
     *     
     *     The maximum image width in pixels, or 0 if there is no limit
     *
     * \return
     *     
     *     The maximum image height in pixels, or 0 if there is no limit
     *
     * \return
     *     
     *     The maximum image size in bytes, or 0 if there is no limit
     */
    inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetAvatarTokens" on the remote object.
     * 
     * Get the unique tokens for all of the given contacts&apos; avatars. 
     * Using this method in new Telepathy clients is deprecated; use 
     * GetKnownAvatarTokens instead.
     *
     * \param contacts
     *     
     *     An array of handles representing contacts
     *
     * \return
     *     
     *     An array of avatar tokens or empty strings (if no avatar is set) in 
     *     the same order as the given array of contact handles
     */
    inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetKnownAvatarTokens" on the remote object.
     * 
     * Get the unique tokens for the given contacts&apos; avatars. These 
     * tokens can be persisted across connections, and should be used by the 
     * client to check whether the avatars have been updated. For handles 
     * other than the self handle, only tokens that are already known are 
     * returned; an empty token means the given contact has no avatar. 
     * However, a CM must always have the tokens for the self handle if one is 
     * set (even if it is set to no avatar). On protocols where the avatar 
     * does not persist between connections, a CM should omit the self handle 
     * from the returned map until an avatar is explicitly set or cleared.
     *
     * \param contacts
     *     
     *     An array of handles representing contacts
     *
     * \return
     *     
     *     A dictionary of handles mapped to avatar tokens, containing only 
     *     the known avatar tokens.
     */
    inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestAvatar" on the remote object.
     * 
     * Request the avatar for a given contact. Using this method in new 
     * Telepathy clients is deprecated; use RequestAvatars instead.
     *
     * \param contact
     *     
     *     An integer handle for the contact to request the avatar for
     *
     * \return
     *     
     *     An array of bytes containing the image data
     *
     * \return
     *     
     *     A string containing the image MIME type (eg image/jpeg), or empty 
     *     if unknown
     */
    inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestAvatars" on the remote object.
     * 
     * Request avatars for a number of contacts. The AvatarRetrieved signal is 
     * emitted for each avatar retrieved. If the handles are valid but 
     * retrieving an avatar fails (for any reason, including the contact not 
     * having an avatar) the AvatarRetrieved signal is not emitted for that 
     * contact.
     *
     * \param contacts
     *     
     *     The contacts to retrieve avatars for
     */
    inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "SetAvatar" on the remote object.
     * 
     * Set a new avatar image for this connection. The avatar image must 
     * respect the requirements obtained by GetAvatarRequirements.
     *
     * \param avatar
     *     
     *     An array of bytes representing the avatar image data
     *
     * \param MIMEType
     *     
     *     A string representing the image MIME type
     *
     * \return
     *     
     *     The string token of the new avatar
     */
    inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QString>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ClearAvatar" on the remote object.
     * 
     * Remove the avatar image for this connection.
     */
    inline QDBusPendingReply<> ClearAvatar()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "AvatarUpdated" on the remote object.
     * 
     * Emitted when the avatar for a contact has been updated, or first 
     * discovered on this connection. If the token differs from the token 
     * associated with the client&apos;s cached avatar for this contact, the 
     * new avatar should be requested with RequestAvatars.
     *
     * \param contact
     *     
     *     An integer handle for the contact whose avatar has changed
     *
     * \param newAvatarToken
     *     
     *     Unique token for their new avatar
     */
    void AvatarUpdated(uint contact, const QString& newAvatarToken);

    /**
     * Represents the signal "AvatarRetrieved" on the remote object.
     * 
     * Emitted when the avatar for a contact has been retrieved.
     *
     * \param contact
     *     
     *     The contact whose avatar has been retrieved
     *
     * \param token
     *     
     *     The token corresponding to the avatar
     *
     * \param avatar
     *     
     *     An array of bytes containing the image data
     *
     * \param type
     *     
     *     A string containing the image MIME type (eg image/jpeg), or empty 
     *     if unknown
     */
    void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);

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

/**
 * \class ConnectionInterfaceBalanceInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Balance."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceBalanceInterface 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.
     */
    ConnectionInterfaceBalanceInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceBalanceInterface 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.
     */
    ConnectionInterfaceBalanceInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceBalanceInterface 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.
     */
    ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceBalanceInterface 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 ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceBalanceInterface 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.
     */
    ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "AccountBalance" on the remote object.
     * 
     * <p>The user's balance on the account corresponding to this <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection</tp:dbus-ref>.
     *   A negative amount may be possible on some services, and indicates
     *   that the user owes money to the service provider.</p>
     * 
     * <p>On initial connection, this property may have an unknown
     *   value, represented by <var>Amount</var> = <tt>0</tt>,
     *   <var>Scale</var> = <tt>2**32 - 1</tt> (the largest possible 32-bit
     *   unsigned integer) and <var>Currency</var> = <tt>&quot;&quot;</tt>.</p>
     */
    Q_PROPERTY(Tp::CurrencyAmount AccountBalance READ _deprecated_AccountBalance)

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

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

    /**
     * Asynchronous getter for the remote object property "AccountBalance" of type Tp::CurrencyAmount.
     *
     * 
     * <p>The user's balance on the account corresponding to this <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection</tp:dbus-ref>.
     *   A negative amount may be possible on some services, and indicates
     *   that the user owes money to the service provider.</p>
     * 
     * <p>On initial connection, this property may have an unknown
     *   value, represented by <var>Amount</var> = <tt>0</tt>,
     *   <var>Scale</var> = <tt>2**32 - 1</tt> (the largest possible 32-bit
     *   unsigned integer) and <var>Currency</var> = <tt>&quot;&quot;</tt>.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyAccountBalance() const
    {
        return internalRequestProperty(QLatin1String("AccountBalance"));
    }

    /**
     * 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 "BalanceChanged" on the remote object.
     * 
     * <p>Emitted when the user's balance has changed.</p>
     *
     * \param balance
     *     
     *     <p>The new value of the <tp:member-ref>AccountBalance</tp:member-ref>
     *       property.</p>
     */
    void BalanceChanged(const Tp::CurrencyAmount& balance);

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

/**
 * \class ConnectionInterfaceCapabilitiesInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Capabilities."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceCapabilitiesInterface 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.
     */
    ConnectionInterfaceCapabilitiesInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceCapabilitiesInterface 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.
     */
    ConnectionInterfaceCapabilitiesInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceCapabilitiesInterface 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.
     */
    ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceCapabilitiesInterface 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 ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceCapabilitiesInterface 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.
     */
    ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& 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 "AdvertiseCapabilities" on the remote object.
     * 
     * <p>Used by user interfaces to indicate which channel types they are able
     * to handle on this connection. Because these may be provided by
     * different client processes, this method accepts channel types to add
     * and remove from the set already advertised on this connection. The type
     * of advertised capabilities (create versus invite) is protocol-dependent
     * and hence cannot be set by the this method. In the case of a client
     * adding an already advertised channel type but with new channel type
     * specific flags, the connection manager should simply add the new flags
     * to the set of advertised capabilities.</p>
     * 
     * <p>Upon a successful invocation of this method, the
     * <tp:member-ref>CapabilitiesChanged</tp:member-ref>
     * signal will be emitted for the user's own handle ( <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.GetSelfHandle</tp:dbus-ref>)
     * by the connection manager to indicate the changes
     * that have been made.  This signal should also be monitored to ensure
     * that the set is kept accurate - for example, a client may remove
     * capabilities or type specific capability flags when it exits
     * which are still provided by another client.</p>
     * 
     * <p>On connections managed by the <tp:dbus-ref namespace="org.freedesktop.Telepathy">ChannelDispatcher</tp:dbus-ref>,
     *   this method SHOULD NOT be used by clients other than the
     *   ChannelDispatcher itself.</p>
     *
     * \param add
     *     
     *     An array of structures containing:
     *     <ul>
     *       <li>a string channel type</li>
     *       <li>a bitwise OR of type specific capability flags</li>
     *     </ul>
     *
     * \param remove
     *     
     *     An array of D-Bus interface names of channel types to remove
     *
     * \return
     *     
     *     An array of structures describing the current capabilities 
     *     containing: a string channel type a bitwise OR of type specific 
     *     capability flags
     */
    inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetCapabilities" on the remote object.
     * 
     * Returns an array of capabilities for the given contact handles.
     *
     * \param handles
     *     
     *     <p>An array of contact handles for this connection.</p>
     *     
     *     <p>This may include zero, which originally meant a query for
     *       capabilities available on the connection itself. This usage
     *       is deprecated; clients SHOULD NOT do this, and connection managers
     *       SHOULD proceed as though zero had not been present in this
     *       list.</p>
     *
     * \return
     *     
     *     An array of structures containing:
     *     <ul>
     *       <li>an integer handle representing the contact</li>
     *       <li>a string channel type</li>
     *       <li>a bitwise OR of generic capability flags for the type</li>
     *       <li>a bitwise OR of type specific capability flags for the type</li>
     *     </ul>
     */
    inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "CapabilitiesChanged" on the remote object.
     * 
     * <p>Announce that there has been a change of capabilities on the
     *   given handle.</p>
     * 
     * <p>If the handle is zero, the capabilities refer to the connection
     *   itself, in some poorly defined way. This usage is deprecated and
     *   clients should ignore it.</p>
     *
     * \param caps
     *     
     *     An array of structures containing:
     *     <ul>
     *       <li>an integer handle representing the contact</li>
     *       <li>a string channel type</li>
     *       <li>a bitwise OR of the contact's old generic capability flags</li>
     *       <li>a bitwise OR of the contact's new generic capability flags</li>
     *       <li>a bitwise OR of the contact's old type specific capability flags</li>
     *       <li>a bitwise OR of the contact's new type specific capability flags</li>
     *     </ul>
     */
    void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);

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

/**
 * \class ConnectionInterfaceCellularInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Cellular."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceCellularInterface 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.
     */
    ConnectionInterfaceCellularInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceCellularInterface 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.
     */
    ConnectionInterfaceCellularInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceCellularInterface 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.
     */
    ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceCellularInterface 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 ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceCellularInterface 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.
     */
    ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "MessageValidityPeriod" on the remote object.
     * 
     * <p>Define how long should the service centre try message delivery before
     *   giving up, failing delivery and deleting the message. A value of 0
     *   means to use the service centre's default period.</p>
     * 
     * <p>The value specified is in seconds. Note that various protocols or
     *   implementations may round the value up (eg. to a minute or hour
     *   precision). The maximum validity period may vary depending on
     *   protocol or provider.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageValidityPeriod&quot;: <var>new_validity_period</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     */
    Q_PROPERTY(uint MessageValidityPeriod READ _deprecated_MessageValidityPeriod WRITE _deprecated_setMessageValidityPeriod)

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

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

    /**
     * Asynchronous getter for the remote object property "MessageValidityPeriod" of type uint.
     *
     * 
     * <p>Define how long should the service centre try message delivery before
     *   giving up, failing delivery and deleting the message. A value of 0
     *   means to use the service centre's default period.</p>
     * 
     * <p>The value specified is in seconds. Note that various protocols or
     *   implementations may round the value up (eg. to a minute or hour
     *   precision). The maximum validity period may vary depending on
     *   protocol or provider.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageValidityPeriod&quot;: <var>new_validity_period</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
    {
        return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
    }

    /**
     * Setter for the remote object property "MessageValidityPeriod".
     *
     * Don't use this: it blocks the main loop.
     *
     * \param newValue The value to set the property to.
     */
    inline TELEPATHY_QT4_DEPRECATED void setMessageValidityPeriod(uint newValue)
    {
        return _deprecated_setMessageValidityPeriod(newValue);
    }

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

    /**
     * Asynchronous setter for the remote object property "MessageValidityPeriod" of type uint.
     *
     * 
     * <p>Define how long should the service centre try message delivery before
     *   giving up, failing delivery and deleting the message. A value of 0
     *   means to use the service centre's default period.</p>
     * 
     * <p>The value specified is in seconds. Note that various protocols or
     *   implementations may round the value up (eg. to a minute or hour
     *   precision). The maximum validity period may vary depending on
     *   protocol or provider.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageValidityPeriod&quot;: <var>new_validity_period</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending operation which will emit finished when the property has been
     *          set.
     */
    inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
    {
        return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
    }

    /**
     * Represents property "OverrideMessageServiceCentre" on the remote object.
     * 
     * <p>If <code>True</code>, SMSes will be sent via the service centre
     *   specified by <tp:member-ref>MessageServiceCentre</tp:member-ref>. If
     *   <code>False</code>, the SIM's default SMSC will be used, ignoring the
     *   value of MessageServiceCentre.</p>
     * 
     * <tp:rationale>
     *   <p>It could be desirable for a configuration interface to remember
     *     the user's previous choice of custom SMSC, even if it's not in use.
     *     This boolean allows that choice to be saved as an account parameter
     *     by Mission Control, rather than the UI needing to save it elsewhere
     *     to be restored if the user wants to reactivate it.</p>
     * </tp:rationale>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.OverrideMessageServiceCentre&quot;: True
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     */
    Q_PROPERTY(bool OverrideMessageServiceCentre READ _deprecated_OverrideMessageServiceCentre WRITE _deprecated_setOverrideMessageServiceCentre)

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

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

    /**
     * Asynchronous getter for the remote object property "OverrideMessageServiceCentre" of type bool.
     *
     * 
     * <p>If <code>True</code>, SMSes will be sent via the service centre
     *   specified by <tp:member-ref>MessageServiceCentre</tp:member-ref>. If
     *   <code>False</code>, the SIM's default SMSC will be used, ignoring the
     *   value of MessageServiceCentre.</p>
     * 
     * <tp:rationale>
     *   <p>It could be desirable for a configuration interface to remember
     *     the user's previous choice of custom SMSC, even if it's not in use.
     *     This boolean allows that choice to be saved as an account parameter
     *     by Mission Control, rather than the UI needing to save it elsewhere
     *     to be restored if the user wants to reactivate it.</p>
     * </tp:rationale>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.OverrideMessageServiceCentre&quot;: True
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
    {
        return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
    }

    /**
     * Setter for the remote object property "OverrideMessageServiceCentre".
     *
     * Don't use this: it blocks the main loop.
     *
     * \param newValue The value to set the property to.
     */
    inline TELEPATHY_QT4_DEPRECATED void setOverrideMessageServiceCentre(bool newValue)
    {
        return _deprecated_setOverrideMessageServiceCentre(newValue);
    }

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

    /**
     * Asynchronous setter for the remote object property "OverrideMessageServiceCentre" of type bool.
     *
     * 
     * <p>If <code>True</code>, SMSes will be sent via the service centre
     *   specified by <tp:member-ref>MessageServiceCentre</tp:member-ref>. If
     *   <code>False</code>, the SIM's default SMSC will be used, ignoring the
     *   value of MessageServiceCentre.</p>
     * 
     * <tp:rationale>
     *   <p>It could be desirable for a configuration interface to remember
     *     the user's previous choice of custom SMSC, even if it's not in use.
     *     This boolean allows that choice to be saved as an account parameter
     *     by Mission Control, rather than the UI needing to save it elsewhere
     *     to be restored if the user wants to reactivate it.</p>
     * </tp:rationale>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.OverrideMessageServiceCentre&quot;: True
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending operation which will emit finished when the property has been
     *          set.
     */
    inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
    {
        return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
    }

    /**
     * Represents property "MessageServiceCentre" on the remote object.
     * 
     * <p>Address for the messaging service centre. Typically (as is the case
     *   for GSM's SMSC), it's the ISDN / telephony address (ie. a phone
     *   number). If
     *   <tp:member-ref>OverrideMessageServiceCentre</tp:member-ref> is
     *   <code>False</code>, this property's value should be ignored by the CM
     *   in favour of the SIM's default SMSC.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageServiceCentre&quot;: <var>new_smsc_address</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     */
    Q_PROPERTY(QString MessageServiceCentre READ _deprecated_MessageServiceCentre WRITE _deprecated_setMessageServiceCentre)

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

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

    /**
     * Asynchronous getter for the remote object property "MessageServiceCentre" of type QString.
     *
     * 
     * <p>Address for the messaging service centre. Typically (as is the case
     *   for GSM's SMSC), it's the ISDN / telephony address (ie. a phone
     *   number). If
     *   <tp:member-ref>OverrideMessageServiceCentre</tp:member-ref> is
     *   <code>False</code>, this property's value should be ignored by the CM
     *   in favour of the SIM's default SMSC.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageServiceCentre&quot;: <var>new_smsc_address</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
    {
        return internalRequestProperty(QLatin1String("MessageServiceCentre"));
    }

    /**
     * Setter for the remote object property "MessageServiceCentre".
     *
     * Don't use this: it blocks the main loop.
     *
     * \param newValue The value to set the property to.
     */
    inline TELEPATHY_QT4_DEPRECATED void setMessageServiceCentre(const QString& newValue)
    {
        return _deprecated_setMessageServiceCentre(newValue);
    }

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

    /**
     * Asynchronous setter for the remote object property "MessageServiceCentre" of type QString.
     *
     * 
     * <p>Address for the messaging service centre. Typically (as is the case
     *   for GSM's SMSC), it's the ISDN / telephony address (ie. a phone
     *   number). If
     *   <tp:member-ref>OverrideMessageServiceCentre</tp:member-ref> is
     *   <code>False</code>, this property's value should be ignored by the CM
     *   in favour of the SIM's default SMSC.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageServiceCentre&quot;: <var>new_smsc_address</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending operation which will emit finished when the property has been
     *          set.
     */
    inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
    {
        return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
    }

    /**
     * Represents property "IMSI" on the remote object.
     * 
     * <p>The International Mobile Subscriber Identifier, if it exists. This
     *   would originate from a SIM card.  If the IMSI is unknown, this will
     *   contain an empty string (&quot;&quot;).</p>
     */
    Q_PROPERTY(QString IMSI READ _deprecated_IMSI)

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

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

    /**
     * Asynchronous getter for the remote object property "IMSI" of type QString.
     *
     * 
     * <p>The International Mobile Subscriber Identifier, if it exists. This
     *   would originate from a SIM card.  If the IMSI is unknown, this will
     *   contain an empty string (&quot;&quot;).</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyIMSI() const
    {
        return internalRequestProperty(QLatin1String("IMSI"));
    }

    /**
     * Represents property "MessageReducedCharacterSet" on the remote object.
     * 
     * <p>Determines whether SMSes containing characters that do not fit into
     *   a 7‐bit GSM character set should be sent as UCS‐2, or lossily
     *   recoded. If <code>False</code> (which SHOULD be the default),
     *   messages will be sent with no loss of fidelity (at the potential
     *   financial cost of using twice as many SMSes); if <code>True</code>,
     *   the message will be recoded in an implementation‐specific way to fit
     *   into a country‐specific GSM reduced character set.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageReducedCharacterSet&quot;: <var>new_value</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     */
    Q_PROPERTY(bool MessageReducedCharacterSet READ _deprecated_MessageReducedCharacterSet WRITE _deprecated_setMessageReducedCharacterSet)

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

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

    /**
     * Asynchronous getter for the remote object property "MessageReducedCharacterSet" of type bool.
     *
     * 
     * <p>Determines whether SMSes containing characters that do not fit into
     *   a 7‐bit GSM character set should be sent as UCS‐2, or lossily
     *   recoded. If <code>False</code> (which SHOULD be the default),
     *   messages will be sent with no loss of fidelity (at the potential
     *   financial cost of using twice as many SMSes); if <code>True</code>,
     *   the message will be recoded in an implementation‐specific way to fit
     *   into a country‐specific GSM reduced character set.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageReducedCharacterSet&quot;: <var>new_value</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
    {
        return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
    }

    /**
     * Setter for the remote object property "MessageReducedCharacterSet".
     *
     * Don't use this: it blocks the main loop.
     *
     * \param newValue The value to set the property to.
     */
    inline TELEPATHY_QT4_DEPRECATED void setMessageReducedCharacterSet(bool newValue)
    {
        return _deprecated_setMessageReducedCharacterSet(newValue);
    }

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

    /**
     * Asynchronous setter for the remote object property "MessageReducedCharacterSet" of type bool.
     *
     * 
     * <p>Determines whether SMSes containing characters that do not fit into
     *   a 7‐bit GSM character set should be sent as UCS‐2, or lossily
     *   recoded. If <code>False</code> (which SHOULD be the default),
     *   messages will be sent with no loss of fidelity (at the potential
     *   financial cost of using twice as many SMSes); if <code>True</code>,
     *   the message will be recoded in an implementation‐specific way to fit
     *   into a country‐specific GSM reduced character set.</p>
     * 
     * <p>Connections with this interface SHOULD provide this property as a
     *   parameter of the same (fully-qualified) name to <tp:dbus-ref namespace="org.freedesktop.Telepathy">ConnectionManager.RequestConnection</tp:dbus-ref>, with the
     *   <code>DBus_Property</code> flag. For connections managed by the
     *   <tp:dbus-ref namespace="org.freedesktop.Telepathy">AccountManager</tp:dbus-ref>,
     *   this property SHOULD be set via the Account Manager as follows:</p>
     * 
     * <blockquote>
     *   <code><tp:dbus-ref namespace="org.freedesktop.Telepathy.Account">UpdateParameters</tp:dbus-ref>({
     *       &quot;org.freedesktop.Telepathy.Connection.Interface.Cellular.MessageReducedCharacterSet&quot;: <var>new_value</var>
     *       }, [])</code>
     * </blockquote>
     * 
     * <p>The AccountManager provides change-notification, as long as all
     *   other clients cooperate by using it instead of setting this property
     *   directly.</p>
     *
     * \return A pending operation which will emit finished when the property has been
     *          set.
     */
    inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
    {
        return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
    }

    /**
     * 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 "IMSIChanged" on the remote object.
     * 
     * Emitted when the IMSI for the connection changes. This sort of thing is 
     * rare, but could happen on cellular phones that allow hot-swapping of 
     * SIM cards. In the case of SIM swapping, this signal would be emitted 
     * twice; the first time while the SIM is being ejected (with an empty 
     * string), and the second time after a new SIM has been inserted 
     * (assuming that the IMSI can be determined from the new SIM).
     *
     * \param IMSI
     *     
     *     The new IMSI value. This may be an empty string in the case where 
     *     the IMSI is being reset or removed.
     */
    void IMSIChanged(const QString& IMSI);

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

/**
 * \class ConnectionInterfaceClientTypesInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.ClientTypes."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceClientTypesInterface 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.
     */
    ConnectionInterfaceClientTypesInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceClientTypesInterface 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.
     */
    ConnectionInterfaceClientTypesInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceClientTypesInterface 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.
     */
    ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceClientTypesInterface 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 ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceClientTypesInterface 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.
     */
    ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& 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 "GetClientTypes" on the remote object.
     * 
     * Return the client types of the given contacts, if they are already 
     * known. If any of the given contacts&apos; client types are not known, 
     * request their current client types, but return immediately without 
     * waiting for a reply; if a reply with a non-empty client type array is 
     * later received for those contacts, the ClientTypesUpdated signal will 
     * be emitted for them. This method is appropriate for &quot;lazy&quot; 
     * client type finding, for instance displaying the client types (if 
     * available) of everyone in your contact list.
     *
     * \param contacts
     *     
     *     The contacts whose client types should be returned or signalled.
     *
     * \return
     *     
     *     The contacts&apos; client types, if already known. Contacts whose 
     *     client types are not already known are omitted from the mapping; 
     *     contacts known to have no client type information appear in the 
     *     mapping with an empty list.
     */
    inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestClientTypes" on the remote object.
     * 
     * Return the current client types of the given contact. If necessary, 
     * make a request to the server for up-to-date information, and wait for a 
     * reply. This method is appropriate for use in a &quot;Contact 
     * Information...&quot; dialog; it can be used to show progress 
     * information (while waiting for the method to return), and can 
     * distinguish between various error conditions.
     *
     * \param contact
     *     
     *     The contact whose client types should be returned.
     *
     * \return
     *     
     *     The contact&apos;s client types. It MAY be empty, indicating that 
     *     no client type information was found.
     */
    inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QStringList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "ClientTypesUpdated" on the remote object.
     * 
     * Emitted when a contact&apos;s client types change or become known.
     *
     * \param contact
     *     
     *     The contact.
     *
     * \param clientTypes
     *     
     *     The contact&apos;s client types, or an empty list to indicate that 
     *     nothing is known about the contact&apos;s client types.
     */
    void ClientTypesUpdated(uint contact, const QStringList& clientTypes);

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

/**
 * \class ConnectionInterfaceContactCapabilitiesInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceContactCapabilitiesInterface 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.
     */
    ConnectionInterfaceContactCapabilitiesInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactCapabilitiesInterface 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.
     */
    ConnectionInterfaceContactCapabilitiesInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactCapabilitiesInterface 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.
     */
    ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceContactCapabilitiesInterface 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 ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceContactCapabilitiesInterface 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.
     */
    ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& 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 "UpdateCapabilities" on the remote object.
     * 
     * <p>Alter the connection's advertised capabilities to include
     *   the intersection of the given clients' capabilities with what the
     *   connection manager is able to implement.</p>
     * 
     * <p>On connections managed by the ChannelDispatcher, processes other
     *   than the ChannelDispatcher SHOULD NOT call this method, and the
     *   ChannelDispatcher SHOULD use this method to advertise the
     *   capabilities of all the registered <tp:dbus-ref namespace="org.freedesktop.Telepathy">Client.Handler</tp:dbus-ref>
     *   implementations.On connections not managed by the ChannelDispatcher,
     *   clients MAY use this method directly, to indicate the channels they
     *   will handle and the extra capabilities they have.</p>
     * 
     * <p>Upon a successful invocation of this method, the connection manager
     *   will only emit the
     *   <tp:member-ref>ContactCapabilitiesChanged</tp:member-ref> signal
     *   for the user's <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">SelfHandle</tp:dbus-ref>
     *   if, in the underlying protocol, the new capabilities are distinct
     *   from the previous state.</p>
     * 
     * <tp:rationale>
     *   <p>The connection manager will essentially intersect the provided
     *     capabilities and the channel classes it implements. Therefore,
     *     certain properties which are never fixed for a channel class
     *     (such as the target handle, or the Parameters property of a tube
     *     channel) will almost certainly not be advertised.</p>
     * </tp:rationale>
     * 
     * <p>This method MAY be called on a newly-created connection while it
     *   is still in the DISCONNECTED state, to request that when the
     *   connection connects, it will do so with the appropriate
     *   capabilities. Doing so MUST NOT fail.</p>
     *
     * \param handlerCapabilities
     *     
     *     The capabilities of one or more clients. For each client in the 
     *     given list, any capabilities previously advertised for the same 
     *     client name are discarded, then replaced by the capabilities 
     *     indicated. As a result, if a client becomes unavailable, this 
     *     method SHOULD be called with a Handler_Capabilities structure 
     *     containing its name, an empty list of channel classes, and an empty 
     *     list of capabilities. When this is done, the connection manager 
     *     SHOULD free all memory associated with that client name. This 
     *     method takes a list of clients so that when the channel dispatcher 
     *     first calls it (with a list of all the Handlers that are initially 
     *     available), the changes can be made atomically, with only one 
     *     transmission of updated capabilities to the network. Afterwards, 
     *     the channel dispatcher will call this method with a single-element 
     *     list every time a Handler becomes available or unavailable. The 
     *     connection manager MUST ignore any channel classes and client 
     *     capabilities for which there is no representation in the protocol 
     *     or no support in the connection manager.
     */
    inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetContactCapabilities" on the remote object.
     * 
     * <p>Returns an array of requestable channel classes for the given
     *   contact handles, representing the channel requests that are
     *   expected to succeed.</p>
     *
     * \param handles
     *     
     *     <p>An array of contact handles for this connection.</p>
     *     
     *     <p>The handle zero MUST NOT be included in the request.</p>
     *
     * \return
     *     
     *     <p>A map from contact handles to lists of requestable channel
     *       classes, representing the channel requests that are expected
     *       to succeed for that contact.</p>
     *     
     *     <p>Contacts listed among Handles whose capabilities are unknown
     *       SHOULD be omitted from this map; contacts known to have an empty
     *       set of capabilities SHOULD be included in the keys of this map,
     *       with an empty array as the corresponding value.</p>
     */
    inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "ContactCapabilitiesChanged" on the remote object.
     * 
     * <p>Announce that there has been a change of capabilities on the
     *   given handles. A single signal can be emitted for several
     * contacts.</p>
     * 
     * <tp:rationale>
     *   <p>The underlying protocol can get several contacts' capabilities at
     *     the same time.</p>
     * </tp:rationale>
     *
     * \param caps
     *     
     *     All the capabilities of the contacts
     */
    void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);

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

/**
 * \class ConnectionInterfaceContactGroupsInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.ContactGroups."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceContactGroupsInterface 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.
     */
    ConnectionInterfaceContactGroupsInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactGroupsInterface 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.
     */
    ConnectionInterfaceContactGroupsInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactGroupsInterface 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.
     */
    ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceContactGroupsInterface 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 ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceContactGroupsInterface 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.
     */
    ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "DisjointGroups" on the remote object.
     * 
     * <p>True if each contact can be in at most one group; false if each
     *   contact can be in many groups.</p>
     * 
     * <p>This property cannot change after the connection has moved to the
     *   Connected state. Until then, its value is undefined, and it may
     *   change at any time, without notification.</p>
     */
    Q_PROPERTY(bool DisjointGroups READ _deprecated_DisjointGroups)

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

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

    /**
     * Asynchronous getter for the remote object property "DisjointGroups" of type bool.
     *
     * 
     * <p>True if each contact can be in at most one group; false if each
     *   contact can be in many groups.</p>
     * 
     * <p>This property cannot change after the connection has moved to the
     *   Connected state. Until then, its value is undefined, and it may
     *   change at any time, without notification.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyDisjointGroups() const
    {
        return internalRequestProperty(QLatin1String("DisjointGroups"));
    }

    /**
     * Represents property "GroupStorage" on the remote object.
     * 
     * Indicates the extent to which contacts&apos; groups can be set and 
     * stored. This property cannot change after the connection has moved to 
     * the Connected state. Until then, its value is undefined, and it may 
     * change at any time, without notification.
     */
    Q_PROPERTY(uint GroupStorage READ _deprecated_GroupStorage)

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

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

    /**
     * Asynchronous getter for the remote object property "GroupStorage" of type uint.
     *
     * 
     * Indicates the extent to which contacts&apos; groups can be set and 
     * stored. This property cannot change after the connection has moved to 
     * the Connected state. Until then, its value is undefined, and it may 
     * change at any time, without notification.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyGroupStorage() const
    {
        return internalRequestProperty(QLatin1String("GroupStorage"));
    }

    /**
     * Represents property "Groups" on the remote object.
     * 
     * <p>The names of all groups that currently exist. This may be a
     *   larger set than the union of all contacts' <code>groups</code>
     *   contact attributes, if the connection allows groups to be
     *   empty.</p>
     * 
     * <p>Change notification is via
     *   <tp:member-ref>GroupsCreated</tp:member-ref> and
     *   <tp:member-ref>GroupsRemoved</tp:member-ref>; clients can also
     *   distinguish between a create/remove pair and a renamed group by
     *   receiving <tp:member-ref>GroupRenamed</tp:member-ref>.</p>
     * 
     * <p>This property's value is not meaningful until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> has become Success.</p>
     */
    Q_PROPERTY(QStringList Groups READ _deprecated_Groups)

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

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

    /**
     * Asynchronous getter for the remote object property "Groups" of type QStringList.
     *
     * 
     * <p>The names of all groups that currently exist. This may be a
     *   larger set than the union of all contacts' <code>groups</code>
     *   contact attributes, if the connection allows groups to be
     *   empty.</p>
     * 
     * <p>Change notification is via
     *   <tp:member-ref>GroupsCreated</tp:member-ref> and
     *   <tp:member-ref>GroupsRemoved</tp:member-ref>; clients can also
     *   distinguish between a create/remove pair and a renamed group by
     *   receiving <tp:member-ref>GroupRenamed</tp:member-ref>.</p>
     * 
     * <p>This property's value is not meaningful until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> has become Success.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyGroups() const
    {
        return internalRequestProperty(QLatin1String("Groups"));
    }

    /**
     * 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 "SetContactGroups" on the remote object.
     * 
     * <p>Add the given contact to the given groups (creating new groups
     *   if necessary), and remove them from all other groups.</p>
     * 
     * <tp:rationale>
     *   <p>This is the easiest and most correct way to implement user
     *     interfaces that display a single contact with a list of groups,
     *     resulting in a user expectation that when they apply the changes,
     *     the contact's set of groups will become exactly what was
     *     displayed.</p>
     * </tp:rationale>
     * 
     * <p>If the user is removed from a group of which they were the only
     *   member, the group MAY be removed automatically.</p>
     * 
     * <tp:rationale>
     *   <p>In protocols like XMPP where groups behave like tags, a group
     *     with no members has no protocol representation.</p>
     * </tp:rationale>
     * 
     * <p>Any <tp:member-ref>GroupsCreated</tp:member-ref>,
     *   <tp:member-ref>GroupsChanged</tp:member-ref> and
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> signals that result from
     *   this method call MUST be emitted before the method returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> changes to Success.
     *   If the ContactListState is Failure, this method SHOULD raise the
     *   same error as
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">GetContactListAttributes</tp:dbus-ref>.</p>
     *
     * \param contact
     *     
     *     The contact to alter.
     *
     * \param groups
     *     
     *     The set of groups which the contact should be in.
     */
    inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "SetGroupMembers" on the remote object.
     * 
     * <p>Add the given members to the given group (creating it if necessary),
     *   and remove all other members.</p>
     * 
     * <tp:rationale>
     *   <p>This is the easiest and most correct way to implement user
     *     interfaces that display a single group with a list of contacts,
     *     resulting in a user expectation that when they apply the changes,
     *     the groups's set of members will become exactly what was
     *     displayed.</p>
     * </tp:rationale>
     * 
     * <p>If <tp:member-ref>DisjointGroups</tp:member-ref> is true,
     *   this will also remove each member from their previous group.</p>
     * 
     * <p>If the user is removed from a group of which they were the only
     *   member, the group MAY be removed automatically.</p>
     * 
     * <p>Any <tp:member-ref>GroupsCreated</tp:member-ref>,
     *   <tp:member-ref>GroupsChanged</tp:member-ref> and
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> signals that result from
     *   this method call MUST be emitted before the method returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> changes to Success.
     *   If the ContactListState is Failure, this method SHOULD raise the
     *   same error as
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">GetContactListAttributes</tp:dbus-ref>.</p>
     *
     * \param group
     *     
     *     The group to alter.
     *
     * \param members
     *     
     *     The set of members for the group. If this set is empty, this method 
     *     MAY remove the group.
     */
    inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "AddToGroup" on the remote object.
     * 
     * <p>Add the given members to the given group, creating it if
     *   necessary.</p>
     * 
     * <p>If <tp:member-ref>DisjointGroups</tp:member-ref> is true,
     *   this will also remove each member from their previous group.</p>
     * 
     * <tp:rationale>
     *   <p>This is good for user interfaces in which you can edit groups
     *     via drag-and-drop.</p>
     * </tp:rationale>
     * 
     * <p>Any <tp:member-ref>GroupsCreated</tp:member-ref>,
     *   <tp:member-ref>GroupsChanged</tp:member-ref> and
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> signals that result from
     *   this method call MUST be emitted before the method returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> changes to Success.
     *   If the ContactListState is Failure, this method SHOULD raise the
     *   same error as
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">GetContactListAttributes</tp:dbus-ref>.</p>
     *
     * \param group
     *     
     *     The group to alter.
     *
     * \param members
     *     
     *     The set of members to include in the group.
     */
    inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RemoveFromGroup" on the remote object.
     * 
     * <p>Remove the given members from the given group.</p>
     * 
     * <tp:rationale>
     *   <p>This is good for user interfaces in which you can edit groups
     *     via drag-and-drop.</p>
     * </tp:rationale>
     * 
     * <p>Any <tp:member-ref>GroupsChanged</tp:member-ref> or
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> signals that result from
     *   this method call MUST be emitted before the method returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> changes to Success.
     *   If the ContactListState is Failure, this method SHOULD raise the
     *   same error as
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">GetContactListAttributes</tp:dbus-ref>.</p>
     *
     * \param group
     *     
     *     The group to alter. If it does not exist, then it has no members by 
     *     definition, so this method SHOULD return successfully.
     *
     * \param members
     *     
     *     The set of members to remove from the group. It is not an error to 
     *     remove members who are already not in the group. If there are no 
     *     members left in the group afterwards, the group MAY itself be 
     *     removed.
     */
    inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RemoveGroup" on the remote object.
     * 
     * <p>Remove all members from the given group, then remove the group
     *   itself. If the group already does not exist, this method SHOULD
     *   return successfully.</p>
     * 
     * <p>Any <tp:member-ref>GroupsChanged</tp:member-ref> or
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> signals that result from
     *   this method call MUST be emitted before the method returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> changes to Success.
     *   If the ContactListState is Failure, this method SHOULD raise the
     *   same error as
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">GetContactListAttributes</tp:dbus-ref>.</p>
     *
     * \param group
     *     
     *     The group to remove.
     */
    inline QDBusPendingReply<> RemoveGroup(const QString& group)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RenameGroup" on the remote object.
     * 
     * <p>Rename the given group.</p>
     * 
     * <p>On protocols where groups behave like tags, this is an API
     *   short-cut for adding all of the group's members to a group with
     *   the new name, then removing the old group.</p>
     * 
     * <tp:rationale>
     *   <p>Otherwise, clients can't perform this operation atomically, even
     *     if the connection could.</p>
     * </tp:rationale>
     * 
     * <p>Any <tp:member-ref>GroupRenamed</tp:member-ref> or
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> signals that result from
     *   this method call MUST be emitted before the method returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">ContactListState</tp:dbus-ref> changes to Success.
     *   If the ContactListState is Failure, this method SHOULD raise the
     *   same error as
     *   <tp:dbus-ref namespace="ofdT.Connection.Interface.ContactList">GetContactListAttributes</tp:dbus-ref>.</p>
     *
     * \param oldName
     *     
     *     The group to rename.
     *
     * \param newName
     *     
     *     The new name for the group.
     */
    inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "GroupsChanged" on the remote object.
     * 
     * Emitted when contacts&apos; groups change.
     *
     * \param contact
     *     
     *     The relevant contacts.
     *
     * \param added
     *     
     *     The names of groups to which the contacts were added.
     *
     * \param removed
     *     
     *     The names of groups from which the contacts were removed.
     */
    void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);

    /**
     * Represents the signal "GroupsCreated" on the remote object.
     * 
     * Emitted when new, empty groups are created. This will often be followed 
     * by GroupsChanged signals that add some members.
     *
     * \param names
     *     
     *     The names of the new groups.
     */
    void GroupsCreated(const QStringList& names);

    /**
     * Represents the signal "GroupRenamed" on the remote object.
     * 
     * <p>Emitted when a group is renamed, in protocols where this can
     *   be distinguished from group creation, removal and membership
     *   changes.</p>
     * 
     * <p>Immediately after this signal is emitted,
     *   <tp:member-ref>GroupsCreated</tp:member-ref> MUST signal the
     *   creation of a group with the new name, and
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> MUST signal the
     *   removal of a group with the old name.</p>
     * 
     * <tp:rationale>
     *   <p>Emitting these extra signals, in this order, means that clients
     *     that are interested in the set of groups that exist (but treat a
     *     rename and a create/remove pair identically) can ignore the
     *     GroupRenamed signal entirely.</p>
     * </tp:rationale>
     * 
     * <p>If the group was not empty, immediately after those signals are
     *   emitted, <tp:member-ref>GroupsChanged</tp:member-ref> MUST signal
     *   that the members of that group were removed from the old name
     *   and added to the new name.</p>
     * 
     * <p>On connection managers where groups behave like tags, renaming a
     *   group MAY be signalled as a set of
     *   <tp:member-ref>GroupsCreated</tp:member-ref>,
     *   <tp:member-ref>GroupsRemoved</tp:member-ref> and
     *   <tp:member-ref>GroupsChanged</tp:member-ref> signals, instead of
     *   emitting this signal.</p>
     * 
     * <tp:rationale>
     *   <p>On protocols like XMPP, another resource &quot;renaming a group&quot; is
     *     indistinguishable from changing contacts' groups individually.</p>
     * </tp:rationale>
     *
     * \param oldName
     *     
     *     The old name of the group.
     *
     * \param newName
     *     
     *     The new name of the group.
     */
    void GroupRenamed(const QString& oldName, const QString& newName);

    /**
     * Represents the signal "GroupsRemoved" on the remote object.
     * 
     * <p>Emitted when one or more groups are removed. If they had members at
     *   the time that they were removed, then immediately after this signal
     *   is emitted, <tp:member-ref>GroupsChanged</tp:member-ref> MUST signal
     *   that their members were removed.</p>
     * 
     * <tp:rationale>
     *   <p>Emitting the signals in this order allows for two modes of
     *     operation. A client interested only in a contact's set of groups
     *     can ignore <tp:member-ref>GroupsRemoved</tp:member-ref> and rely
     *     on the <tp:member-ref>GroupsChanged</tp:member-ref> signal that
     *     will follow; a more elaborate client wishing to distinguish between
     *     all of a group's members being removed, and the group itself
     *     being removed, can additionally watch for
     *     <tp:member-ref>GroupsRemoved</tp:member-ref> and use it to
     *     disambiguate.</p>
     * </tp:rationale>
     *
     * \param names
     *     
     *     The names of the groups.
     */
    void GroupsRemoved(const QStringList& names);

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

/**
 * \class ConnectionInterfaceContactInfoInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.ContactInfo."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceContactInfoInterface 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.
     */
    ConnectionInterfaceContactInfoInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactInfoInterface 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.
     */
    ConnectionInterfaceContactInfoInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactInfoInterface 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.
     */
    ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceContactInfoInterface 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 ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceContactInfoInterface 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.
     */
    ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "ContactInfoFlags" on the remote object.
     * 
     * <p>An integer representing the bitwise-OR of flags on this
     *   connection.</p>
     * 
     * <p>This property MAY change, without change notification, at any time
     *   before the connection moves to status Connection_Status_Connected.
     *   It MUST NOT change after that point.</p>
     * 
     * <tp:rationale>
     *   <p>Some XMPP servers, like Facebook Chat, do not allow the vCard to
     *     be changed (and so would not have the Can_Set flag). Whether the
     *     user's server is one of these cannot necessarily be detected until
     *     quite late in the connection process.</p>
     * </tp:rationale>
     */
    Q_PROPERTY(uint ContactInfoFlags READ _deprecated_ContactInfoFlags)

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

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

    /**
     * Asynchronous getter for the remote object property "ContactInfoFlags" of type uint.
     *
     * 
     * <p>An integer representing the bitwise-OR of flags on this
     *   connection.</p>
     * 
     * <p>This property MAY change, without change notification, at any time
     *   before the connection moves to status Connection_Status_Connected.
     *   It MUST NOT change after that point.</p>
     * 
     * <tp:rationale>
     *   <p>Some XMPP servers, like Facebook Chat, do not allow the vCard to
     *     be changed (and so would not have the Can_Set flag). Whether the
     *     user's server is one of these cannot necessarily be detected until
     *     quite late in the connection process.</p>
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
    {
        return internalRequestProperty(QLatin1String("ContactInfoFlags"));
    }

    /**
     * Represents property "SupportedFields" on the remote object.
     * 
     *         <p>A list of field specifications describing the kinds of fields which may
     *           be passed to <tp:member-ref>SetContactInfo</tp:member-ref>.  The empty
     *           list indicates that arbitrary vCard fields are permitted.  This
     *           property SHOULD be the empty list, and be ignored by clients, if
     *           <tp:member-ref>ContactInfoFlags</tp:member-ref> does not contain the
     *           Can_Set flag.</p>
     * 
     *         <p>For example, a protocol in which arbitrary vCards were stored
     *           as-is would set this property to the
     *           empty list. A protocol whose notion of contact information is one
     *           each of personal phone number, mobile phone number, location, email
     *           address and date of birth, with no attributes allowed on each piece
     *           of information, would set this property to (in Python-like
     *           syntax):</p>
     * 
     *         <pre>
     * [
     *   ('tel', ['type=home'], Parameters_Exact, 1),
     *   ('tel', ['type=cell'], Parameters_Exact, 1),
     *   ('adr', [], Parameters_Exact, 1),
     *   ('bday', [], Parameters_Exact, 1),
     *   ('email', ['type=internet'], Parameters_Exact, 1),
     * ]</pre>
     * 
     *         <p>A protocol which allows users to specify up to four phone numbers,
     *           which may be labelled as personal and/or mobile, would set this
     *           property to
     *           <code>[ ('tel', ['type=home', 'type=cell'], 0, 4), ]</code>.</p>
     * 
     *         <tp:rationale>
     *           <p>Studying existing IM protocols shows that in practice protocols
     *             allow either a very restricted set of fields (such as MSN, which
     *             seems to correspond roughly to the largest example above), or
     *             something mapping 1:1 to a large subset of vCard (such as XMPP's
     *             XEP-0054).</p>
     *         </tp:rationale>
     * 
     *         <p>This property MAY change, without change notification, at any time
     *           before the connection moves to status Connection_Status_Connected.
     *           It MUST NOT change after that point.</p>
     * 
     *         <tp:rationale>
     *           <p>Some XMPP servers, like Google Talk, only allow a small subset of
     *             the &quot;vcard-temp&quot; protocol. Whether the user's server is one of
     *             these cannot be detected until quite late in the connection
     *             process.</p>
     *         </tp:rationale>
     */
    Q_PROPERTY(Tp::FieldSpecs SupportedFields READ _deprecated_SupportedFields)

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

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

    /**
     * Asynchronous getter for the remote object property "SupportedFields" of type Tp::FieldSpecs.
     *
     * 
     *         <p>A list of field specifications describing the kinds of fields which may
     *           be passed to <tp:member-ref>SetContactInfo</tp:member-ref>.  The empty
     *           list indicates that arbitrary vCard fields are permitted.  This
     *           property SHOULD be the empty list, and be ignored by clients, if
     *           <tp:member-ref>ContactInfoFlags</tp:member-ref> does not contain the
     *           Can_Set flag.</p>
     * 
     *         <p>For example, a protocol in which arbitrary vCards were stored
     *           as-is would set this property to the
     *           empty list. A protocol whose notion of contact information is one
     *           each of personal phone number, mobile phone number, location, email
     *           address and date of birth, with no attributes allowed on each piece
     *           of information, would set this property to (in Python-like
     *           syntax):</p>
     * 
     *         <pre>
     * [
     *   ('tel', ['type=home'], Parameters_Exact, 1),
     *   ('tel', ['type=cell'], Parameters_Exact, 1),
     *   ('adr', [], Parameters_Exact, 1),
     *   ('bday', [], Parameters_Exact, 1),
     *   ('email', ['type=internet'], Parameters_Exact, 1),
     * ]</pre>
     * 
     *         <p>A protocol which allows users to specify up to four phone numbers,
     *           which may be labelled as personal and/or mobile, would set this
     *           property to
     *           <code>[ ('tel', ['type=home', 'type=cell'], 0, 4), ]</code>.</p>
     * 
     *         <tp:rationale>
     *           <p>Studying existing IM protocols shows that in practice protocols
     *             allow either a very restricted set of fields (such as MSN, which
     *             seems to correspond roughly to the largest example above), or
     *             something mapping 1:1 to a large subset of vCard (such as XMPP's
     *             XEP-0054).</p>
     *         </tp:rationale>
     * 
     *         <p>This property MAY change, without change notification, at any time
     *           before the connection moves to status Connection_Status_Connected.
     *           It MUST NOT change after that point.</p>
     * 
     *         <tp:rationale>
     *           <p>Some XMPP servers, like Google Talk, only allow a small subset of
     *             the &quot;vcard-temp&quot; protocol. Whether the user's server is one of
     *             these cannot be detected until quite late in the connection
     *             process.</p>
     *         </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySupportedFields() const
    {
        return internalRequestProperty(QLatin1String("SupportedFields"));
    }

    /**
     * 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 "GetContactInfo" on the remote object.
     * 
     * Request information on several contacts at once. This SHOULD only 
     * return cached information, omitting handles for which no information is 
     * cached from the returned map.
     *
     * \param contacts
     *     
     *     An array of handles representing contacts.
     *
     * \return
     *     
     *     A dictionary mapping contact handles to information, whose keys are 
     *     the subset of the requested list of handles for which information 
     *     was cached.
     */
    inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RefreshContactInfo" on the remote object.
     * 
     * Retrieve information for the given contact, requesting it from the 
     * network if an up-to-date version is not cached locally. This method 
     * SHOULD return immediately, emitting ContactInfoChanged when the 
     * contacts&apos; updated contact information is returned. This method 
     * allows a client with cached contact information to update its cache 
     * after a number of days.
     *
     * \param contacts
     *     
     *     Integer handles for contacts.
     */
    inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestContactInfo" on the remote object.
     * 
     * Retrieve information for a contact, requesting it from the network if 
     * it is not cached locally. This method is appropriate for an explicit 
     * user request to show a contact&apos;s information; it allows a UI to 
     * wait for the contact info to be returned.
     *
     * \param contact
     *     
     *     An integer handle for a contact.
     *
     * \return
     *     
     *     Information about that contact.
     */
    inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "SetContactInfo" on the remote object.
     * 
     * Set new contact information for this connection, replacing existing 
     * information. This method is only suppported if ContactInfoFlags 
     * contains Can_Set, and may only be passed fields conforming to 
     * SupportedFields.
     *
     * \param contactInfo
     *     
     *     The new information to be set.
     */
    inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "ContactInfoChanged" on the remote object.
     * 
     * Emitted when a contact&apos;s information has changed or been received 
     * for the first time on this connection.
     *
     * \param contact
     *     
     *     An integer handle for the contact whose info has changed.
     *
     * \param contactInfo
     *     
     *     An array of fields representing information about this contact.
     */
    void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);

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

/**
 * \class ConnectionInterfaceContactListInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.ContactList."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceContactListInterface 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.
     */
    ConnectionInterfaceContactListInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactListInterface 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.
     */
    ConnectionInterfaceContactListInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactListInterface 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.
     */
    ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceContactListInterface 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 ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceContactListInterface 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.
     */
    ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "ContactListState" on the remote object.
     * 
     * The progress made in retrieving the contact list. Change notification 
     * is via ContactListStateChanged.
     */
    Q_PROPERTY(uint ContactListState READ _deprecated_ContactListState)

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

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

    /**
     * Asynchronous getter for the remote object property "ContactListState" of type uint.
     *
     * 
     * The progress made in retrieving the contact list. Change notification 
     * is via ContactListStateChanged.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyContactListState() const
    {
        return internalRequestProperty(QLatin1String("ContactListState"));
    }

    /**
     * Represents property "ContactListPersists" on the remote object.
     * 
     * <p>If true, presence subscriptions (in both directions) on this
     *   connection are stored by the server or other infrastructure.</p>
     * 
     * <tp:rationale>
     *   <p>XMPP, MSN, ICQ, etc. all behave like this.</p>
     * </tp:rationale>
     * 
     * <p>If false, presence subscriptions on this connection are not
     *   stored.</p>
     * 
     * <tp:rationale>
     *   <p>In SIMPLE (SIP), <em>clients</em> are expected to keep a record
     *     of subscriptions, as described below. In link-local XMPP,
     *     subscriptions are implicit (everyone on the local network receives
     *     presence from everyone else) so nothing is ever stored.</p>
     * </tp:rationale>
     * 
     * <p>If <tp:member-ref>CanChangeContactList</tp:member-ref>
     *   is true, Telepathy clients (e.g. user interfaces or address books)
     *   MAY keep a record of permission to publish and requests to subscribe
     *   locally, and attempt to restore it for each Connection. If
     *   ContactListPersists is false, clients MAY do this for all contacts;
     *   if ContactListPersists is true, clients SHOULD NOT change the state
     *   of contacts that were not changed locally.</p>
     * 
     * <tp:rationale>
     *   <p>In SIMPLE (SIP), ContactListPersists is false, but
     *     CanChangeContactList is true. Presence will not be received
     *     unless clients renew any subscriptions they have for each
     *     connection, in the way described. There is no server-side storage,
     *     so clients have no alternative but to maintain independent contact
     *     lists.</p>
     * 
     *   <p>In protocols like XMPP and MSN, it may be useful for clients to
     *     queue up subscription requests or removals made while offline and
     *     process them next time the connection is online. However, clients
     *     should only replay the changes, rather than resetting the contact
     *     list to match a stored copy, to avoid overwriting changes that
     *     were made on the server.</p>
     * </tp:rationale>
     * 
     * <p>Clients that replay requests like this SHOULD do so by calling
     *   AuthorizePublication to pre-approve publication of presence to the
     *   appropriate contacts, followed by RequestSubscription to request the
     *   appropriate contacts' presences.</p>
     * 
     * <p>This property cannot change after the connection has moved to the
     *   Connected state. Until then, its value is undefined, and it may
     *   change at any time, without notification.</p>
     */
    Q_PROPERTY(bool ContactListPersists READ _deprecated_ContactListPersists)

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

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

    /**
     * Asynchronous getter for the remote object property "ContactListPersists" of type bool.
     *
     * 
     * <p>If true, presence subscriptions (in both directions) on this
     *   connection are stored by the server or other infrastructure.</p>
     * 
     * <tp:rationale>
     *   <p>XMPP, MSN, ICQ, etc. all behave like this.</p>
     * </tp:rationale>
     * 
     * <p>If false, presence subscriptions on this connection are not
     *   stored.</p>
     * 
     * <tp:rationale>
     *   <p>In SIMPLE (SIP), <em>clients</em> are expected to keep a record
     *     of subscriptions, as described below. In link-local XMPP,
     *     subscriptions are implicit (everyone on the local network receives
     *     presence from everyone else) so nothing is ever stored.</p>
     * </tp:rationale>
     * 
     * <p>If <tp:member-ref>CanChangeContactList</tp:member-ref>
     *   is true, Telepathy clients (e.g. user interfaces or address books)
     *   MAY keep a record of permission to publish and requests to subscribe
     *   locally, and attempt to restore it for each Connection. If
     *   ContactListPersists is false, clients MAY do this for all contacts;
     *   if ContactListPersists is true, clients SHOULD NOT change the state
     *   of contacts that were not changed locally.</p>
     * 
     * <tp:rationale>
     *   <p>In SIMPLE (SIP), ContactListPersists is false, but
     *     CanChangeContactList is true. Presence will not be received
     *     unless clients renew any subscriptions they have for each
     *     connection, in the way described. There is no server-side storage,
     *     so clients have no alternative but to maintain independent contact
     *     lists.</p>
     * 
     *   <p>In protocols like XMPP and MSN, it may be useful for clients to
     *     queue up subscription requests or removals made while offline and
     *     process them next time the connection is online. However, clients
     *     should only replay the changes, rather than resetting the contact
     *     list to match a stored copy, to avoid overwriting changes that
     *     were made on the server.</p>
     * </tp:rationale>
     * 
     * <p>Clients that replay requests like this SHOULD do so by calling
     *   AuthorizePublication to pre-approve publication of presence to the
     *   appropriate contacts, followed by RequestSubscription to request the
     *   appropriate contacts' presences.</p>
     * 
     * <p>This property cannot change after the connection has moved to the
     *   Connected state. Until then, its value is undefined, and it may
     *   change at any time, without notification.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyContactListPersists() const
    {
        return internalRequestProperty(QLatin1String("ContactListPersists"));
    }

    /**
     * Represents property "CanChangeContactList" on the remote object.
     * 
     * <p>If true, presence subscription and publication can be changed
     *   using the
     *   <tp:member-ref>RequestSubscription</tp:member-ref>,
     *   <tp:member-ref>AuthorizePublication</tp:member-ref> and
     *   <tp:member-ref>RemoveContacts</tp:member-ref> methods.</p>
     * 
     * <p>If false, all of those methods will always fail; they SHOULD raise
     *   the error org.freedesktop.Telepathy.Error.NotImplemented.</p>
     * 
     * <tp:rationale>
     *   <p>In XEP-0174 &quot;Serverless Messaging&quot; (link-local XMPP), presence is
     *     implicitly published to everyone in the local subnet, so the user
     *     cannot control their presence publication.</p>
     * </tp:rationale>
     * 
     * <p>This property cannot change after the connection has moved to the
     *   Connected state. Until then, its value is undefined, and it may
     *   change at any time, without notification.</p>
     */
    Q_PROPERTY(bool CanChangeContactList READ _deprecated_CanChangeContactList)

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

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

    /**
     * Asynchronous getter for the remote object property "CanChangeContactList" of type bool.
     *
     * 
     * <p>If true, presence subscription and publication can be changed
     *   using the
     *   <tp:member-ref>RequestSubscription</tp:member-ref>,
     *   <tp:member-ref>AuthorizePublication</tp:member-ref> and
     *   <tp:member-ref>RemoveContacts</tp:member-ref> methods.</p>
     * 
     * <p>If false, all of those methods will always fail; they SHOULD raise
     *   the error org.freedesktop.Telepathy.Error.NotImplemented.</p>
     * 
     * <tp:rationale>
     *   <p>In XEP-0174 &quot;Serverless Messaging&quot; (link-local XMPP), presence is
     *     implicitly published to everyone in the local subnet, so the user
     *     cannot control their presence publication.</p>
     * </tp:rationale>
     * 
     * <p>This property cannot change after the connection has moved to the
     *   Connected state. Until then, its value is undefined, and it may
     *   change at any time, without notification.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
    {
        return internalRequestProperty(QLatin1String("CanChangeContactList"));
    }

    /**
     * Represents property "RequestUsesMessage" on the remote object.
     * 
     * <p>If true, the Message parameter to
     *   <tp:member-ref>RequestSubscription</tp:member-ref> is likely to be
     *   significant, and user interfaces SHOULD prompt the user for a
     *   message to send with the request; a message such as &quot;I would like
     *   to add you to my contact list&quot;, translated into the local user's
     *   language, might make a suitable default.</p>
     * 
     * <tp:rationale>
     *   <p>This matches user expectations in XMPP and ICQ, for instance.</p>
     * </tp:rationale>
     * 
     * <p>If false, the parameter is ignored; user interfaces SHOULD avoid
     *   prompting the user, and SHOULD pass an empty string to
     *   RequestSubscription.</p>
     * 
     * <tp:rationale>
     *   <p><em>FIXME: is there any such protocol?</em></p>
     * </tp:rationale>
     */
    Q_PROPERTY(bool RequestUsesMessage READ _deprecated_RequestUsesMessage)

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

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

    /**
     * Asynchronous getter for the remote object property "RequestUsesMessage" of type bool.
     *
     * 
     * <p>If true, the Message parameter to
     *   <tp:member-ref>RequestSubscription</tp:member-ref> is likely to be
     *   significant, and user interfaces SHOULD prompt the user for a
     *   message to send with the request; a message such as &quot;I would like
     *   to add you to my contact list&quot;, translated into the local user's
     *   language, might make a suitable default.</p>
     * 
     * <tp:rationale>
     *   <p>This matches user expectations in XMPP and ICQ, for instance.</p>
     * </tp:rationale>
     * 
     * <p>If false, the parameter is ignored; user interfaces SHOULD avoid
     *   prompting the user, and SHOULD pass an empty string to
     *   RequestSubscription.</p>
     * 
     * <tp:rationale>
     *   <p><em>FIXME: is there any such protocol?</em></p>
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
    {
        return internalRequestProperty(QLatin1String("RequestUsesMessage"));
    }

    /**
     * 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 "GetContactListAttributes" on the remote object.
     * 
     * <p>Return some contact attributes for a list of contacts
     *   associated with the user. This list MUST include at least:</p>
     * 
     * <ul>
     *   <li>all contacts whose <tp:token-ref>subscribe</tp:token-ref>
     *     attribute is not No</li>
     *   <li>all contacts whose <tp:token-ref>publish</tp:token-ref>
     *     attribute is not No</li>
     * </ul>
     * 
     * <p>but MAY contain other contacts.</p>
     * 
     * <tp:rationale>
     *   <p>For instance, on XMPP, all contacts on the roster would appear
     *     here even if they have subscription=&quot;none&quot;, unless there's
     *     reason to believe the user does not want to see them (such as
     *     having been blocked).</p>
     * </tp:rationale>
     * 
     * <p>This list does not need to contain every visible contact: for
     *   instance, contacts seen in XMPP or IRC chatrooms SHOULD NOT appear
     *   here. Blocked contacts SHOULD NOT appear here, unless they still
     *   have a non-<tt>No</tt> <tp:token-ref>subscribe</tp:token-ref> or
     *   <tp:token-ref>publish</tp:token-ref> attribute
     *   for some reason.</p>
     * 
     * <tp:rationale>
     *   <p>It's reasonable to assume that blocked contacts should not be
     *     visible to the user unless they specifically go looking for them,
     *     at least in protocols like XMPP where blocking a contact
     *     suppresses presence.</p>
     * </tp:rationale>
     *
     * \param interfaces
     *     
     *     <p>A list of strings indicating which D-Bus interfaces the calling
     *       process is interested in. Equivalent to the corresponding argument
     *       to <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Contacts">GetContactAttributes</tp:dbus-ref>,
     *       except that if this list does not contain the ContactList
     *       interface itself, it is treated as though that interface was also
     *       requested.</p>
     *
     * \param hold
     *     
     *     <p>Whether to hold the handles on behalf of the calling process.
     *       Equivalent to the corresponding argument to <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Contacts">GetContactAttributes</tp:dbus-ref>.</p>
     *
     * \return
     *     
     *     <p>A dictionary mapping the contact handles to contact attributes,
     *       equivalent to the result of <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Contacts">GetContactAttributes</tp:dbus-ref>.</p>
     */
    inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestSubscription" on the remote object.
     * 
     * <p>Request that the given contacts allow the local user to
     *   subscribe to their presence, i.e. that their subscribe attribute
     *   becomes Yes.</p>
     * 
     * <p>Before calling this method on a connection where <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Aliasing">GetAliasFlags</tp:dbus-ref> returns the <code>User_Set</code> flag,
     *   user interfaces SHOULD obtain, from the user, an alias to
     *   identify the contact in future, and store it using <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Aliasing">SetAliases</tp:dbus-ref>.
     * 
     *   The user MAY be
     *   prompted using the contact's current self-assigned nickname, or
     *   something derived from the contact's (presumably self-assigned)
     *   identifier, as a default, but these names chosen by the contact
     *   SHOULD NOT be used without user approval.</p>
     * 
     * <tp:rationale>
     *   <p>This is a generalization of
     *     <a href="http://xmpp.org/extensions/xep-0165.html">XEP-0165 &quot;Best Practices to Discourage JID Mimicking&quot;</a>)
     *     to protocols other than XMPP. A reasonable user interface for
     *     this, as used in many XMPP clients, is to have a text entry
     *     for the alias adjacent to the text entry for the identifier
     *     to add.</p>
     * </tp:rationale>
     * 
     * <p>For contacts with subscribe=Yes, this method has no effect.
     *   It MUST return successfully if all contacts are in this state.</p>
     * 
     * <p>For contacts with subscribe=Ask, this method SHOULD send a new
     *   request, with the given message, if allowed by the underlying
     *   protocol.</p>
     * 
     * <p>For contacts with subscribe=No or subscribe=Rejected, this method
     *   SHOULD request that the contact allows the local user to subscribe
     *   to their presence; in general, this will change their publish
     *   attribute to Ask (although it could change directly to Yes in some
     *   situations).</p>
     * 
     * <p>Any state changes that immediately result from this request MUST
     *   be signalled via <tp:member-ref>ContactsChanged</tp:member-ref>
     *   before this method returns.</p>
     * 
     * <tp:rationale>
     *   <p>This makes it easy for user interfaces to see what practical
     *     effect this method had.</p>
     * </tp:rationale>
     * 
     * <p>If the remote contact accepts the request, their subscribe
     *   attribute will later change from Ask to Yes.</p>
     * 
     * <p>If the remote contact explicitly rejects the request (in protocols
     *   that allow this), their subscribe attribute will later change from
     *   Ask to Rejected.</p>
     * 
     * <p>If the subscription request is cancelled by the local user, the
     *   contact's subscribe attribute will change from Ask to No.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:member-ref>ContactListState</tp:member-ref> changes to Success.
     *   If the <tp:member-ref>ContactListState</tp:member-ref> changes to
     *   Failure, this method SHOULD raise the same error as
     *   <tp:member-ref>GetContactListAttributes</tp:member-ref>.</p>
     *
     * \param contacts
     *     
     *     <p>One or more contacts to whom requests are to be sent.</p>
     *
     * \param message
     *     
     *     <p>An optional plain-text message from the user, to send to those
     *       contacts with the subscription request. The
     *       <tp:member-ref>RequestUsesMessage</tp:member-ref> property
     *       indicates whether this message will be used or ignored.</p>
     *     
     *     <p>Clients SHOULD NOT send a non-empty message without first giving
     *       the user an opportunity to edit it.</p>
     *     
     *     <tp:rationale>
     *       <p>These messages are typically presented to the remote contact
     *         as if the user had typed them, so as a minimum, the user should be
     *         allowed to see what the UI will be saying on their behalf.</p>
     *     </tp:rationale>
     *     
     *     <p>Connections where this message is not useful MUST still allow it to
     *       be non-empty.</p>
     */
    inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "AuthorizePublication" on the remote object.
     * 
     * <p>For each of the given contacts, request that the local user's
     *   presence is sent to that contact, i.e. that their publish attribute
     *   becomes Yes.</p>
     * 
     * <p>For contacts with publish=Yes, this method has no effect; it
     *   MUST return successfully if all contacts given have this state.</p>
     * 
     * <p>For contacts with publish=Ask, this method accepts the
     *   contact's request to see the local user's presence, changing
     *   their publish attribute from Ask to Yes.</p>
     * 
     * <p>For contacts with publish=No, if the protocol allows it, this
     *   method allows the contacts to see the local user's presence even
     *   though they have not requested it, changing their publish attribute
     *   from No to Yes. Otherwise, it merely records the fact that
     *   presence publication to those contacts is allowed; if any of
     *   those contacts ask to receive the local user's presence
     *   later in the lifetime of the connection, the connection SHOULD
     *   immediately allow them to do so, changing their publish
     *   attribute directly from No to Yes.</p>
     * 
     * <tp:rationale>
     *   <p>This makes it easy to implement the common UI policy that if
     *     the user attempts to subscribe to a contact's presence, requests
     *     for reciprocal subscription are automatically approved.</p>
     * </tp:rationale>
     * 
     * <p>Any state changes that immediately result from this request MUST
     *   be signalled via <tp:member-ref>ContactsChanged</tp:member-ref>
     *   before this method returns.</p>
     * 
     * <tp:rationale>
     *   <p>This makes it easy for user interfaces to see what practical
     *     effect this method had.</p>
     * </tp:rationale>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:member-ref>ContactListState</tp:member-ref> changes to Success.
     *   If the <tp:member-ref>ContactListState</tp:member-ref> changes to
     *   Failure, this method SHOULD raise the same error as
     *   <tp:member-ref>GetContactListAttributes</tp:member-ref>.</p>
     *
     * \param contacts
     *     
     *     <p>One or more contacts to authorize.</p>
     */
    inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RemoveContacts" on the remote object.
     * 
     * <p>Remove the given contacts from the contact list entirely. It is
     *   protocol-dependent whether this works, and under which
     *   circumstances.</p>
     * 
     * <p>If possible, this method SHOULD set the contacts' subscribe and
     *   publish attributes to No, remove any stored aliases for those
     *   contacts, and remove the contacts from the result of
     *   <tp:member-ref>GetContactListAttributes</tp:member-ref>.</p>
     * 
     * <p>This method SHOULD succeed even if it was not possible to carry out
     *   the request entirely or for all contacts (for instance, if there is an
     *   outstanding request to subscribe to the contact's presence, and it's
     *   not possible to cancel such requests). However, all signals that
     *   immediately result from this method call MUST be emitted before it
     *   returns, so that clients can interpret the result.</p>
     * 
     * <tp:rationale>
     *   <p>User interfaces removing a contact from the contact list are
     *     unlikely to want spurious failure notifications resulting from
     *     limitations of a particular protocol. However, emitting the
     *     signals first means that if a client does want to check exactly
     *     what happened, it can wait for the method to return (while
     *     applying change-notification signals to its local cache of the
     *     contact list's state), then consult its local cache of the
     *     contact list's state to see whether the contact is still there.</p>
     * </tp:rationale>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:member-ref>ContactListState</tp:member-ref> changes to Success.
     *   If the <tp:member-ref>ContactListState</tp:member-ref> changes to
     *   Failure, this method SHOULD raise the same error as
     *   <tp:member-ref>GetContactListAttributes</tp:member-ref>.</p>
     *
     * \param contacts
     *     
     *     <p>One or more contacts to remove.</p>
     */
    inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "Unsubscribe" on the remote object.
     * 
     * <p>Attempt to set the given contacts' subscribe attribute to No,
     *   i.e. stop receiving their presence.</p>
     * 
     * <p>For contacts with subscribe=Ask, this attempts to cancel
     *   an earlier request to subscribe to the contact's presence; for
     *   contacts with subscribe=Yes, this attempts to
     *   unsubscribe from the contact's presence.</p>
     * 
     * <p>As with <tp:member-ref>RemoveContacts</tp:member-ref>, this method
     *   SHOULD succeed even if it was not possible to carry out the request
     *   entirely or for all contacts; however, all signals that
     *   immediately result from this method call MUST be emitted before it
     *   returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:member-ref>ContactListState</tp:member-ref> changes to Success.
     *   If the <tp:member-ref>ContactListState</tp:member-ref> changes to
     *   Failure, this method SHOULD raise the same error as
     *   <tp:member-ref>GetContactListAttributes</tp:member-ref>.</p>
     *
     * \param contacts
     *     
     *     <p>One or more contacts to remove.</p>
     */
    inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "Unpublish" on the remote object.
     * 
     * <p>Attempt to set the given contacts' publish attribute to No,
     *   i.e. stop sending presence to them.</p>
     * 
     * <p>For contacts with publish=Ask, this method explicitly rejects the
     *   contact's request to subscribe to the user's presence; for
     *   contacts with publish=Yes, this method attempts to prevent the
     *   user's presence from being received by the contact.</p>
     * 
     * <p>As with <tp:member-ref>RemoveContacts</tp:member-ref>, this method
     *   SHOULD succeed even if it was not possible to carry out the request
     *   entirely or for all contacts; however, all signals that
     *   immediately result from this method call MUST be emitted before it
     *   returns.</p>
     * 
     * <p>This method SHOULD NOT be called until the
     *   <tp:member-ref>ContactListState</tp:member-ref> changes to Success.
     *   If the <tp:member-ref>ContactListState</tp:member-ref> changes to
     *   Failure, this method SHOULD raise the same error as
     *   <tp:member-ref>GetContactListAttributes</tp:member-ref>.</p>
     *
     * \param contacts
     *     
     *     <p>One or more contacts to remove.</p>
     */
    inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "ContactListStateChanged" on the remote object.
     * 
     * Emitted when ContactListState changes.
     *
     * \param contactListState
     *     
     *     The new value of ContactListState.
     */
    void ContactListStateChanged(uint contactListState);

    /**
     * Represents the signal "ContactsChanged" on the remote object.
     * 
     * <p>Emitted when the contact list becomes available, when contacts'
     *   basic stored properties change, when new contacts are added to the
     *   list that would be returned by
     *   <tp:member-ref>GetContactListAttributes</tp:member-ref>,
     *   or when contacts are removed from that list.</p>
     * 
     * <tp:rationale>
     *   <p>This provides change notification for that list, and for
     *     contacts' <tp:token-ref>subscribe</tp:token-ref>,
     *     <tp:token-ref>publish</tp:token-ref> and
     *     <tp:token-ref>publish-request</tp:token-ref> attributes.</p>
     * </tp:rationale>
     * 
     * <p>Connection managers SHOULD also emit this signal when a contact
     *   requests that the user's presence is published to them, even if
     *   that contact's <tp:token>publish</tp:token> attribute is already
     *   Ask and the <tp:token>publish-request</tp:token> has not changed.</p>
     * 
     * <tp:rationale>
     *   <p>If the same contact sends 10 identical requests, 10 identical
     *     signals should be emitted.</p>
     * </tp:rationale>
     *
     * \param changes
     *     
     *     The new subscribe, publish and publish-request attributes of all 
     *     the contacts that have been added, and all the contacts for which 
     *     those attributes have changed.
     *
     * \param removals
     *     
     *     The contacts that have been removed from the list that would be 
     *     returned by GetContactListAttributes. This also implies that they 
     *     have subscribe = No and publish = No; contacts MUST NOT be listed 
     *     both here and in Changes.
     */
    void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);

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

/**
 * \class ConnectionInterfaceContactsInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Contacts."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceContactsInterface 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.
     */
    ConnectionInterfaceContactsInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactsInterface 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.
     */
    ConnectionInterfaceContactsInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceContactsInterface 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.
     */
    ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceContactsInterface 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 ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceContactsInterface 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.
     */
    ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "ContactAttributeInterfaces" on the remote object.
     * 
     * A list of D-Bus interfaces for which GetContactAttributes is expected 
     * to work. This cannot change during the lifetime of the Connection.
     */
    Q_PROPERTY(QStringList ContactAttributeInterfaces READ _deprecated_ContactAttributeInterfaces)

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

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

    /**
     * Asynchronous getter for the remote object property "ContactAttributeInterfaces" of type QStringList.
     *
     * 
     * A list of D-Bus interfaces for which GetContactAttributes is expected 
     * to work. This cannot change during the lifetime of the Connection.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
    {
        return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
    }

    /**
     * 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 "GetContactAttributes" on the remote object.
     * 
     * Return any number of contact attributes for the given handles.
     *
     * \param handles
     *     
     *     An array of handles representing contacts.
     *
     * \param interfaces
     *     
     *     <p>A list of strings indicating which D-Bus interfaces the calling
     *       process is interested in. All supported attributes from these
     *       interfaces, whose values can be obtained without additional network
     *       activity, will be in the reply.</p>
     *     
     *     <p>Connection managers SHOULD ignore interfaces requested which they
     *       do not support (i.e. those not mentioned in the
     *       <tp:member-ref>ContactAttributeInterfaces</tp:member-ref>
     *       property.)</p>
     *     
     *     <tp:rationale>
     *       <p>This simplifies client-side code. Clients which care may
     *         distinguish between unsupported interfaces (e.g. this Connection
     *         does not support Avatars), and interfaces on which no information
     *         is known for these contacts (e.g. we don't know the avatar tokens
     *         of any of the contacts, so we omitted them all) by inspecting
     *         <tp:member-ref>ContactAttributeInterfaces</tp:member-ref>.</p>
     *     </tp:rationale>
     *     
     *     <p>Attributes from the interface
     *       <tp:dbus-ref>org.freedesktop.Telepathy.Connection</tp:dbus-ref>
     *       are always returned, and need not be requested explicitly.</p>
     *     
     *     <p>As well as returning cached information immediately, the
     *       connection MAY start asynchronous requests to obtain better
     *       values for the contact attributes. If better values are later
     *       obtained by this process, they will be indicated with the usual
     *       signals (such as <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface.Aliasing">AliasesChanged</tp:dbus-ref>).</p>
     *     
     *     <tp:rationale>
     *       For instance, an XMPP connection manager could download vCards
     *       in response to a request for <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface">Aliasing</tp:dbus-ref>
     *       attributes.
     *     </tp:rationale>
     *
     * \param hold
     *     
     *     If true, all handles in the result have been held on behalf of the 
     *     calling process, as if by a call to Connection.HoldHandles. For 
     *     further round-trip avoidance.
     *
     * \return
     *     
     *     <p>A dictionary mapping the contact handles to contact attributes.
     *       If any of the requested handles are in fact invalid, they are
     *       simply omitted from this mapping. If contact attributes are not
     *       immediately known, the behaviour is defined by the interface;
     *       the attribute should either be omitted from the result or
     *       replaced with a default value.</p>
     *     
     *     <p>Each contact's attributes will always include at least the
     *       identifier that would be obtained by inspecting the handle
     *       (<code>org.freedesktop.Telepathy.Connection/contact-id</code>).</p>
     */
    inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

/**
 * \class ConnectionInterfaceLocationInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Location."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceLocationInterface 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.
     */
    ConnectionInterfaceLocationInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceLocationInterface 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.
     */
    ConnectionInterfaceLocationInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceLocationInterface 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.
     */
    ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceLocationInterface 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 ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceLocationInterface 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.
     */
    ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "LocationAccessControlTypes" on the remote object.
     * 
     * The types of access control that are supported by this connection.
     */
    Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ _deprecated_LocationAccessControlTypes)

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

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

    /**
     * Asynchronous getter for the remote object property "LocationAccessControlTypes" of type Tp::UIntList.
     *
     * 
     * The types of access control that are supported by this connection.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
    {
        return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
    }

    /**
     * Represents property "LocationAccessControl" on the remote object.
     * 
     * The current access control mechanism and settings for this connection. 
     * Before publishing location for the first time, if this has not been set 
     * by a client, implementations SHOULD set it to be as restrictive as 
     * possible (an empty whitelist, if supported).
     */
    Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ _deprecated_LocationAccessControl WRITE _deprecated_setLocationAccessControl)

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

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

    /**
     * Asynchronous getter for the remote object property "LocationAccessControl" of type Tp::RichPresenceAccessControl.
     *
     * 
     * The current access control mechanism and settings for this connection. 
     * Before publishing location for the first time, if this has not been set 
     * by a client, implementations SHOULD set it to be as restrictive as 
     * possible (an empty whitelist, if supported).
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
    {
        return internalRequestProperty(QLatin1String("LocationAccessControl"));
    }

    /**
     * Setter for the remote object property "LocationAccessControl".
     *
     * Don't use this: it blocks the main loop.
     *
     * \param newValue The value to set the property to.
     */
    inline TELEPATHY_QT4_DEPRECATED void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue)
    {
        return _deprecated_setLocationAccessControl(newValue);
    }

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

    /**
     * Asynchronous setter for the remote object property "LocationAccessControl" of type Tp::RichPresenceAccessControl.
     *
     * 
     * The current access control mechanism and settings for this connection. 
     * Before publishing location for the first time, if this has not been set 
     * by a client, implementations SHOULD set it to be as restrictive as 
     * possible (an empty whitelist, if supported).
     *
     * \return A pending operation which will emit finished when the property has been
     *          set.
     */
    inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
    {
        return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
    }

    /**
     * Represents property "SupportedLocationFeatures" on the remote object.
     * 
     * Indicates the Location features supported by this connection. This
     * property MAY be undefined before <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">Status</tp:dbus-ref>
     * becomes <code>Connected</code>, but MUST remain constant thereafter.
     */
    Q_PROPERTY(uint SupportedLocationFeatures READ _deprecated_SupportedLocationFeatures)

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

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

    /**
     * Asynchronous getter for the remote object property "SupportedLocationFeatures" of type uint.
     *
     * 
     * Indicates the Location features supported by this connection. This
     * property MAY be undefined before <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">Status</tp:dbus-ref>
     * becomes <code>Connected</code>, but MUST remain constant thereafter.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
    {
        return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
    }

    /**
     * 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 "GetLocations" on the remote object.
     * 
     * Return the current locations of the given contacts, if they are already 
     * known. If any of the given contacts&apos; locations are not known, 
     * request their current locations, but return immediately without waiting 
     * for a reply; if a reply with a non-empty location is later received for 
     * those contacts, the LocationUpdated signal will be emitted for them. 
     * This method is appropriate for &quot;lazy&quot; location finding, for 
     * instance displaying the location (if available) of everyone in your 
     * contact list.
     *
     * \param contacts
     *     
     *     The contacts whose locations should be returned or signalled.
     *
     * \return
     *     
     *     The contacts&apos; locations, if already known. Contacts whose 
     *     locations are not already known are omitted from the mapping; 
     *     contacts known to have no location information appear in the 
     *     mapping with an empty Location dictionary.
     */
    inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestLocation" on the remote object.
     * 
     * Return the current location of the given contact. If necessary, make a 
     * request to the server for up-to-date information, and wait for a reply. 
     * This method is appropriate for use in a &quot;Contact 
     * Information...&quot; dialog; it can be used to show progress 
     * information (while waiting for the method to return), and can 
     * distinguish between various error conditions.
     *
     * \param contact
     *     
     *     The contact whose location should be returned.
     *
     * \return
     *     
     *     The contact&apos;s location. It MAY be empty, indicating that no 
     *     location information was found.
     */
    inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "SetLocation" on the remote object.
     * 
     * Set the local user&apos;s own location.
     *
     * \param location
     *     
     *     The location to advertise. If the user wants to obscure their exact 
     *     location by reducing the precision or accuracy, clients MUST do 
     *     this themselves, rather than relying on the connection manager to 
     *     do so. Clients that interact with more than one connection SHOULD 
     *     advertise the same reduced-accuracy location to all of them, so 
     *     that contacts cannot obtain an undesirably accurate location by 
     *     assuming that random errors have been added and averaging the 
     *     locations advertised on multiple connections.
     */
    inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "LocationUpdated" on the remote object.
     * 
     * Emitted when a contact&apos;s location changes or becomes known.
     *
     * \param contact
     *     
     *     The contact
     *
     * \param location
     *     
     *     The contact&apos;s location, or empty to indicate that nothing is 
     *     known about the contact&apos;s location.
     */
    void LocationUpdated(uint contact, const QVariantMap& location);

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

/**
 * \class ConnectionInterfacePowerSavingInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.PowerSaving.DRAFT."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfacePowerSavingInterface 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.
     */
    ConnectionInterfacePowerSavingInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfacePowerSavingInterface 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.
     */
    ConnectionInterfacePowerSavingInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfacePowerSavingInterface 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.
     */
    ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfacePowerSavingInterface 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 ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfacePowerSavingInterface 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.
     */
    ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "PowerSavingActive" on the remote object.
     * 
     * <p><code>True</code> if protocol-level power saving features are
     *   currently activated. This property can be changed using the
     *   <tp:member-ref>SetPowerSaving</tp:member-ref> method; change
     *   notifications is via the
     *   <tp:member-ref>PowerSavingChanged</tp:member-ref> signal.</p>
     */
    Q_PROPERTY(bool PowerSavingActive READ _deprecated_PowerSavingActive)

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

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

    /**
     * Asynchronous getter for the remote object property "PowerSavingActive" of type bool.
     *
     * 
     * <p><code>True</code> if protocol-level power saving features are
     *   currently activated. This property can be changed using the
     *   <tp:member-ref>SetPowerSaving</tp:member-ref> method; change
     *   notifications is via the
     *   <tp:member-ref>PowerSavingChanged</tp:member-ref> signal.</p>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
    {
        return internalRequestProperty(QLatin1String("PowerSavingActive"));
    }

    /**
     * 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 "SetPowerSaving" on the remote object.
     * 
     * <p>Turn power saving mode on or off.</p>
     * 
     * <tp:rationale>
     *   <p>Depending on the device's activity level, the
     *     connection can have its power saving mode turned on or off.</p>
     * </tp:rationale>
     * 
     * <p>Errors raised by this method indicate that power saving could not be
     *   enabled, which SHOULD NOT generally be treated as fatal.</p>
     * 
     * <tp:rationale>
     *   If the CM cannot switch modes, either because of the
     *   protocol (<code>NotImplemented</code>), or because of the service
     *   (<code>NotAvailable</code>), Mission Control (or whoever manages this)
     *   should be made aware. The error could be ignored or, in the extreme,
     *   be fascist and disconnect the account.
     * </tp:rationale>
     *
     * \param activate
     *     
     *     True if protocol-level power saving features should be activated; 
     *     False if they should be de-activated.
     */
    inline QDBusPendingReply<> SetPowerSaving(bool activate)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "PowerSavingChanged" on the remote object.
     * 
     * The <tp:member-ref>PowerSavingActive</tp:member-ref>
     * property changed.
     *
     * \param active
     *     
     *     The new state of the power saving feature.
     */
    void PowerSavingChanged(bool active);

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

/**
 * \class ConnectionInterfacePresenceInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Presence."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfacePresenceInterface 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.
     */
    ConnectionInterfacePresenceInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfacePresenceInterface 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.
     */
    ConnectionInterfacePresenceInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfacePresenceInterface 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.
     */
    ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfacePresenceInterface 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 ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfacePresenceInterface 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.
     */
    ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& 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 "AddStatus" on the remote object.
     * 
     * Request that a single presence status is published for the user, along 
     * with any desired parameters. Changes will be indicated by 
     * PresenceUpdate signals being emitted.
     *
     * \param status
     *     
     *     The string identifier of the desired status
     *
     * \param parameters
     *     
     *     A dictionary of optional parameter names mapped to their 
     *     variant-boxed values
     */
    inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "ClearStatus" on the remote object.
     * 
     * Request that all of a user&apos;s presence statuses be removed. Be 
     * aware that this request may simply result in the statuses being 
     * replaced by a default available status. Changes will be indicated by 
     * PresenceUpdate signals being emitted.
     */
    inline QDBusPendingReply<> ClearStatus()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetPresence" on the remote object.
     * 
     * Get presence previously emitted by PresenceUpdate for the given 
     * contacts. Data is returned in the same structure as the PresenceUpdate 
     * signal. Using this method in favour of RequestPresence has the 
     * advantage that it will not wake up each client connected to the 
     * PresenceUpdate signal.
     *
     * \param contacts
     *     
     *     An array of the contacts whose presence should be obtained
     *
     * \return
     *     
     *     Presence information in the same format as for the PresenceUpdate 
     *     signal
     */
    inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetStatuses" on the remote object.
     * 
     * Get a dictionary of the valid presence statuses for this connection. 
     * This is only available when online because only some statuses will be 
     * available on some servers.
     *
     * \return
     *     
     *     A dictionary of string identifiers mapped to a struct for each 
     *     status, containing: a type value from one of the values above a 
     *     boolean to indicate if this status may be set on yourself a boolean 
     *     to indicate if this is an exclusive status which you may not set 
     *     alongside any other a dictionary of valid optional string argument 
     *     names mapped to their types
     */
    inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RemoveStatus" on the remote object.
     * 
     * Request that the given presence status is no longer published for the 
     * user. Changes will be indicated by PresenceUpdate signals being 
     * emitted. As with ClearStatus, removing a status may actually result in 
     * it being replaced by a default available status.
     *
     * \param status
     *     
     *     The string identifier of the status not to publish anymore for the 
     *     user
     */
    inline QDBusPendingReply<> RemoveStatus(const QString& status)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "RequestPresence" on the remote object.
     * 
     * Request the presence for contacts on this connection. A PresenceUpdate 
     * signal will be emitted when they are received. This is not the same as 
     * subscribing to the presence of a contact, which must be done using the 
     * &apos;subscription&apos; ContactList, and on some protocols presence 
     * information may not be available unless a subscription exists.
     *
     * \param contacts
     *     
     *     An array of the contacts whose presence should be obtained
     */
    inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "SetLastActivityTime" on the remote object.
     * 
     * Request that the recorded last activity time for the user be updated on 
     * the server.
     *
     * \param time
     *     
     *     A UNIX timestamp of the user&apos;s last activity time (in UTC)
     */
    inline QDBusPendingReply<> SetLastActivityTime(uint time)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "SetStatus" on the remote object.
     * 
     * <p>Request that the user's presence be changed to the given statuses
     *   and desired parameters. Changes will be reflected by
     *   <tp:member-ref>PresenceUpdate</tp:member-ref>
     *   signals being emitted.</p>
     * 
     * <p>Statuses whose <tp:type>Connection_Presence_Type</tp:type>
     *   is Offline, Error or Unknown MUST NOT be passed to this
     *   function. Connection managers SHOULD reject these statuses.</p>
     * 
     * <tp:rationale>
     *   <p>The same rationale as for <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection.Interface">SimplePresence.SetPresence</tp:dbus-ref>
     *     applies.</p>
     * </tp:rationale>
     * 
     * <p>On certain protocols, this method may be
     *   called on a newly-created connection which is still in the
     *   DISCONNECTED state, and will sign on with the requested status.
     *   If the requested status is not available after signing on,
     *   NotAvailable will be returned and the connection will remain
     *   offline, or if the protocol does not support signing on with
     *   a certain status, Disconnected will be returned.</p>
     *
     * \param statuses
     *     
     *     A dictionary mapping status identifiers to dictionaries, which map 
     *     optional parameter names to their variant-boxed values
     */
    inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "PresenceUpdate" on the remote object.
     * 
     * This signal should be emitted when your own presence has been changed, 
     * or the presence of the member of any of the connection&apos;s channels 
     * has been changed, or when the presence requested by RequestPresence is 
     * available.
     *
     * \param presence
     *     
     *     A dictionary of contact handles mapped to a struct containing a 
     *     UNIX timestamp of the last activity time (in UTC), and a dictionary 
     *     mapping the contact&apos;s current status identifiers to a 
     *     dictionary of optional parameter names mapped to their 
     *     variant-boxed values
     */
    void PresenceUpdate(const Tp::ContactPresences& presence);

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

/**
 * \class ConnectionInterfaceRequestsInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.Requests."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceRequestsInterface 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.
     */
    ConnectionInterfaceRequestsInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceRequestsInterface 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.
     */
    ConnectionInterfaceRequestsInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceRequestsInterface 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.
     */
    ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceRequestsInterface 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 ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceRequestsInterface 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.
     */
    ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "Channels" on the remote object.
     * 
     * A list of all the channels which currently exist on this connection. 
     * Change notification is via the NewChannels and ChannelClosed signals.
     */
    Q_PROPERTY(Tp::ChannelDetailsList 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::ChannelDetailsList Channels() const
    {
        return _deprecated_Channels();
    }

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

    /**
     * Asynchronous getter for the remote object property "Channels" of type Tp::ChannelDetailsList.
     *
     * 
     * A list of all the channels which currently exist on this connection. 
     * Change notification is via the NewChannels and ChannelClosed signals.
     *
     * \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 "RequestableChannelClasses" on the remote object.
     * 
     * <p>The classes of channel that are expected to be available on this
     *   connection, i.e. those for which
     *   <tp:member-ref>CreateChannel</tp:member-ref> can reasonably
     *   be expected to succeed. User interfaces can use this information
     *   to show or hide UI components.</p>
     * 
     * <p>This property cannot change after the connection has gone to
     *   state Connection_Status_Connected, so there is no change
     *   notification (if the connection has context-dependent capabilities,
     *   it SHOULD advertise support for all classes of channel that it might
     *   support during its lifetime). Before this state has been reached,
     *   the value of this property is undefined.</p>
     * 
     * <tp:rationale>
     *   <p>This is not on an optional interface, because connection
     *     managers can always offer some sort of clue about the channel
     *     classes they expect to support (at worst, they can announce
     *     support for everything for which they have code).</p>
     * </tp:rationale>
     */
    Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ _deprecated_RequestableChannelClasses)

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

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

    /**
     * Asynchronous getter for the remote object property "RequestableChannelClasses" of type Tp::RequestableChannelClassList.
     *
     * 
     * <p>The classes of channel that are expected to be available on this
     *   connection, i.e. those for which
     *   <tp:member-ref>CreateChannel</tp:member-ref> can reasonably
     *   be expected to succeed. User interfaces can use this information
     *   to show or hide UI components.</p>
     * 
     * <p>This property cannot change after the connection has gone to
     *   state Connection_Status_Connected, so there is no change
     *   notification (if the connection has context-dependent capabilities,
     *   it SHOULD advertise support for all classes of channel that it might
     *   support during its lifetime). Before this state has been reached,
     *   the value of this property is undefined.</p>
     * 
     * <tp:rationale>
     *   <p>This is not on an optional interface, because connection
     *     managers can always offer some sort of clue about the channel
     *     classes they expect to support (at worst, they can announce
     *     support for everything for which they have code).</p>
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
    {
        return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
    }

    /**
     * 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 "CreateChannel" on the remote object.
     * 
     * <p>Request that an entirely new channel is created.</p>
     * 
     * <tp:rationale>
     *   <p>There is deliberately no flag corresponding to the
     *     suppress_handler argument to
     *     <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.RequestChannel</tp:dbus-ref>,
     *     because passing a FALSE value for that argument is deprecated.
     *     Requests made using this interface always behave as though
     *     suppress_handler was TRUE.</p>
     * </tp:rationale>
     *
     * \param request
     *     
     *     <p>A dictionary containing desirable properties, which MUST include
     *       <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel">ChannelType</tp:dbus-ref>.
     *       Some properties
     *       are defined such that only an exact match makes sense, and
     *       connection managers MUST NOT satisfy a request with a channel
     *       where that property does not match; some properties are defined
     *       such that the connection manager MAY treat the request as merely
     *       a hint, and make a best-effort attempt to satisfy it. This is
     *       documented separately for each property.</p>
     *     
     *     <p>If this dictionary contains a property whose semantics
     *       are not known to the connection manager, this method MUST fail
     *       without side-effects (in particular it must not create a new
     *       channel).</p>
     *     
     *     <tp:rationale>
     *       <p>This is necessary if we want to be able to invent properties
     *         in future that, when used in a request, are hard requirements
     *         rather than just hints. A connection manager that did not know
     *         the semantics of those properties could incorrectly return a
     *         new channel that did not satisfy the requirements.</p>
     *     </tp:rationale>
     *     
     *     <p>The connection manager MUST NOT respond successfully,
     *       and SHOULD NOT create a new channel or cause any other
     *       side-effects, unless it can create a new channel that satisfies
     *       the client's requirements.</p>
     *     
     *     <p>Properties that will be set by this argument need not have write
     *       access after the channel has been created - indeed, it is
     *       expected that most will be read-only.</p>
     *
     * \return
     *     
     *     <p>The Channel object, which MUST NOT be signalled with
     *       <tp:member-ref>NewChannels</tp:member-ref> until after this method
     *       returns.</p>
     *     
     *     <tp:rationale>
     *       <p>This allows the requester to alter its handling of
     *         NewChannels by knowing whether one of the channels satisfied
     *         a request it made.</p>
     *     </tp:rationale>
     *
     * \return
     *     
     *     <p>Properties of the channel that was produced, equivalent to
     *       the properties in <tp:type>Channel_Details</tp:type>.
     *       Connection managers MUST NOT include properties here whose
     *       values can change, for the same reasons as in
     *       <tp:type>Channel_Details</tp:type>.</p>
     */
    inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "EnsureChannel" on the remote object.
     * 
     * <p>Request that channels are ensured to exist.</p>
     * 
     * <tp:rationale>
     *   <p>The connection manager is in the best position to determine which
     *     existing channels could satisfy which requests.</p>
     * </tp:rationale>
     *
     * \param request
     *     
     *     <p>A dictionary containing desirable properties, with the same
     *       semantics as the corresponding parameter to
     *       <tp:member-ref>CreateChannel</tp:member-ref>.</p>
     *
     * \return
     *     
     *     <p>If false, the caller of EnsureChannel MUST assume that some
     *       other process is handling this channel; if true, the caller of
     *       EnsureChannel SHOULD handle it themselves or delegate it to another
     *       client.</p>
     *     
     *     <p>If the creation of a channel makes several calls to EnsureChannel
     *       (and no other requests) successful, exactly one of those calls MUST
     *       return a true value for this argument.</p>
     *     
     *     <p>If the creation of a channel makes other requests successful,
     *       the value returned for this argument MUST be such that exactly
     *       one of the clients making requests ends up responsible for the
     *       channel. In particular, if
     *       <tp:member-ref>CreateChannel</tp:member-ref> returns a channel
     *       <em>C</em>, any EnsureChannel calls that also return <em>C</em>
     *       MUST return a false value for this argument.</p>
     *
     * \return
     *     
     *     The Channel object. If it was created as a result of this method 
     *     call, it MUST NOT be signalled by NewChannels until after this 
     *     method returns. This allows the requester to alter its handling of 
     *     NewChannels by knowing whether one of the channels satisfied a 
     *     request it made.
     *
     * \return
     *     
     *     <p>Properties of the channel that was produced, equivalent to
     *       the properties in <tp:type>Channel_Details</tp:type>.
     *       Connection managers MUST NOT include properties here whose
     *       values can change, for the same reasons as in
     *       <tp:type>Channel_Details</tp:type>.</p>
     */
    inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "NewChannels" on the remote object.
     * 
     * <p>New channels have been created. The connection manager SHOULD emit
     *   a single signal for any group of closely related channels that are
     *   created at the same time, so that the channel dispatcher can try to
     *   dispatch them to a handler as a unit.</p>
     * 
     * <p>In particular, if additional channels are created as a side-effect
     *   of a call to <tp:member-ref>CreateChannel</tp:member-ref>,
     *   these channels SHOULD appear in the same NewChannels signal as
     *   the channel that satisfies the request.</p>
     * 
     * <tp:rationale>
     *   <p>Joining a MUC Tube in XMPP requires joining the corresponding
     *     MUC (chatroom), so a <tp:dbus-ref namespace="org.freedesktop.Telepathy.Channel.Type">Text</tp:dbus-ref>
     *     channel can be created as a side-effect.</p>
     * </tp:rationale>
     * 
     * <p>Every time NewChannels is emitted, it MUST be followed by
     *   a <tp:dbus-ref namespace="org.freedesktop.Telepathy">Connection.NewChannel</tp:dbus-ref>
     *   signal for each channel.</p>
     * 
     * <tp:rationale>
     *   <p>The double signal emission is for the benefit of older Telepathy
     *     clients, which won't be listening for NewChannels.</p>
     * 
     *   <p>The more informative NewChannels signal comes first so that
     *     clients that did not examine the connection to find
     *     out whether Requests is supported will see the more informative
     *     signal for each channel first, and then ignore the less
     *     informative signal because it announces a new channel of which
     *     they are already aware.</p>
     * </tp:rationale>
     *
     * \param channels
     *     
     *     The channels and their details. All channels that are signalled 
     *     together like this MUST have the same Bundle property, which may 
     *     either refer to an existing bundle, or establish a new bundle.
     */
    void NewChannels(const Tp::ChannelDetailsList& channels);

    /**
     * Represents the signal "ChannelClosed" on the remote object.
     * 
     * Emitted when a channel is closed and hence disappears from the Channels 
     * property. This is redundant with the Closed signal on the channel 
     * itself, but it does provide full change notification for the Channels 
     * property.
     *
     * \param removed
     *     
     *     The channel which has been removed from the Channels property
     */
    void ChannelClosed(const QDBusObjectPath& removed);

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

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

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

    /**
     * Creates a ConnectionInterfaceServicePointInterface 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.
     */
    ConnectionInterfaceServicePointInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceServicePointInterface 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.
     */
    ConnectionInterfaceServicePointInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceServicePointInterface 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.
     */
    ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceServicePointInterface 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 ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceServicePointInterface 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.
     */
    ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "KnownServicePoints" on the remote object.
     * 
     * The list of all (known) service points.
     */
    Q_PROPERTY(Tp::ServicePointInfoList KnownServicePoints READ _deprecated_KnownServicePoints)

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

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

    /**
     * Asynchronous getter for the remote object property "KnownServicePoints" of type Tp::ServicePointInfoList.
     *
     * 
     * The list of all (known) service points.
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
    {
        return internalRequestProperty(QLatin1String("KnownServicePoints"));
    }

    /**
     * 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 "ServicePointsChanged" on the remote object.
     * 
     * Emitted when the list of known service points (or their IDs) has 
     * changed.
     *
     * \param servicePoints
     *     
     *     <p>The new value of
     *       <tp:member-ref>KnownServicePoints</tp:member-ref>.</p>
     */
    void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);

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

/**
 * \class ConnectionInterfaceSimplePresenceInterface
 * \headerfile TelepathyQt4/connection.h <TelepathyQt4/Connection>
 * \ingroup clientconn
 *
 * Proxy class providing a 1:1 mapping of the D-Bus interface "org.freedesktop.Telepathy.Connection.Interface.SimplePresence."
 */
class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

    /**
     * Creates a ConnectionInterfaceSimplePresenceInterface 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.
     */
    ConnectionInterfaceSimplePresenceInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceSimplePresenceInterface 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.
     */
    ConnectionInterfaceSimplePresenceInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    /**
     * Creates a ConnectionInterfaceSimplePresenceInterface 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.
     */
    ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);

    /**
     * Creates a ConnectionInterfaceSimplePresenceInterface 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 ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);

    /**
     * Creates a ConnectionInterfaceSimplePresenceInterface 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.
     */
    ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);

    /**
     * Represents property "Statuses" on the remote object.
     * 
     * <p>A dictionary where the keys are the presence statuses that are
     *   available on this connection, and the values are the corresponding
     *   presence types.</p>
     * 
     * <p>While the connection is in the DISCONNECTED state, it contains
     *   the set of presence statuses allowed to be set before connecting.
     *   The connection manager will attempt to set the appropriate status
     *   when the connection becomes connected, but cannot necessarily
     *   guarantee it. The available statuses cannot change until the
     *   connection status changes, so there is no change notification.</p>
     * 
     * <p>While the connection is in the CONNECTED state, this property
     *   contains the set of presence statuses which are actually available
     *   on this protocol. This set is constant for the remaining lifetime
     *   of the connection, so again, there is no change notification.</p>
     * 
     * <p>While the connection is in the CONNECTING state, the value of
     *   this property is undefined and SHOULD NOT be used. It can change
     *   at any time without notification (in particular, any cached values
     *   from when the connection was in the DISCONNECTED or CONNECTING
     *   state MUST NOT be assumed to still be correct when the state has
     *   become CONNECTED).</p>
     * 
     * <p>This property MUST include the special statuses &quot;unknown&quot; and
     *   &quot;error&quot; if and only if the connection manager can emit them
     *   as a contact's status.</p>
     * 
     * <tp:rationale>
     *   For instance, connection managers for local-xmpp (XEP-0174) would
     *   omit &quot;unknown&quot; since there is no such concept.
     * </tp:rationale>
     */
    Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ _deprecated_Statuses)

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

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

    /**
     * Asynchronous getter for the remote object property "Statuses" of type Tp::SimpleStatusSpecMap.
     *
     * 
     * <p>A dictionary where the keys are the presence statuses that are
     *   available on this connection, and the values are the corresponding
     *   presence types.</p>
     * 
     * <p>While the connection is in the DISCONNECTED state, it contains
     *   the set of presence statuses allowed to be set before connecting.
     *   The connection manager will attempt to set the appropriate status
     *   when the connection becomes connected, but cannot necessarily
     *   guarantee it. The available statuses cannot change until the
     *   connection status changes, so there is no change notification.</p>
     * 
     * <p>While the connection is in the CONNECTED state, this property
     *   contains the set of presence statuses which are actually available
     *   on this protocol. This set is constant for the remaining lifetime
     *   of the connection, so again, there is no change notification.</p>
     * 
     * <p>While the connection is in the CONNECTING state, the value of
     *   this property is undefined and SHOULD NOT be used. It can change
     *   at any time without notification (in particular, any cached values
     *   from when the connection was in the DISCONNECTED or CONNECTING
     *   state MUST NOT be assumed to still be correct when the state has
     *   become CONNECTED).</p>
     * 
     * <p>This property MUST include the special statuses &quot;unknown&quot; and
     *   &quot;error&quot; if and only if the connection manager can emit them
     *   as a contact's status.</p>
     * 
     * <tp:rationale>
     *   For instance, connection managers for local-xmpp (XEP-0174) would
     *   omit &quot;unknown&quot; since there is no such concept.
     * </tp:rationale>
     *
     * \return A pending variant which will emit finished when the property has been
     *          retrieved.
     */
    inline Tp::PendingVariant *requestPropertyStatuses() const
    {
        return internalRequestProperty(QLatin1String("Statuses"));
    }

    /**
     * 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 "SetPresence" on the remote object.
     * 
     * <p>Request that the presence status and status message are published for
     *   the connection.  Changes will be indicated by
     *   <tp:member-ref>PresencesChanged</tp:member-ref>
     *   signals being emitted.</p>
     * 
     * <p>This method may be called on a newly-created connection while it
     *   is still in the DISCONNECTED state, to request that when the
     *   connection connects, it will do so with the selected status.</p>
     * 
     * <p>In DISCONNECTED state the
     *   <tp:member-ref>Statuses</tp:member-ref>
     *   property will indicate which statuses are allowed to be set
     *   while DISCONNECTED (none, if the Connection Manager doesn't allow
     *   this). This value MUST NOT be cached, as the set of allowed
     *   presences might change upon connecting.</p>
     *
     * \param status
     *     
     *     <p>The string identifier of the desired status. Possible status
     *       identifiers are defined in the
     *       <tp:member-ref>Statuses</tp:member-ref> property.</p>
     *     
     *     <p>Clients MUST NOT set a status whose string value they do not
     *       recognise, even if its presence type in Statuses
     *       matches what the user requested.</p>
     *     
     *     <tp:rationale>
     *       <p>Suppose a protocol has statuses that include 'phone' (of type
     *         BUSY) and 'in-a-meeting' (of type BUSY), but there is no
     *         generic 'busy' status.</p>
     *     
     *       <p>If the user requests &quot;Busy&quot; status from a menu, a
     *         client author might be tempted to pick an arbitrary status
     *         that has type BUSY. However, on this protocol, neither of
     *         the choices would be appropriate, and incorrect information
     *         about the user would be conveyed.</p>
     *     </tp:rationale>
     *     
     *     <p>Statuses whose <tp:type>Connection_Presence_Type</tp:type>
     *       is Offline, Error or Unknown MUST NOT be passed to this
     *       function. Connection managers SHOULD reject these statuses.</p>
     *     
     *     <tp:rationale>
     *       <p>To go offline, call <tp:dbus-ref namespace="org.freedesktop.Telepathy.Connection">Disconnect</tp:dbus-ref>
     *       instead. The &quot;error&quot; and &quot;unknown&quot; statuses make no sense.</p>
     *     </tp:rationale>
     *
     * \param statusMessage
     *     
     *     The status message associated with the current status.
     */
    inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

    /**
     * Begins a call to the D-Bus method "GetPresences" on the remote object.
     * 
     * Get presence previously emitted by PresencesChanged for the given 
     * contacts. Data is returned in the same structure as the 
     * PresencesChanged signal; no additional network requests are made.
     *
     * \param contacts
     *     
     *     An array of the contacts whose presence should be obtained.
     *
     * \return
     *     
     *     <p>Presence information in the same format as for the
     *       <tp:member-ref>PresencesChanged</tp:member-ref> signal.
     *       The returned mapping MUST include an entry for each contact
     *       in the method's argument.</p>
     *     
     *     <p>The definition of the connection presence types Unknown
     *       and Offline means that if a connection manager will return
     *       Unknown for contacts not on the subscribe list, it MUST delay
     *       the reply to this method call until it has found out which
     *       contacts are, in fact, on the subscribe list.</p>
     */
    inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

Q_SIGNALS:
    /**
     * Represents the signal "PresencesChanged" on the remote object.
     * 
     * This signal should be emitted when your own presence has been changed, 
     * or the presence of the member of any of the connection&apos;s channels 
     * has been changed.
     *
     * \param presence
     *     
     *     A dictionary of contact handles mapped to the status, presence type 
     *     and status message.
     */
    void PresencesChanged(const Tp::SimpleContactPresences& presence);

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)
