MeeGo 1.2 Harmattan Developer Documentation Develop for the Nokia N9
   Home · All Classes · All Namespaces · Modules · Functions · Files

cli-channel.h

00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
00003  *
00004  * This file can be distributed under the same terms as the specification from
00005  * which it was generated.
00006  */
00007 
00008 #ifndef IN_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011 
00012 #include <TelepathyQt4/Types>
00013 
00014 #include <QtGlobal>
00015 
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019 
00020 #include <QDBusPendingReply>
00021 
00022 #include <TelepathyQt4/AbstractInterface>
00023 #include <TelepathyQt4/DBusProxy>
00024 #include <TelepathyQt4/Global>
00025 
00026 namespace Tp
00027 {
00028 class PendingVariant;
00029 class PendingOperation;
00030 }
00031 
00032 namespace Tp
00033 {
00034 namespace Client
00035 {
00036 
00044 class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
00045 {
00046     Q_OBJECT
00047 
00048 public:
00055     static inline QLatin1String staticInterfaceName()
00056     {
00057         return QLatin1String("org.freedesktop.Telepathy.Channel");
00058     }
00059 
00067     ChannelInterface(
00068         const QString& busName,
00069         const QString& objectPath,
00070         QObject* parent = 0
00071     );
00072 
00081     ChannelInterface(
00082         const QDBusConnection& connection,
00083         const QString& busName,
00084         const QString& objectPath,
00085         QObject* parent = 0
00086     );
00087 
00094     ChannelInterface(Tp::DBusProxy *proxy);
00095 
00126     inline Tp::PendingVariant *requestPropertyChannelType() const
00127     {
00128         return internalRequestProperty(QLatin1String("ChannelType"));
00129     }
00130 
00164     inline Tp::PendingVariant *requestPropertyInterfaces() const
00165     {
00166         return internalRequestProperty(QLatin1String("Interfaces"));
00167     }
00168 
00213     inline Tp::PendingVariant *requestPropertyTargetHandle() const
00214     {
00215         return internalRequestProperty(QLatin1String("TargetHandle"));
00216     }
00217 
00271     inline Tp::PendingVariant *requestPropertyTargetID() const
00272     {
00273         return internalRequestProperty(QLatin1String("TargetID"));
00274     }
00275 
00295     inline Tp::PendingVariant *requestPropertyTargetHandleType() const
00296     {
00297         return internalRequestProperty(QLatin1String("TargetHandleType"));
00298     }
00299 
00368     inline Tp::PendingVariant *requestPropertyRequested() const
00369     {
00370         return internalRequestProperty(QLatin1String("Requested"));
00371     }
00372 
00434     inline Tp::PendingVariant *requestPropertyInitiatorHandle() const
00435     {
00436         return internalRequestProperty(QLatin1String("InitiatorHandle"));
00437     }
00438 
00473     inline Tp::PendingVariant *requestPropertyInitiatorID() const
00474     {
00475         return internalRequestProperty(QLatin1String("InitiatorID"));
00476     }
00477 
00484     Tp::PendingVariantMap *requestAllProperties() const
00485     {
00486         return internalRequestAllProperties();
00487     }
00488 
00489 public Q_SLOTS:
00504     inline QDBusPendingReply<> Close(int timeout = -1)
00505     {
00506         if (!invalidationReason().isEmpty()) {
00507             return QDBusPendingReply<>(QDBusMessage::createError(
00508                 invalidationReason(),
00509                 invalidationMessage()
00510             ));
00511         }
00512 
00513         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00514                 this->staticInterfaceName(), QLatin1String("Close"));
00515         return this->connection().asyncCall(callMessage, timeout);
00516     }
00517 
00535     inline QDBusPendingReply<QString> GetChannelType(int timeout = -1)
00536     {
00537         if (!invalidationReason().isEmpty()) {
00538             return QDBusPendingReply<QString>(QDBusMessage::createError(
00539                 invalidationReason(),
00540                 invalidationMessage()
00541             ));
00542         }
00543 
00544         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00545                 this->staticInterfaceName(), QLatin1String("GetChannelType"));
00546         return this->connection().asyncCall(callMessage, timeout);
00547     }
00548 
00572     inline QDBusPendingReply<uint, uint> GetHandle(int timeout = -1)
00573     {
00574         if (!invalidationReason().isEmpty()) {
00575             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00576                 invalidationReason(),
00577                 invalidationMessage()
00578             ));
00579         }
00580 
00581         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00582                 this->staticInterfaceName(), QLatin1String("GetHandle"));
00583         return this->connection().asyncCall(callMessage, timeout);
00584     }
00585 
00603     inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00604     {
00605         if (!invalidationReason().isEmpty()) {
00606             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00607                 invalidationReason(),
00608                 invalidationMessage()
00609             ));
00610         }
00611 
00612         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00613                 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00614         return this->connection().asyncCall(callMessage, timeout);
00615     }
00616 
00617 Q_SIGNALS:
00625     void Closed();
00626 
00627 protected:
00628     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00629 };
00630 
00638 class TELEPATHY_QT4_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
00639 {
00640     Q_OBJECT
00641 
00642 public:
00649     static inline QLatin1String staticInterfaceName()
00650     {
00651         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Anonymity");
00652     }
00653 
00661     ChannelInterfaceAnonymityInterface(
00662         const QString& busName,
00663         const QString& objectPath,
00664         QObject* parent = 0
00665     );
00666 
00675     ChannelInterfaceAnonymityInterface(
00676         const QDBusConnection& connection,
00677         const QString& busName,
00678         const QString& objectPath,
00679         QObject* parent = 0
00680     );
00681 
00688     ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00689 
00697     explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);
00698 
00706     ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00707 
00720     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
00721     {
00722         return internalRequestProperty(QLatin1String("AnonymityModes"));
00723     }
00724 
00735     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
00736     {
00737         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
00738     }
00739 
00761     inline Tp::PendingVariant *requestPropertyAnonymousID() const
00762     {
00763         return internalRequestProperty(QLatin1String("AnonymousID"));
00764     }
00765 
00772     Tp::PendingVariantMap *requestAllProperties() const
00773     {
00774         return internalRequestAllProperties();
00775     }
00776 
00777 protected:
00778     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00779 };
00780 
00788 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00789 {
00790     Q_OBJECT
00791 
00792 public:
00799     static inline QLatin1String staticInterfaceName()
00800     {
00801         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.CallState");
00802     }
00803 
00811     ChannelInterfaceCallStateInterface(
00812         const QString& busName,
00813         const QString& objectPath,
00814         QObject* parent = 0
00815     );
00816 
00825     ChannelInterfaceCallStateInterface(
00826         const QDBusConnection& connection,
00827         const QString& busName,
00828         const QString& objectPath,
00829         QObject* parent = 0
00830     );
00831 
00838     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00839 
00847     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00848 
00856     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00857 
00864     Tp::PendingVariantMap *requestAllProperties() const
00865     {
00866         return internalRequestAllProperties();
00867     }
00868 
00869 public Q_SLOTS:
00885     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates(int timeout = -1)
00886     {
00887         if (!invalidationReason().isEmpty()) {
00888             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00889                 invalidationReason(),
00890                 invalidationMessage()
00891             ));
00892         }
00893 
00894         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00895                 this->staticInterfaceName(), QLatin1String("GetCallStates"));
00896         return this->connection().asyncCall(callMessage, timeout);
00897     }
00898 
00899 Q_SIGNALS:
00913     void CallStateChanged(uint contact, uint state);
00914 
00915 protected:
00916     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00917 };
00918 
00926 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00927 {
00928     Q_OBJECT
00929 
00930 public:
00937     static inline QLatin1String staticInterfaceName()
00938     {
00939         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ChatState");
00940     }
00941 
00949     ChannelInterfaceChatStateInterface(
00950         const QString& busName,
00951         const QString& objectPath,
00952         QObject* parent = 0
00953     );
00954 
00963     ChannelInterfaceChatStateInterface(
00964         const QDBusConnection& connection,
00965         const QString& busName,
00966         const QString& objectPath,
00967         QObject* parent = 0
00968     );
00969 
00976     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00977 
00985     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00986 
00994     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00995 
01031     inline Tp::PendingVariant *requestPropertyChatStates() const
01032     {
01033         return internalRequestProperty(QLatin1String("ChatStates"));
01034     }
01035 
01042     Tp::PendingVariantMap *requestAllProperties() const
01043     {
01044         return internalRequestAllProperties();
01045     }
01046 
01047 public Q_SLOTS:
01063     inline QDBusPendingReply<> SetChatState(uint state, int timeout = -1)
01064     {
01065         if (!invalidationReason().isEmpty()) {
01066             return QDBusPendingReply<>(QDBusMessage::createError(
01067                 invalidationReason(),
01068                 invalidationMessage()
01069             ));
01070         }
01071 
01072         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01073                 this->staticInterfaceName(), QLatin1String("SetChatState"));
01074         callMessage << QVariant::fromValue(state);
01075         return this->connection().asyncCall(callMessage, timeout);
01076     }
01077 
01078 Q_SIGNALS:
01093     void ChatStateChanged(uint contact, uint state);
01094 
01095 protected:
01096     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01097 };
01098 
01106 class TELEPATHY_QT4_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
01107 {
01108     Q_OBJECT
01109 
01110 public:
01117     static inline QLatin1String staticInterfaceName()
01118     {
01119         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Conference");
01120     }
01121 
01129     ChannelInterfaceConferenceInterface(
01130         const QString& busName,
01131         const QString& objectPath,
01132         QObject* parent = 0
01133     );
01134 
01143     ChannelInterfaceConferenceInterface(
01144         const QDBusConnection& connection,
01145         const QString& busName,
01146         const QString& objectPath,
01147         QObject* parent = 0
01148     );
01149 
01156     ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
01157 
01165     explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
01166 
01174     ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01175 
01204     inline Tp::PendingVariant *requestPropertyChannels() const
01205     {
01206         return internalRequestProperty(QLatin1String("Channels"));
01207     }
01208 
01270     inline Tp::PendingVariant *requestPropertyInitialChannels() const
01271     {
01272         return internalRequestProperty(QLatin1String("InitialChannels"));
01273     }
01274 
01348     inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
01349     {
01350         return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
01351     }
01352 
01377     inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
01378     {
01379         return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
01380     }
01381 
01409     inline Tp::PendingVariant *requestPropertyInvitationMessage() const
01410     {
01411         return internalRequestProperty(QLatin1String("InvitationMessage"));
01412     }
01413 
01479     inline Tp::PendingVariant *requestPropertyOriginalChannels() const
01480     {
01481         return internalRequestProperty(QLatin1String("OriginalChannels"));
01482     }
01483 
01490     Tp::PendingVariantMap *requestAllProperties() const
01491     {
01492         return internalRequestAllProperties();
01493     }
01494 
01495 Q_SIGNALS:
01519     void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01520 
01545     void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01546 
01547 protected:
01548     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01549 };
01550 
01558 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01559 {
01560     Q_OBJECT
01561 
01562 public:
01569     static inline QLatin1String staticInterfaceName()
01570     {
01571         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
01572     }
01573 
01581     ChannelInterfaceDTMFInterface(
01582         const QString& busName,
01583         const QString& objectPath,
01584         QObject* parent = 0
01585     );
01586 
01595     ChannelInterfaceDTMFInterface(
01596         const QDBusConnection& connection,
01597         const QString& busName,
01598         const QString& objectPath,
01599         QObject* parent = 0
01600     );
01601 
01608     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
01609 
01617     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
01618 
01626     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01627 
01639     inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
01640     {
01641         return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
01642     }
01643 
01656     inline Tp::PendingVariant *requestPropertyInitialTones() const
01657     {
01658         return internalRequestProperty(QLatin1String("InitialTones"));
01659     }
01660 
01678     inline Tp::PendingVariant *requestPropertyDeferredTones() const
01679     {
01680         return internalRequestProperty(QLatin1String("DeferredTones"));
01681     }
01682 
01689     Tp::PendingVariantMap *requestAllProperties() const
01690     {
01691         return internalRequestAllProperties();
01692     }
01693 
01694 public Q_SLOTS:
01725     inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
01726     {
01727         if (!invalidationReason().isEmpty()) {
01728             return QDBusPendingReply<>(QDBusMessage::createError(
01729                 invalidationReason(),
01730                 invalidationMessage()
01731             ));
01732         }
01733 
01734         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01735                 this->staticInterfaceName(), QLatin1String("StartTone"));
01736         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01737         return this->connection().asyncCall(callMessage, timeout);
01738     }
01739 
01762     inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
01763     {
01764         if (!invalidationReason().isEmpty()) {
01765             return QDBusPendingReply<>(QDBusMessage::createError(
01766                 invalidationReason(),
01767                 invalidationMessage()
01768             ));
01769         }
01770 
01771         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01772                 this->staticInterfaceName(), QLatin1String("StopTone"));
01773         callMessage << QVariant::fromValue(streamID);
01774         return this->connection().asyncCall(callMessage, timeout);
01775     }
01776 
01822     inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
01823     {
01824         if (!invalidationReason().isEmpty()) {
01825             return QDBusPendingReply<>(QDBusMessage::createError(
01826                 invalidationReason(),
01827                 invalidationMessage()
01828             ));
01829         }
01830 
01831         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01832                 this->staticInterfaceName(), QLatin1String("MultipleTones"));
01833         callMessage << QVariant::fromValue(tones);
01834         return this->connection().asyncCall(callMessage, timeout);
01835     }
01836 
01837 Q_SIGNALS:
01865     void TonesDeferred(const QString& tones);
01866 
01883     void SendingTones(const QString& tones);
01884 
01896     void StoppedTones(bool cancelled);
01897 
01898 protected:
01899     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01900 };
01901 
01909 class TELEPATHY_QT4_EXPORT ChannelInterfaceDestroyableInterface : public Tp::AbstractInterface
01910 {
01911     Q_OBJECT
01912 
01913 public:
01920     static inline QLatin1String staticInterfaceName()
01921     {
01922         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Destroyable");
01923     }
01924 
01932     ChannelInterfaceDestroyableInterface(
01933         const QString& busName,
01934         const QString& objectPath,
01935         QObject* parent = 0
01936     );
01937 
01946     ChannelInterfaceDestroyableInterface(
01947         const QDBusConnection& connection,
01948         const QString& busName,
01949         const QString& objectPath,
01950         QObject* parent = 0
01951     );
01952 
01959     ChannelInterfaceDestroyableInterface(Tp::DBusProxy *proxy);
01960 
01968     explicit ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface);
01969 
01977     ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01978 
01985     Tp::PendingVariantMap *requestAllProperties() const
01986     {
01987         return internalRequestAllProperties();
01988     }
01989 
01990 public Q_SLOTS:
02035     inline QDBusPendingReply<> Destroy(int timeout = -1)
02036     {
02037         if (!invalidationReason().isEmpty()) {
02038             return QDBusPendingReply<>(QDBusMessage::createError(
02039                 invalidationReason(),
02040                 invalidationMessage()
02041             ));
02042         }
02043 
02044         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02045                 this->staticInterfaceName(), QLatin1String("Destroy"));
02046         return this->connection().asyncCall(callMessage, timeout);
02047     }
02048 
02049 protected:
02050     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02051 };
02052 
02060 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
02061 {
02062     Q_OBJECT
02063 
02064 public:
02071     static inline QLatin1String staticInterfaceName()
02072     {
02073         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
02074     }
02075 
02083     ChannelInterfaceGroupInterface(
02084         const QString& busName,
02085         const QString& objectPath,
02086         QObject* parent = 0
02087     );
02088 
02097     ChannelInterfaceGroupInterface(
02098         const QDBusConnection& connection,
02099         const QString& busName,
02100         const QString& objectPath,
02101         QObject* parent = 0
02102     );
02103 
02110     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
02111 
02119     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
02120 
02128     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02129 
02142     inline Tp::PendingVariant *requestPropertyGroupFlags() const
02143     {
02144         return internalRequestProperty(QLatin1String("GroupFlags"));
02145     }
02146 
02162     inline Tp::PendingVariant *requestPropertyHandleOwners() const
02163     {
02164         return internalRequestProperty(QLatin1String("HandleOwners"));
02165     }
02166 
02177     inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
02178     {
02179         return internalRequestProperty(QLatin1String("LocalPendingMembers"));
02180     }
02181 
02191     inline Tp::PendingVariant *requestPropertyMembers() const
02192     {
02193         return internalRequestProperty(QLatin1String("Members"));
02194     }
02195 
02206     inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
02207     {
02208         return internalRequestProperty(QLatin1String("RemotePendingMembers"));
02209     }
02210 
02225     inline Tp::PendingVariant *requestPropertySelfHandle() const
02226     {
02227         return internalRequestProperty(QLatin1String("SelfHandle"));
02228     }
02229 
02236     Tp::PendingVariantMap *requestAllProperties() const
02237     {
02238         return internalRequestAllProperties();
02239     }
02240 
02241 public Q_SLOTS:
02272     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02273     {
02274         if (!invalidationReason().isEmpty()) {
02275             return QDBusPendingReply<>(QDBusMessage::createError(
02276                 invalidationReason(),
02277                 invalidationMessage()
02278             ));
02279         }
02280 
02281         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02282                 this->staticInterfaceName(), QLatin1String("AddMembers"));
02283         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02284         return this->connection().asyncCall(callMessage, timeout);
02285     }
02286 
02309     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
02310     {
02311         if (!invalidationReason().isEmpty()) {
02312             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02313                 invalidationReason(),
02314                 invalidationMessage()
02315             ));
02316         }
02317 
02318         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02319                 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
02320         return this->connection().asyncCall(callMessage, timeout);
02321     }
02322 
02337     inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
02338     {
02339         if (!invalidationReason().isEmpty()) {
02340             return QDBusPendingReply<uint>(QDBusMessage::createError(
02341                 invalidationReason(),
02342                 invalidationMessage()
02343             ));
02344         }
02345 
02346         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02347                 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
02348         return this->connection().asyncCall(callMessage, timeout);
02349     }
02350 
02376     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
02377     {
02378         if (!invalidationReason().isEmpty()) {
02379             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02380                 invalidationReason(),
02381                 invalidationMessage()
02382             ));
02383         }
02384 
02385         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02386                 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
02387         callMessage << QVariant::fromValue(handles);
02388         return this->connection().asyncCall(callMessage, timeout);
02389     }
02390 
02402     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
02403     {
02404         if (!invalidationReason().isEmpty()) {
02405             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02406                 invalidationReason(),
02407                 invalidationMessage()
02408             ));
02409         }
02410 
02411         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02412                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
02413         return this->connection().asyncCall(callMessage, timeout);
02414     }
02415 
02434     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
02435     {
02436         if (!invalidationReason().isEmpty()) {
02437             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
02438                 invalidationReason(),
02439                 invalidationMessage()
02440             ));
02441         }
02442 
02443         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02444                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
02445         return this->connection().asyncCall(callMessage, timeout);
02446     }
02447 
02458     inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
02459     {
02460         if (!invalidationReason().isEmpty()) {
02461             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02462                 invalidationReason(),
02463                 invalidationMessage()
02464             ));
02465         }
02466 
02467         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02468                 this->staticInterfaceName(), QLatin1String("GetMembers"));
02469         return this->connection().asyncCall(callMessage, timeout);
02470     }
02471 
02483     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
02484     {
02485         if (!invalidationReason().isEmpty()) {
02486             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02487                 invalidationReason(),
02488                 invalidationMessage()
02489             ));
02490         }
02491 
02492         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02493                 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
02494         return this->connection().asyncCall(callMessage, timeout);
02495     }
02496 
02507     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
02508     {
02509         if (!invalidationReason().isEmpty()) {
02510             return QDBusPendingReply<uint>(QDBusMessage::createError(
02511                 invalidationReason(),
02512                 invalidationMessage()
02513             ));
02514         }
02515 
02516         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02517                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
02518         return this->connection().asyncCall(callMessage, timeout);
02519     }
02520 
02576     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
02577     {
02578         if (!invalidationReason().isEmpty()) {
02579             return QDBusPendingReply<>(QDBusMessage::createError(
02580                 invalidationReason(),
02581                 invalidationMessage()
02582             ));
02583         }
02584 
02585         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02586                 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
02587         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02588         return this->connection().asyncCall(callMessage, timeout);
02589     }
02590 
02615     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
02616     {
02617         if (!invalidationReason().isEmpty()) {
02618             return QDBusPendingReply<>(QDBusMessage::createError(
02619                 invalidationReason(),
02620                 invalidationMessage()
02621             ));
02622         }
02623 
02624         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02625                 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
02626         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
02627         return this->connection().asyncCall(callMessage, timeout);
02628     }
02629 
02630 Q_SIGNALS:
02649     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
02650 
02660     void SelfHandleChanged(uint selfHandle);
02661 
02676     void GroupFlagsChanged(uint added, uint removed);
02677 
02731     void MembersChanged(const QString& message, const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, uint actor, uint reason);
02732 
02841     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
02842 
02843 protected:
02844     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02845 };
02846 
02854 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
02855 {
02856     Q_OBJECT
02857 
02858 public:
02865     static inline QLatin1String staticInterfaceName()
02866     {
02867         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
02868     }
02869 
02877     ChannelInterfaceHoldInterface(
02878         const QString& busName,
02879         const QString& objectPath,
02880         QObject* parent = 0
02881     );
02882 
02891     ChannelInterfaceHoldInterface(
02892         const QDBusConnection& connection,
02893         const QString& busName,
02894         const QString& objectPath,
02895         QObject* parent = 0
02896     );
02897 
02904     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
02905 
02913     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
02914 
02922     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02923 
02930     Tp::PendingVariantMap *requestAllProperties() const
02931     {
02932         return internalRequestAllProperties();
02933     }
02934 
02935 public Q_SLOTS:
02954     inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
02955     {
02956         if (!invalidationReason().isEmpty()) {
02957             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
02958                 invalidationReason(),
02959                 invalidationMessage()
02960             ));
02961         }
02962 
02963         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02964                 this->staticInterfaceName(), QLatin1String("GetHoldState"));
02965         return this->connection().asyncCall(callMessage, timeout);
02966     }
02967 
03031     inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
03032     {
03033         if (!invalidationReason().isEmpty()) {
03034             return QDBusPendingReply<>(QDBusMessage::createError(
03035                 invalidationReason(),
03036                 invalidationMessage()
03037             ));
03038         }
03039 
03040         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03041                 this->staticInterfaceName(), QLatin1String("RequestHold"));
03042         callMessage << QVariant::fromValue(hold);
03043         return this->connection().asyncCall(callMessage, timeout);
03044     }
03045 
03046 Q_SIGNALS:
03063     void HoldStateChanged(uint holdState, uint reason);
03064 
03065 protected:
03066     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03067 };
03068 
03076 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
03077 {
03078     Q_OBJECT
03079 
03080 public:
03087     static inline QLatin1String staticInterfaceName()
03088     {
03089         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
03090     }
03091 
03099     ChannelInterfaceMediaSignallingInterface(
03100         const QString& busName,
03101         const QString& objectPath,
03102         QObject* parent = 0
03103     );
03104 
03113     ChannelInterfaceMediaSignallingInterface(
03114         const QDBusConnection& connection,
03115         const QString& busName,
03116         const QString& objectPath,
03117         QObject* parent = 0
03118     );
03119 
03126     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
03127 
03135     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
03136 
03144     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03145 
03152     Tp::PendingVariantMap *requestAllProperties() const
03153     {
03154         return internalRequestAllProperties();
03155     }
03156 
03157 public Q_SLOTS:
03169     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
03170     {
03171         if (!invalidationReason().isEmpty()) {
03172             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
03173                 invalidationReason(),
03174                 invalidationMessage()
03175             ));
03176         }
03177 
03178         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03179                 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
03180         return this->connection().asyncCall(callMessage, timeout);
03181     }
03182 
03183 Q_SIGNALS:
03199     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
03200 
03201 protected:
03202     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03203 };
03204 
03212 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
03213 {
03214     Q_OBJECT
03215 
03216 public:
03223     static inline QLatin1String staticInterfaceName()
03224     {
03225         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
03226     }
03227 
03235     ChannelInterfaceMessagesInterface(
03236         const QString& busName,
03237         const QString& objectPath,
03238         QObject* parent = 0
03239     );
03240 
03249     ChannelInterfaceMessagesInterface(
03250         const QDBusConnection& connection,
03251         const QString& busName,
03252         const QString& objectPath,
03253         QObject* parent = 0
03254     );
03255 
03262     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
03263 
03271     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
03272 
03280     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03281 
03335     inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
03336     {
03337         return internalRequestProperty(QLatin1String("SupportedContentTypes"));
03338     }
03339 
03351     inline Tp::PendingVariant *requestPropertyMessageTypes() const
03352     {
03353         return internalRequestProperty(QLatin1String("MessageTypes"));
03354     }
03355 
03365     inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
03366     {
03367         return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
03368     }
03369 
03390     inline Tp::PendingVariant *requestPropertyPendingMessages() const
03391     {
03392         return internalRequestProperty(QLatin1String("PendingMessages"));
03393     }
03394 
03404     inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
03405     {
03406         return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
03407     }
03408 
03415     Tp::PendingVariantMap *requestAllProperties() const
03416     {
03417         return internalRequestAllProperties();
03418     }
03419 
03420 public Q_SLOTS:
03483     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
03484     {
03485         if (!invalidationReason().isEmpty()) {
03486             return QDBusPendingReply<QString>(QDBusMessage::createError(
03487                 invalidationReason(),
03488                 invalidationMessage()
03489             ));
03490         }
03491 
03492         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03493                 this->staticInterfaceName(), QLatin1String("SendMessage"));
03494         callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
03495         return this->connection().asyncCall(callMessage, timeout);
03496     }
03497 
03538     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
03539     {
03540         if (!invalidationReason().isEmpty()) {
03541             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
03542                 invalidationReason(),
03543                 invalidationMessage()
03544             ));
03545         }
03546 
03547         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03548                 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
03549         callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
03550         return this->connection().asyncCall(callMessage, timeout);
03551     }
03552 
03553 Q_SIGNALS:
03613     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
03614 
03628     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
03629 
03650     void MessageReceived(const Tp::MessagePartList& message);
03651 
03652 protected:
03653     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03654 };
03655 
03663 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
03664 {
03665     Q_OBJECT
03666 
03667 public:
03674     static inline QLatin1String staticInterfaceName()
03675     {
03676         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
03677     }
03678 
03686     ChannelInterfacePasswordInterface(
03687         const QString& busName,
03688         const QString& objectPath,
03689         QObject* parent = 0
03690     );
03691 
03700     ChannelInterfacePasswordInterface(
03701         const QDBusConnection& connection,
03702         const QString& busName,
03703         const QString& objectPath,
03704         QObject* parent = 0
03705     );
03706 
03713     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
03714 
03722     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
03723 
03731     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03732 
03739     Tp::PendingVariantMap *requestAllProperties() const
03740     {
03741         return internalRequestAllProperties();
03742     }
03743 
03744 public Q_SLOTS:
03762     inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
03763     {
03764         if (!invalidationReason().isEmpty()) {
03765             return QDBusPendingReply<uint>(QDBusMessage::createError(
03766                 invalidationReason(),
03767                 invalidationMessage()
03768             ));
03769         }
03770 
03771         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03772                 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
03773         return this->connection().asyncCall(callMessage, timeout);
03774     }
03775 
03796     inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
03797     {
03798         if (!invalidationReason().isEmpty()) {
03799             return QDBusPendingReply<bool>(QDBusMessage::createError(
03800                 invalidationReason(),
03801                 invalidationMessage()
03802             ));
03803         }
03804 
03805         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03806                 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
03807         callMessage << QVariant::fromValue(password);
03808         return this->connection().asyncCall(callMessage, timeout);
03809     }
03810 
03811 Q_SIGNALS:
03826     void PasswordFlagsChanged(uint added, uint removed);
03827 
03828 protected:
03829     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03830 };
03831 
03839 class TELEPATHY_QT4_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
03840 {
03841     Q_OBJECT
03842 
03843 public:
03850     static inline QLatin1String staticInterfaceName()
03851     {
03852         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
03853     }
03854 
03862     ChannelInterfaceSASLAuthenticationInterface(
03863         const QString& busName,
03864         const QString& objectPath,
03865         QObject* parent = 0
03866     );
03867 
03876     ChannelInterfaceSASLAuthenticationInterface(
03877         const QDBusConnection& connection,
03878         const QString& busName,
03879         const QString& objectPath,
03880         QObject* parent = 0
03881     );
03882 
03889     ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
03890 
03898     explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
03899 
03907     ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03908 
03931     inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
03932     {
03933         return internalRequestProperty(QLatin1String("AvailableMechanisms"));
03934     }
03935 
03957     inline Tp::PendingVariant *requestPropertyHasInitialData() const
03958     {
03959         return internalRequestProperty(QLatin1String("HasInitialData"));
03960     }
03961 
03982     inline Tp::PendingVariant *requestPropertyCanTryAgain() const
03983     {
03984         return internalRequestProperty(QLatin1String("CanTryAgain"));
03985     }
03986 
04000     inline Tp::PendingVariant *requestPropertySASLStatus() const
04001     {
04002         return internalRequestProperty(QLatin1String("SASLStatus"));
04003     }
04004 
04033     inline Tp::PendingVariant *requestPropertySASLError() const
04034     {
04035         return internalRequestProperty(QLatin1String("SASLError"));
04036     }
04037 
04059     inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
04060     {
04061         return internalRequestProperty(QLatin1String("SASLErrorDetails"));
04062     }
04063 
04128     inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
04129     {
04130         return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
04131     }
04132 
04194     inline Tp::PendingVariant *requestPropertyDefaultUsername() const
04195     {
04196         return internalRequestProperty(QLatin1String("DefaultUsername"));
04197     }
04198 
04226     inline Tp::PendingVariant *requestPropertyDefaultRealm() const
04227     {
04228         return internalRequestProperty(QLatin1String("DefaultRealm"));
04229     }
04230 
04252     inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
04253     {
04254         return internalRequestProperty(QLatin1String("MaySaveResponse"));
04255     }
04256 
04263     Tp::PendingVariantMap *requestAllProperties() const
04264     {
04265         return internalRequestAllProperties();
04266     }
04267 
04268 public Q_SLOTS:
04295     inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
04296     {
04297         if (!invalidationReason().isEmpty()) {
04298             return QDBusPendingReply<>(QDBusMessage::createError(
04299                 invalidationReason(),
04300                 invalidationMessage()
04301             ));
04302         }
04303 
04304         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04305                 this->staticInterfaceName(), QLatin1String("StartMechanism"));
04306         callMessage << QVariant::fromValue(mechanism);
04307         return this->connection().asyncCall(callMessage, timeout);
04308     }
04309 
04364     inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
04365     {
04366         if (!invalidationReason().isEmpty()) {
04367             return QDBusPendingReply<>(QDBusMessage::createError(
04368                 invalidationReason(),
04369                 invalidationMessage()
04370             ));
04371         }
04372 
04373         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04374                 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
04375         callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
04376         return this->connection().asyncCall(callMessage, timeout);
04377     }
04378 
04396     inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
04397     {
04398         if (!invalidationReason().isEmpty()) {
04399             return QDBusPendingReply<>(QDBusMessage::createError(
04400                 invalidationReason(),
04401                 invalidationMessage()
04402             ));
04403         }
04404 
04405         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04406                 this->staticInterfaceName(), QLatin1String("Respond"));
04407         callMessage << QVariant::fromValue(responseData);
04408         return this->connection().asyncCall(callMessage, timeout);
04409     }
04410 
04439     inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
04440     {
04441         if (!invalidationReason().isEmpty()) {
04442             return QDBusPendingReply<>(QDBusMessage::createError(
04443                 invalidationReason(),
04444                 invalidationMessage()
04445             ));
04446         }
04447 
04448         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04449                 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
04450         return this->connection().asyncCall(callMessage, timeout);
04451     }
04452 
04481     inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
04482     {
04483         if (!invalidationReason().isEmpty()) {
04484             return QDBusPendingReply<>(QDBusMessage::createError(
04485                 invalidationReason(),
04486                 invalidationMessage()
04487             ));
04488         }
04489 
04490         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04491                 this->staticInterfaceName(), QLatin1String("AbortSASL"));
04492         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
04493         return this->connection().asyncCall(callMessage, timeout);
04494     }
04495 
04496 Q_SIGNALS:
04514     void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
04515 
04535     void NewChallenge(const QByteArray& challengeData);
04536 
04537 protected:
04538     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04539 };
04540 
04548 class TELEPATHY_QT4_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
04549 {
04550     Q_OBJECT
04551 
04552 public:
04559     static inline QLatin1String staticInterfaceName()
04560     {
04561         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
04562     }
04563 
04571     ChannelInterfaceSecurableInterface(
04572         const QString& busName,
04573         const QString& objectPath,
04574         QObject* parent = 0
04575     );
04576 
04585     ChannelInterfaceSecurableInterface(
04586         const QDBusConnection& connection,
04587         const QString& busName,
04588         const QString& objectPath,
04589         QObject* parent = 0
04590     );
04591 
04598     ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
04599 
04607     explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
04608 
04616     ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04617 
04639     inline Tp::PendingVariant *requestPropertyEncrypted() const
04640     {
04641         return internalRequestProperty(QLatin1String("Encrypted"));
04642     }
04643 
04660     inline Tp::PendingVariant *requestPropertyVerified() const
04661     {
04662         return internalRequestProperty(QLatin1String("Verified"));
04663     }
04664 
04671     Tp::PendingVariantMap *requestAllProperties() const
04672     {
04673         return internalRequestAllProperties();
04674     }
04675 
04676 protected:
04677     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04678 };
04679 
04687 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
04688 {
04689     Q_OBJECT
04690 
04691 public:
04698     static inline QLatin1String staticInterfaceName()
04699     {
04700         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
04701     }
04702 
04710     ChannelInterfaceServicePointInterface(
04711         const QString& busName,
04712         const QString& objectPath,
04713         QObject* parent = 0
04714     );
04715 
04724     ChannelInterfaceServicePointInterface(
04725         const QDBusConnection& connection,
04726         const QString& busName,
04727         const QString& objectPath,
04728         QObject* parent = 0
04729     );
04730 
04737     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
04738 
04746     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
04747 
04755     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04756 
04776     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
04777     {
04778         return internalRequestProperty(QLatin1String("InitialServicePoint"));
04779     }
04780 
04793     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
04794     {
04795         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
04796     }
04797 
04804     Tp::PendingVariantMap *requestAllProperties() const
04805     {
04806         return internalRequestAllProperties();
04807     }
04808 
04809 Q_SIGNALS:
04826     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
04827 
04828 protected:
04829     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04830 };
04831 
04839 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
04840 {
04841     Q_OBJECT
04842 
04843 public:
04850     static inline QLatin1String staticInterfaceName()
04851     {
04852         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
04853     }
04854 
04862     ChannelInterfaceTubeInterface(
04863         const QString& busName,
04864         const QString& objectPath,
04865         QObject* parent = 0
04866     );
04867 
04876     ChannelInterfaceTubeInterface(
04877         const QDBusConnection& connection,
04878         const QString& busName,
04879         const QString& objectPath,
04880         QObject* parent = 0
04881     );
04882 
04889     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
04890 
04898     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
04899 
04907     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04908 
04954     inline Tp::PendingVariant *requestPropertyParameters() const
04955     {
04956         return internalRequestProperty(QLatin1String("Parameters"));
04957     }
04958 
04974     inline Tp::PendingVariant *requestPropertyState() const
04975     {
04976         return internalRequestProperty(QLatin1String("State"));
04977     }
04978 
04985     Tp::PendingVariantMap *requestAllProperties() const
04986     {
04987         return internalRequestAllProperties();
04988     }
04989 
04990 Q_SIGNALS:
05001     void TubeChannelStateChanged(uint state);
05002 
05003 protected:
05004     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05005 };
05006 
05014 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
05015 {
05016     Q_OBJECT
05017 
05018 public:
05025     static inline QLatin1String staticInterfaceName()
05026     {
05027         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
05028     }
05029 
05037     ChannelTypeContactListInterface(
05038         const QString& busName,
05039         const QString& objectPath,
05040         QObject* parent = 0
05041     );
05042 
05051     ChannelTypeContactListInterface(
05052         const QDBusConnection& connection,
05053         const QString& busName,
05054         const QString& objectPath,
05055         QObject* parent = 0
05056     );
05057 
05064     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
05065 
05073     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
05074 
05082     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05083 
05090     Tp::PendingVariantMap *requestAllProperties() const
05091     {
05092         return internalRequestAllProperties();
05093     }
05094 
05095 protected:
05096     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05097 };
05098 
05106 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
05107 {
05108     Q_OBJECT
05109 
05110 public:
05117     static inline QLatin1String staticInterfaceName()
05118     {
05119         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
05120     }
05121 
05129     ChannelTypeContactSearchInterface(
05130         const QString& busName,
05131         const QString& objectPath,
05132         QObject* parent = 0
05133     );
05134 
05143     ChannelTypeContactSearchInterface(
05144         const QDBusConnection& connection,
05145         const QString& busName,
05146         const QString& objectPath,
05147         QObject* parent = 0
05148     );
05149 
05156     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
05157 
05165     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
05166 
05174     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05175 
05186     inline Tp::PendingVariant *requestPropertySearchState() const
05187     {
05188         return internalRequestProperty(QLatin1String("SearchState"));
05189     }
05190 
05216     inline Tp::PendingVariant *requestPropertyLimit() const
05217     {
05218         return internalRequestProperty(QLatin1String("Limit"));
05219     }
05220 
05235     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
05236     {
05237         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
05238     }
05239 
05260     inline Tp::PendingVariant *requestPropertyServer() const
05261     {
05262         return internalRequestProperty(QLatin1String("Server"));
05263     }
05264 
05271     Tp::PendingVariantMap *requestAllProperties() const
05272     {
05273         return internalRequestAllProperties();
05274     }
05275 
05276 public Q_SLOTS:
05294     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
05295     {
05296         if (!invalidationReason().isEmpty()) {
05297             return QDBusPendingReply<>(QDBusMessage::createError(
05298                 invalidationReason(),
05299                 invalidationMessage()
05300             ));
05301         }
05302 
05303         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05304                 this->staticInterfaceName(), QLatin1String("Search"));
05305         callMessage << QVariant::fromValue(terms);
05306         return this->connection().asyncCall(callMessage, timeout);
05307     }
05308 
05323     inline QDBusPendingReply<> More(int timeout = -1)
05324     {
05325         if (!invalidationReason().isEmpty()) {
05326             return QDBusPendingReply<>(QDBusMessage::createError(
05327                 invalidationReason(),
05328                 invalidationMessage()
05329             ));
05330         }
05331 
05332         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05333                 this->staticInterfaceName(), QLatin1String("More"));
05334         return this->connection().asyncCall(callMessage, timeout);
05335     }
05336 
05369     inline QDBusPendingReply<> Stop(int timeout = -1)
05370     {
05371         if (!invalidationReason().isEmpty()) {
05372             return QDBusPendingReply<>(QDBusMessage::createError(
05373                 invalidationReason(),
05374                 invalidationMessage()
05375             ));
05376         }
05377 
05378         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05379                 this->staticInterfaceName(), QLatin1String("Stop"));
05380         return this->connection().asyncCall(callMessage, timeout);
05381     }
05382 
05383 Q_SIGNALS:
05433     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
05434 
05447     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
05448 
05449 protected:
05450     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05451 };
05452 
05460 class TELEPATHY_QT4_EXPORT ChannelTypeDBusTubeInterface : public Tp::AbstractInterface
05461 {
05462     Q_OBJECT
05463 
05464 public:
05471     static inline QLatin1String staticInterfaceName()
05472     {
05473         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.DBusTube");
05474     }
05475 
05483     ChannelTypeDBusTubeInterface(
05484         const QString& busName,
05485         const QString& objectPath,
05486         QObject* parent = 0
05487     );
05488 
05497     ChannelTypeDBusTubeInterface(
05498         const QDBusConnection& connection,
05499         const QString& busName,
05500         const QString& objectPath,
05501         QObject* parent = 0
05502     );
05503 
05510     ChannelTypeDBusTubeInterface(Tp::DBusProxy *proxy);
05511 
05519     explicit ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
05520 
05528     ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05529 
05548     inline Tp::PendingVariant *requestPropertyServiceName() const
05549     {
05550         return internalRequestProperty(QLatin1String("ServiceName"));
05551     }
05552 
05565     inline Tp::PendingVariant *requestPropertyDBusNames() const
05566     {
05567         return internalRequestProperty(QLatin1String("DBusNames"));
05568     }
05569 
05587     inline Tp::PendingVariant *requestPropertySupportedAccessControls() const
05588     {
05589         return internalRequestProperty(QLatin1String("SupportedAccessControls"));
05590     }
05591 
05598     Tp::PendingVariantMap *requestAllProperties() const
05599     {
05600         return internalRequestAllProperties();
05601     }
05602 
05603 public Q_SLOTS:
05628     inline QDBusPendingReply<QString> Offer(const QVariantMap& parameters, uint accesscontrol, int timeout = -1)
05629     {
05630         if (!invalidationReason().isEmpty()) {
05631             return QDBusPendingReply<QString>(QDBusMessage::createError(
05632                 invalidationReason(),
05633                 invalidationMessage()
05634             ));
05635         }
05636 
05637         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05638                 this->staticInterfaceName(), QLatin1String("Offer"));
05639         callMessage << QVariant::fromValue(parameters) << QVariant::fromValue(accesscontrol);
05640         return this->connection().asyncCall(callMessage, timeout);
05641     }
05642 
05666     inline QDBusPendingReply<QString> Accept(uint accesscontrol, int timeout = -1)
05667     {
05668         if (!invalidationReason().isEmpty()) {
05669             return QDBusPendingReply<QString>(QDBusMessage::createError(
05670                 invalidationReason(),
05671                 invalidationMessage()
05672             ));
05673         }
05674 
05675         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05676                 this->staticInterfaceName(), QLatin1String("Accept"));
05677         callMessage << QVariant::fromValue(accesscontrol);
05678         return this->connection().asyncCall(callMessage, timeout);
05679     }
05680 
05681 Q_SIGNALS:
05697     void DBusNamesChanged(const Tp::DBusTubeParticipants& added, const Tp::UIntList& removed);
05698 
05699 protected:
05700     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05701 };
05702 
05710 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
05711 {
05712     Q_OBJECT
05713 
05714 public:
05721     static inline QLatin1String staticInterfaceName()
05722     {
05723         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
05724     }
05725 
05733     ChannelTypeFileTransferInterface(
05734         const QString& busName,
05735         const QString& objectPath,
05736         QObject* parent = 0
05737     );
05738 
05747     ChannelTypeFileTransferInterface(
05748         const QDBusConnection& connection,
05749         const QString& busName,
05750         const QString& objectPath,
05751         QObject* parent = 0
05752     );
05753 
05760     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
05761 
05769     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
05770 
05778     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05779 
05792     inline Tp::PendingVariant *requestPropertyState() const
05793     {
05794         return internalRequestProperty(QLatin1String("State"));
05795     }
05796 
05814     inline Tp::PendingVariant *requestPropertyContentType() const
05815     {
05816         return internalRequestProperty(QLatin1String("ContentType"));
05817     }
05818 
05840     inline Tp::PendingVariant *requestPropertyFilename() const
05841     {
05842         return internalRequestProperty(QLatin1String("Filename"));
05843     }
05844 
05868     inline Tp::PendingVariant *requestPropertySize() const
05869     {
05870         return internalRequestProperty(QLatin1String("Size"));
05871     }
05872 
05899     inline Tp::PendingVariant *requestPropertyContentHashType() const
05900     {
05901         return internalRequestProperty(QLatin1String("ContentHashType"));
05902     }
05903 
05924     inline Tp::PendingVariant *requestPropertyContentHash() const
05925     {
05926         return internalRequestProperty(QLatin1String("ContentHash"));
05927     }
05928 
05946     inline Tp::PendingVariant *requestPropertyDescription() const
05947     {
05948         return internalRequestProperty(QLatin1String("Description"));
05949     }
05950 
05967     inline Tp::PendingVariant *requestPropertyDate() const
05968     {
05969         return internalRequestProperty(QLatin1String("Date"));
05970     }
05971 
06000     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
06001     {
06002         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
06003     }
06004 
06018     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
06019     {
06020         return internalRequestProperty(QLatin1String("TransferredBytes"));
06021     }
06022 
06045     inline Tp::PendingVariant *requestPropertyInitialOffset() const
06046     {
06047         return internalRequestProperty(QLatin1String("InitialOffset"));
06048     }
06049 
06084     inline Tp::PendingVariant *requestPropertyURI() const
06085     {
06086         return internalRequestProperty(QLatin1String("URI"));
06087     }
06088 
06123     inline Tp::PendingOperation *setPropertyURI(QString newValue)
06124     {
06125         return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
06126     }
06127 
06134     Tp::PendingVariantMap *requestAllProperties() const
06135     {
06136         return internalRequestAllProperties();
06137     }
06138 
06139 public Q_SLOTS:
06184     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
06185     {
06186         if (!invalidationReason().isEmpty()) {
06187             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06188                 invalidationReason(),
06189                 invalidationMessage()
06190             ));
06191         }
06192 
06193         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06194                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
06195         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
06196         return this->connection().asyncCall(callMessage, timeout);
06197     }
06198 
06232     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
06233     {
06234         if (!invalidationReason().isEmpty()) {
06235             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06236                 invalidationReason(),
06237                 invalidationMessage()
06238             ));
06239         }
06240 
06241         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06242                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
06243         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
06244         return this->connection().asyncCall(callMessage, timeout);
06245     }
06246 
06247 Q_SIGNALS:
06265     void FileTransferStateChanged(uint state, uint reason);
06266 
06279     void TransferredBytesChanged(qulonglong count);
06280 
06292     void InitialOffsetDefined(qulonglong initialOffset);
06293 
06305     void URIDefined(const QString& URI);
06306 
06307 protected:
06308     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06309 };
06310 
06318 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
06319 {
06320     Q_OBJECT
06321 
06322 public:
06329     static inline QLatin1String staticInterfaceName()
06330     {
06331         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
06332     }
06333 
06341     ChannelTypeRoomListInterface(
06342         const QString& busName,
06343         const QString& objectPath,
06344         QObject* parent = 0
06345     );
06346 
06355     ChannelTypeRoomListInterface(
06356         const QDBusConnection& connection,
06357         const QString& busName,
06358         const QString& objectPath,
06359         QObject* parent = 0
06360     );
06361 
06368     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
06369 
06377     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
06378 
06386     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06387 
06401     inline Tp::PendingVariant *requestPropertyServer() const
06402     {
06403         return internalRequestProperty(QLatin1String("Server"));
06404     }
06405 
06412     Tp::PendingVariantMap *requestAllProperties() const
06413     {
06414         return internalRequestAllProperties();
06415     }
06416 
06417 public Q_SLOTS:
06433     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
06434     {
06435         if (!invalidationReason().isEmpty()) {
06436             return QDBusPendingReply<bool>(QDBusMessage::createError(
06437                 invalidationReason(),
06438                 invalidationMessage()
06439             ));
06440         }
06441 
06442         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06443                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
06444         return this->connection().asyncCall(callMessage, timeout);
06445     }
06446 
06460     inline QDBusPendingReply<> ListRooms(int timeout = -1)
06461     {
06462         if (!invalidationReason().isEmpty()) {
06463             return QDBusPendingReply<>(QDBusMessage::createError(
06464                 invalidationReason(),
06465                 invalidationMessage()
06466             ));
06467         }
06468 
06469         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06470                 this->staticInterfaceName(), QLatin1String("ListRooms"));
06471         return this->connection().asyncCall(callMessage, timeout);
06472     }
06473 
06486     inline QDBusPendingReply<> StopListing(int timeout = -1)
06487     {
06488         if (!invalidationReason().isEmpty()) {
06489             return QDBusPendingReply<>(QDBusMessage::createError(
06490                 invalidationReason(),
06491                 invalidationMessage()
06492             ));
06493         }
06494 
06495         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06496                 this->staticInterfaceName(), QLatin1String("StopListing"));
06497         return this->connection().asyncCall(callMessage, timeout);
06498     }
06499 
06500 Q_SIGNALS:
06558     void GotRooms(const Tp::RoomInfoList& rooms);
06559 
06570     void ListingRooms(bool listing);
06571 
06572 protected:
06573     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06574 };
06575 
06583 class TELEPATHY_QT4_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
06584 {
06585     Q_OBJECT
06586 
06587 public:
06594     static inline QLatin1String staticInterfaceName()
06595     {
06596         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
06597     }
06598 
06606     ChannelTypeServerAuthenticationInterface(
06607         const QString& busName,
06608         const QString& objectPath,
06609         QObject* parent = 0
06610     );
06611 
06620     ChannelTypeServerAuthenticationInterface(
06621         const QDBusConnection& connection,
06622         const QString& busName,
06623         const QString& objectPath,
06624         QObject* parent = 0
06625     );
06626 
06633     ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
06634 
06642     explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
06643 
06651     ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06652 
06669     inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
06670     {
06671         return internalRequestProperty(QLatin1String("AuthenticationMethod"));
06672     }
06673 
06680     Tp::PendingVariantMap *requestAllProperties() const
06681     {
06682         return internalRequestAllProperties();
06683     }
06684 
06685 protected:
06686     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06687 };
06688 
06696 class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
06697 {
06698     Q_OBJECT
06699 
06700 public:
06707     static inline QLatin1String staticInterfaceName()
06708     {
06709         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
06710     }
06711 
06719     ChannelTypeServerTLSConnectionInterface(
06720         const QString& busName,
06721         const QString& objectPath,
06722         QObject* parent = 0
06723     );
06724 
06733     ChannelTypeServerTLSConnectionInterface(
06734         const QDBusConnection& connection,
06735         const QString& busName,
06736         const QString& objectPath,
06737         QObject* parent = 0
06738     );
06739 
06746     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
06747 
06755     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
06756 
06764     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06765 
06776     inline Tp::PendingVariant *requestPropertyServerCertificate() const
06777     {
06778         return internalRequestProperty(QLatin1String("ServerCertificate"));
06779     }
06780 
06794     inline Tp::PendingVariant *requestPropertyHostname() const
06795     {
06796         return internalRequestProperty(QLatin1String("Hostname"));
06797     }
06798 
06825     inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
06826     {
06827         return internalRequestProperty(QLatin1String("ReferenceIdentities"));
06828     }
06829 
06836     Tp::PendingVariantMap *requestAllProperties() const
06837     {
06838         return internalRequestAllProperties();
06839     }
06840 
06841 protected:
06842     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06843 };
06844 
06852 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
06853 {
06854     Q_OBJECT
06855 
06856 public:
06863     static inline QLatin1String staticInterfaceName()
06864     {
06865         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
06866     }
06867 
06875     ChannelTypeStreamTubeInterface(
06876         const QString& busName,
06877         const QString& objectPath,
06878         QObject* parent = 0
06879     );
06880 
06889     ChannelTypeStreamTubeInterface(
06890         const QDBusConnection& connection,
06891         const QString& busName,
06892         const QString& objectPath,
06893         QObject* parent = 0
06894     );
06895 
06902     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
06903 
06911     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
06912 
06920     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06921 
06944     inline Tp::PendingVariant *requestPropertyService() const
06945     {
06946         return internalRequestProperty(QLatin1String("Service"));
06947     }
06948 
06983     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
06984     {
06985         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
06986     }
06987 
06994     Tp::PendingVariantMap *requestAllProperties() const
06995     {
06996         return internalRequestAllProperties();
06997     }
06998 
06999 public Q_SLOTS:
07030     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
07031     {
07032         if (!invalidationReason().isEmpty()) {
07033             return QDBusPendingReply<>(QDBusMessage::createError(
07034                 invalidationReason(),
07035                 invalidationMessage()
07036             ));
07037         }
07038 
07039         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07040                 this->staticInterfaceName(), QLatin1String("Offer"));
07041         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
07042         return this->connection().asyncCall(callMessage, timeout);
07043     }
07044 
07085     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
07086     {
07087         if (!invalidationReason().isEmpty()) {
07088             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
07089                 invalidationReason(),
07090                 invalidationMessage()
07091             ));
07092         }
07093 
07094         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07095                 this->staticInterfaceName(), QLatin1String("Accept"));
07096         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
07097         return this->connection().asyncCall(callMessage, timeout);
07098     }
07099 
07100 Q_SIGNALS:
07141     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
07142 
07158     void NewLocalConnection(uint connectionID);
07159 
07191     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
07192 
07193 protected:
07194     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07195 };
07196 
07204 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
07205 {
07206     Q_OBJECT
07207 
07208 public:
07215     static inline QLatin1String staticInterfaceName()
07216     {
07217         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
07218     }
07219 
07227     ChannelTypeStreamedMediaInterface(
07228         const QString& busName,
07229         const QString& objectPath,
07230         QObject* parent = 0
07231     );
07232 
07241     ChannelTypeStreamedMediaInterface(
07242         const QDBusConnection& connection,
07243         const QString& busName,
07244         const QString& objectPath,
07245         QObject* parent = 0
07246     );
07247 
07254     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
07255 
07263     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
07264 
07272     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07273 
07362     inline Tp::PendingVariant *requestPropertyInitialAudio() const
07363     {
07364         return internalRequestProperty(QLatin1String("InitialAudio"));
07365     }
07366 
07387     inline Tp::PendingVariant *requestPropertyInitialVideo() const
07388     {
07389         return internalRequestProperty(QLatin1String("InitialVideo"));
07390     }
07391 
07434     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
07435     {
07436         return internalRequestProperty(QLatin1String("ImmutableStreams"));
07437     }
07438 
07445     Tp::PendingVariantMap *requestAllProperties() const
07446     {
07447         return internalRequestAllProperties();
07448     }
07449 
07450 public Q_SLOTS:
07478     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
07479     {
07480         if (!invalidationReason().isEmpty()) {
07481             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
07482                 invalidationReason(),
07483                 invalidationMessage()
07484             ));
07485         }
07486 
07487         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07488                 this->staticInterfaceName(), QLatin1String("ListStreams"));
07489         return this->connection().asyncCall(callMessage, timeout);
07490     }
07491 
07518     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
07519     {
07520         if (!invalidationReason().isEmpty()) {
07521             return QDBusPendingReply<>(QDBusMessage::createError(
07522                 invalidationReason(),
07523                 invalidationMessage()
07524             ));
07525         }
07526 
07527         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07528                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
07529         callMessage << QVariant::fromValue(streams);
07530         return this->connection().asyncCall(callMessage, timeout);
07531     }
07532 
07569     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
07570     {
07571         if (!invalidationReason().isEmpty()) {
07572             return QDBusPendingReply<>(QDBusMessage::createError(
07573                 invalidationReason(),
07574                 invalidationMessage()
07575             ));
07576         }
07577 
07578         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07579                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
07580         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
07581         return this->connection().asyncCall(callMessage, timeout);
07582     }
07583 
07636     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
07637     {
07638         if (!invalidationReason().isEmpty()) {
07639             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
07640                 invalidationReason(),
07641                 invalidationMessage()
07642             ));
07643         }
07644 
07645         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07646                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
07647         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
07648         return this->connection().asyncCall(callMessage, timeout);
07649     }
07650 
07651 Q_SIGNALS:
07718     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
07719 
07751     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
07752 
07770     void StreamError(uint streamID, uint errorCode, const QString& message);
07771 
07781     void StreamRemoved(uint streamID);
07782 
07796     void StreamStateChanged(uint streamID, uint streamState);
07797 
07798 protected:
07799     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07800 };
07801 
07809 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
07810 {
07811     Q_OBJECT
07812 
07813 public:
07820     static inline QLatin1String staticInterfaceName()
07821     {
07822         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
07823     }
07824 
07832     ChannelTypeTextInterface(
07833         const QString& busName,
07834         const QString& objectPath,
07835         QObject* parent = 0
07836     );
07837 
07846     ChannelTypeTextInterface(
07847         const QDBusConnection& connection,
07848         const QString& busName,
07849         const QString& objectPath,
07850         QObject* parent = 0
07851     );
07852 
07859     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
07860 
07868     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
07869 
07877     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
07878 
07885     Tp::PendingVariantMap *requestAllProperties() const
07886     {
07887         return internalRequestAllProperties();
07888     }
07889 
07890 public Q_SLOTS:
07906     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
07907     {
07908         if (!invalidationReason().isEmpty()) {
07909             return QDBusPendingReply<>(QDBusMessage::createError(
07910                 invalidationReason(),
07911                 invalidationMessage()
07912             ));
07913         }
07914 
07915         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07916                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
07917         callMessage << QVariant::fromValue(IDs);
07918         return this->connection().asyncCall(callMessage, timeout);
07919     }
07920 
07936     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
07937     {
07938         if (!invalidationReason().isEmpty()) {
07939             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
07940                 invalidationReason(),
07941                 invalidationMessage()
07942             ));
07943         }
07944 
07945         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07946                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
07947         return this->connection().asyncCall(callMessage, timeout);
07948     }
07949 
07980     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
07981     {
07982         if (!invalidationReason().isEmpty()) {
07983             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
07984                 invalidationReason(),
07985                 invalidationMessage()
07986             ));
07987         }
07988 
07989         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07990                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
07991         callMessage << QVariant::fromValue(clear);
07992         return this->connection().asyncCall(callMessage, timeout);
07993     }
07994 
08027     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
08028     {
08029         if (!invalidationReason().isEmpty()) {
08030             return QDBusPendingReply<>(QDBusMessage::createError(
08031                 invalidationReason(),
08032                 invalidationMessage()
08033             ));
08034         }
08035 
08036         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08037                 this->staticInterfaceName(), QLatin1String("Send"));
08038         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
08039         return this->connection().asyncCall(callMessage, timeout);
08040     }
08041 
08042 Q_SIGNALS:
08050     void LostMessage();
08051 
08085     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
08086 
08115     void SendError(uint error, uint timestamp, uint type, const QString& text);
08116 
08140     void Sent(uint timestamp, uint type, const QString& text);
08141 
08142 protected:
08143     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08144 };
08145 
08153 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
08154 {
08155     Q_OBJECT
08156 
08157 public:
08164     static inline QLatin1String staticInterfaceName()
08165     {
08166         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
08167     }
08168 
08176     ChannelTypeTubesInterface(
08177         const QString& busName,
08178         const QString& objectPath,
08179         QObject* parent = 0
08180     );
08181 
08190     ChannelTypeTubesInterface(
08191         const QDBusConnection& connection,
08192         const QString& busName,
08193         const QString& objectPath,
08194         QObject* parent = 0
08195     );
08196 
08203     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
08204 
08212     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
08213 
08221     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
08222 
08229     Tp::PendingVariantMap *requestAllProperties() const
08230     {
08231         return internalRequestAllProperties();
08232     }
08233 
08234 public Q_SLOTS:
08271     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
08272     {
08273         if (!invalidationReason().isEmpty()) {
08274             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
08275                 invalidationReason(),
08276                 invalidationMessage()
08277             ));
08278         }
08279 
08280         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08281                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
08282         return this->connection().asyncCall(callMessage, timeout);
08283     }
08284 
08298     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
08299     {
08300         if (!invalidationReason().isEmpty()) {
08301             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
08302                 invalidationReason(),
08303                 invalidationMessage()
08304             ));
08305         }
08306 
08307         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08308                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
08309         return this->connection().asyncCall(callMessage, timeout);
08310     }
08311 
08327     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
08328     {
08329         if (!invalidationReason().isEmpty()) {
08330             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
08331                 invalidationReason(),
08332                 invalidationMessage()
08333             ));
08334         }
08335 
08336         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08337                 this->staticInterfaceName(), QLatin1String("ListTubes"));
08338         return this->connection().asyncCall(callMessage, timeout);
08339     }
08340 
08368     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
08369     {
08370         if (!invalidationReason().isEmpty()) {
08371             return QDBusPendingReply<uint>(QDBusMessage::createError(
08372                 invalidationReason(),
08373                 invalidationMessage()
08374             ));
08375         }
08376 
08377         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08378                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
08379         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
08380         return this->connection().asyncCall(callMessage, timeout);
08381     }
08382 
08442     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
08443     {
08444         if (!invalidationReason().isEmpty()) {
08445             return QDBusPendingReply<uint>(QDBusMessage::createError(
08446                 invalidationReason(),
08447                 invalidationMessage()
08448             ));
08449         }
08450 
08451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08452                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
08453         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
08454         return this->connection().asyncCall(callMessage, timeout);
08455     }
08456 
08479     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
08480     {
08481         if (!invalidationReason().isEmpty()) {
08482             return QDBusPendingReply<QString>(QDBusMessage::createError(
08483                 invalidationReason(),
08484                 invalidationMessage()
08485             ));
08486         }
08487 
08488         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08489                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
08490         callMessage << QVariant::fromValue(ID);
08491         return this->connection().asyncCall(callMessage, timeout);
08492     }
08493 
08531     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
08532     {
08533         if (!invalidationReason().isEmpty()) {
08534             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
08535                 invalidationReason(),
08536                 invalidationMessage()
08537             ));
08538         }
08539 
08540         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08541                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
08542         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
08543         return this->connection().asyncCall(callMessage, timeout);
08544     }
08545 
08560     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
08561     {
08562         if (!invalidationReason().isEmpty()) {
08563             return QDBusPendingReply<>(QDBusMessage::createError(
08564                 invalidationReason(),
08565                 invalidationMessage()
08566             ));
08567         }
08568 
08569         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08570                 this->staticInterfaceName(), QLatin1String("CloseTube"));
08571         callMessage << QVariant::fromValue(ID);
08572         return this->connection().asyncCall(callMessage, timeout);
08573     }
08574 
08594     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
08595     {
08596         if (!invalidationReason().isEmpty()) {
08597             return QDBusPendingReply<QString>(QDBusMessage::createError(
08598                 invalidationReason(),
08599                 invalidationMessage()
08600             ));
08601         }
08602 
08603         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08604                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
08605         callMessage << QVariant::fromValue(ID);
08606         return this->connection().asyncCall(callMessage, timeout);
08607     }
08608 
08629     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
08630     {
08631         if (!invalidationReason().isEmpty()) {
08632             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
08633                 invalidationReason(),
08634                 invalidationMessage()
08635             ));
08636         }
08637 
08638         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08639                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
08640         callMessage << QVariant::fromValue(ID);
08641         return this->connection().asyncCall(callMessage, timeout);
08642     }
08643 
08669     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
08670     {
08671         if (!invalidationReason().isEmpty()) {
08672             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
08673                 invalidationReason(),
08674                 invalidationMessage()
08675             ));
08676         }
08677 
08678         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
08679                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
08680         callMessage << QVariant::fromValue(ID);
08681         return this->connection().asyncCall(callMessage, timeout);
08682     }
08683 
08684 Q_SIGNALS:
08714     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
08715 
08729     void TubeStateChanged(uint ID, uint state);
08730 
08741     void TubeClosed(uint ID);
08742 
08761     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
08762 
08777     void StreamTubeNewConnection(uint ID, uint handle);
08778 
08779 protected:
08780     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
08781 };
08782 }
08783 }
08784 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
08785 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
08786 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
08787 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
08788 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
08789 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
08790 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDestroyableInterface*)
08791 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
08792 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
08793 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
08794 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
08795 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
08796 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
08797 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
08798 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
08799 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
08800 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
08801 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
08802 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeDBusTubeInterface*)
08803 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
08804 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
08805 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
08806 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
08807 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
08808 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
08809 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
08810 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)

Copyright © 2008-2011 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.6.5