cli-client.h

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

#ifndef IN_TP_QT_HEADER
#error IN_TP_QT_HEADER
#endif

#include <TelepathyQt/Types>

#include <QtGlobal>

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

#include <QDBusPendingReply>

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

namespace Tp
{
class PendingVariant;
class PendingOperation;
}

namespace Tp
{
namespace Client
{

class TP_QT_EXPORT ClientInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ClientInterface(Tp::DBusProxy *proxy);

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

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

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

class TP_QT_EXPORT ClientApproverInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Client.Approver");
    }

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

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

    ClientApproverInterface(Tp::DBusProxy *proxy);

    explicit ClientApproverInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientApproverInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyApproverChannelFilter() const
    {
        return internalRequestProperty(QLatin1String("ApproverChannelFilter"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> AddDispatchOperation(const Tp::ChannelDetailsList& channels, const QDBusObjectPath& dispatchOperation, const QVariantMap& properties, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

class TP_QT_EXPORT ClientHandlerInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Client.Handler");
    }

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

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

    ClientHandlerInterface(Tp::DBusProxy *proxy);

    explicit ClientHandlerInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientHandlerInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyHandlerChannelFilter() const
    {
        return internalRequestProperty(QLatin1String("HandlerChannelFilter"));
    }

    inline Tp::PendingVariant *requestPropertyBypassApproval() const
    {
        return internalRequestProperty(QLatin1String("BypassApproval"));
    }

    inline Tp::PendingVariant *requestPropertyCapabilities() const
    {
        return internalRequestProperty(QLatin1String("Capabilities"));
    }

    inline Tp::PendingVariant *requestPropertyHandledChannels() const
    {
        return internalRequestProperty(QLatin1String("HandledChannels"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> HandleChannels(const QDBusObjectPath& account, const QDBusObjectPath& connection, const Tp::ChannelDetailsList& channels, const Tp::ObjectPathList& requestsSatisfied, qulonglong userActionTime, const QVariantMap& handlerInfo, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("HandleChannels"));
        callMessage << QVariant::fromValue(account) << QVariant::fromValue(connection) << QVariant::fromValue(channels) << QVariant::fromValue(requestsSatisfied) << QVariant::fromValue(userActionTime) << QVariant::fromValue(handlerInfo);
        return this->connection().asyncCall(callMessage, timeout);
    }

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

class TP_QT_EXPORT ClientInterfaceRequestsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

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

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

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

    ClientInterfaceRequestsInterface(Tp::DBusProxy *proxy);

    explicit ClientInterfaceRequestsInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientInterfaceRequestsInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

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

public Q_SLOTS:
    inline QDBusPendingReply<> AddRequest(const QDBusObjectPath& request, const QVariantMap& properties, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

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

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

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

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

class TP_QT_EXPORT ClientObserverInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline QLatin1String staticInterfaceName()
    {
        return QLatin1String("org.freedesktop.Telepathy.Client.Observer");
    }

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

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

    ClientObserverInterface(Tp::DBusProxy *proxy);

    explicit ClientObserverInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientObserverInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

    inline Tp::PendingVariant *requestPropertyObserverChannelFilter() const
    {
        return internalRequestProperty(QLatin1String("ObserverChannelFilter"));
    }

    inline Tp::PendingVariant *requestPropertyRecover() const
    {
        return internalRequestProperty(QLatin1String("Recover"));
    }

    inline Tp::PendingVariant *requestPropertyDelayApprovers() const
    {
        return internalRequestProperty(QLatin1String("DelayApprovers"));
    }

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

public Q_SLOTS:
    inline QDBusPendingReply<> ObserveChannels(const QDBusObjectPath& account, const QDBusObjectPath& connection, const Tp::ChannelDetailsList& channels, const QDBusObjectPath& dispatchOperation, const Tp::ObjectPathList& requestsSatisfied, const QVariantMap& observerInfo, int timeout = -1)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }

        QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
                this->staticInterfaceName(), QLatin1String("ObserveChannels"));
        callMessage << QVariant::fromValue(account) << QVariant::fromValue(connection) << QVariant::fromValue(channels) << QVariant::fromValue(dispatchOperation) << QVariant::fromValue(requestsSatisfied) << QVariant::fromValue(observerInfo);
        return this->connection().asyncCall(callMessage, timeout);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}
Q_DECLARE_METATYPE(Tp::Client::ClientInterface*)
Q_DECLARE_METATYPE(Tp::Client::ClientApproverInterface*)
Q_DECLARE_METATYPE(Tp::Client::ClientHandlerInterface*)
Q_DECLARE_METATYPE(Tp::Client::ClientInterfaceRequestsInterface*)
Q_DECLARE_METATYPE(Tp::Client::ClientObserverInterface*)