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

cli-channel.h

    00001 /*
    00002  * This file contains D-Bus client proxy classes generated by qt-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_TP_QT_HEADER
    00009 #error IN_TP_QT_HEADER
    00010 #endif
    00011
    00012 #include <TelepathyQt/Types>
    00013
    00014 #include <QtGlobal>
    00015
    00016 #include <QString>
    00017 #include <QObject>
    00018 #include <QVariant>
    00019
    00020 #include <QDBusPendingReply>
    00021
    00022 #include <TelepathyQt/AbstractInterface>
    00023 #include <TelepathyQt/DBusProxy>
    00024 #include <TelepathyQt/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 TP_QT_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 TP_QT_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 TP_QT_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 TP_QT_EXPORT ChannelInterfaceCaptchaAuthenticationInterface : public Tp::AbstractInterface
    00927 {
    00928     Q_OBJECT
    00929
    00930 public:
    00937     static inline QLatin1String staticInterfaceName()
    00938     {
    00939         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.CaptchaAuthentication1");
    00940     }
    00941
    00949     ChannelInterfaceCaptchaAuthenticationInterface(
    00950         const QString& busName,
    00951         const QString& objectPath,
    00952         QObject* parent = 0
    00953     );
    00954
    00963     ChannelInterfaceCaptchaAuthenticationInterface(
    00964         const QDBusConnection& connection,
    00965         const QString& busName,
    00966         const QString& objectPath,
    00967         QObject* parent = 0
    00968     );
    00969
    00976     ChannelInterfaceCaptchaAuthenticationInterface(Tp::DBusProxy *proxy);
    00977
    00985     explicit ChannelInterfaceCaptchaAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
    00986
    00994     ChannelInterfaceCaptchaAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    00995
    01017     inline Tp::PendingVariant *requestPropertyCanRetryCaptcha() const
    01018     {
    01019         return internalRequestProperty(QLatin1String("CanRetryCaptcha"));
    01020     }
    01021
    01047     inline Tp::PendingVariant *requestPropertyCaptchaStatus() const
    01048     {
    01049         return internalRequestProperty(QLatin1String("CaptchaStatus"));
    01050     }
    01051
    01085     inline Tp::PendingVariant *requestPropertyCaptchaError() const
    01086     {
    01087         return internalRequestProperty(QLatin1String("CaptchaError"));
    01088     }
    01089
    01111     inline Tp::PendingVariant *requestPropertyCaptchaErrorDetails() const
    01112     {
    01113         return internalRequestProperty(QLatin1String("CaptchaErrorDetails"));
    01114     }
    01115
    01122     Tp::PendingVariantMap *requestAllProperties() const
    01123     {
    01124         return internalRequestAllProperties();
    01125     }
    01126
    01127 public Q_SLOTS:
    01181     inline QDBusPendingReply<Tp::CaptchaInfoList, uint, QString> GetCaptchas(int timeout = -1)
    01182     {
    01183         if (!invalidationReason().isEmpty()) {
    01184             return QDBusPendingReply<Tp::CaptchaInfoList, uint, QString>(QDBusMessage::createError(
    01185                 invalidationReason(),
    01186                 invalidationMessage()
    01187             ));
    01188         }
    01189
    01190         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01191                 this->staticInterfaceName(), QLatin1String("GetCaptchas"));
    01192         return this->connection().asyncCall(callMessage, timeout);
    01193     }
    01194
    01232     inline QDBusPendingReply<QByteArray> GetCaptchaData(uint ID, const QString& mimeType, int timeout = -1)
    01233     {
    01234         if (!invalidationReason().isEmpty()) {
    01235             return QDBusPendingReply<QByteArray>(QDBusMessage::createError(
    01236                 invalidationReason(),
    01237                 invalidationMessage()
    01238             ));
    01239         }
    01240
    01241         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01242                 this->staticInterfaceName(), QLatin1String("GetCaptchaData"));
    01243         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(mimeType);
    01244         return this->connection().asyncCall(callMessage, timeout);
    01245     }
    01246
    01265     inline QDBusPendingReply<> AnswerCaptchas(const Tp::CaptchaAnswers& answers, int timeout = -1)
    01266     {
    01267         if (!invalidationReason().isEmpty()) {
    01268             return QDBusPendingReply<>(QDBusMessage::createError(
    01269                 invalidationReason(),
    01270                 invalidationMessage()
    01271             ));
    01272         }
    01273
    01274         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01275                 this->staticInterfaceName(), QLatin1String("AnswerCaptchas"));
    01276         callMessage << QVariant::fromValue(answers);
    01277         return this->connection().asyncCall(callMessage, timeout);
    01278     }
    01279
    01307     inline QDBusPendingReply<> CancelCaptcha(uint reason, const QString& debugMessage, int timeout = -1)
    01308     {
    01309         if (!invalidationReason().isEmpty()) {
    01310             return QDBusPendingReply<>(QDBusMessage::createError(
    01311                 invalidationReason(),
    01312                 invalidationMessage()
    01313             ));
    01314         }
    01315
    01316         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01317                 this->staticInterfaceName(), QLatin1String("CancelCaptcha"));
    01318         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
    01319         return this->connection().asyncCall(callMessage, timeout);
    01320     }
    01321
    01322 protected:
    01323     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01324 };
    01325
    01333 class TP_QT_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
    01334 {
    01335     Q_OBJECT
    01336
    01337 public:
    01344     static inline QLatin1String staticInterfaceName()
    01345     {
    01346         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ChatState");
    01347     }
    01348
    01356     ChannelInterfaceChatStateInterface(
    01357         const QString& busName,
    01358         const QString& objectPath,
    01359         QObject* parent = 0
    01360     );
    01361
    01370     ChannelInterfaceChatStateInterface(
    01371         const QDBusConnection& connection,
    01372         const QString& busName,
    01373         const QString& objectPath,
    01374         QObject* parent = 0
    01375     );
    01376
    01383     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
    01384
    01392     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
    01393
    01401     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    01402
    01438     inline Tp::PendingVariant *requestPropertyChatStates() const
    01439     {
    01440         return internalRequestProperty(QLatin1String("ChatStates"));
    01441     }
    01442
    01449     Tp::PendingVariantMap *requestAllProperties() const
    01450     {
    01451         return internalRequestAllProperties();
    01452     }
    01453
    01454 public Q_SLOTS:
    01470     inline QDBusPendingReply<> SetChatState(uint state, int timeout = -1)
    01471     {
    01472         if (!invalidationReason().isEmpty()) {
    01473             return QDBusPendingReply<>(QDBusMessage::createError(
    01474                 invalidationReason(),
    01475                 invalidationMessage()
    01476             ));
    01477         }
    01478
    01479         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01480                 this->staticInterfaceName(), QLatin1String("SetChatState"));
    01481         callMessage << QVariant::fromValue(state);
    01482         return this->connection().asyncCall(callMessage, timeout);
    01483     }
    01484
    01485 Q_SIGNALS:
    01500     void ChatStateChanged(uint contact, uint state);
    01501
    01502 protected:
    01503     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01504 };
    01505
    01513 class TP_QT_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
    01514 {
    01515     Q_OBJECT
    01516
    01517 public:
    01524     static inline QLatin1String staticInterfaceName()
    01525     {
    01526         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Conference");
    01527     }
    01528
    01536     ChannelInterfaceConferenceInterface(
    01537         const QString& busName,
    01538         const QString& objectPath,
    01539         QObject* parent = 0
    01540     );
    01541
    01550     ChannelInterfaceConferenceInterface(
    01551         const QDBusConnection& connection,
    01552         const QString& busName,
    01553         const QString& objectPath,
    01554         QObject* parent = 0
    01555     );
    01556
    01563     ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
    01564
    01572     explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
    01573
    01581     ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    01582
    01611     inline Tp::PendingVariant *requestPropertyChannels() const
    01612     {
    01613         return internalRequestProperty(QLatin1String("Channels"));
    01614     }
    01615
    01677     inline Tp::PendingVariant *requestPropertyInitialChannels() const
    01678     {
    01679         return internalRequestProperty(QLatin1String("InitialChannels"));
    01680     }
    01681
    01755     inline Tp::PendingVariant *requestPropertyInitialInviteeHandles() const
    01756     {
    01757         return internalRequestProperty(QLatin1String("InitialInviteeHandles"));
    01758     }
    01759
    01784     inline Tp::PendingVariant *requestPropertyInitialInviteeIDs() const
    01785     {
    01786         return internalRequestProperty(QLatin1String("InitialInviteeIDs"));
    01787     }
    01788
    01816     inline Tp::PendingVariant *requestPropertyInvitationMessage() const
    01817     {
    01818         return internalRequestProperty(QLatin1String("InvitationMessage"));
    01819     }
    01820
    01886     inline Tp::PendingVariant *requestPropertyOriginalChannels() const
    01887     {
    01888         return internalRequestProperty(QLatin1String("OriginalChannels"));
    01889     }
    01890
    01897     Tp::PendingVariantMap *requestAllProperties() const
    01898     {
    01899         return internalRequestAllProperties();
    01900     }
    01901
    01902 Q_SIGNALS:
    01926     void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
    01927
    01952     void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
    01953
    01954 protected:
    01955     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01956 };
    01957
    01965 class TP_QT_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
    01966 {
    01967     Q_OBJECT
    01968
    01969 public:
    01976     static inline QLatin1String staticInterfaceName()
    01977     {
    01978         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.DTMF");
    01979     }
    01980
    01988     ChannelInterfaceDTMFInterface(
    01989         const QString& busName,
    01990         const QString& objectPath,
    01991         QObject* parent = 0
    01992     );
    01993
    02002     ChannelInterfaceDTMFInterface(
    02003         const QDBusConnection& connection,
    02004         const QString& busName,
    02005         const QString& objectPath,
    02006         QObject* parent = 0
    02007     );
    02008
    02015     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
    02016
    02024     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
    02025
    02033     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02034
    02046     inline Tp::PendingVariant *requestPropertyCurrentlySendingTones() const
    02047     {
    02048         return internalRequestProperty(QLatin1String("CurrentlySendingTones"));
    02049     }
    02050
    02064     inline Tp::PendingVariant *requestPropertyInitialTones() const
    02065     {
    02066         return internalRequestProperty(QLatin1String("InitialTones"));
    02067     }
    02068
    02086     inline Tp::PendingVariant *requestPropertyDeferredTones() const
    02087     {
    02088         return internalRequestProperty(QLatin1String("DeferredTones"));
    02089     }
    02090
    02097     Tp::PendingVariantMap *requestAllProperties() const
    02098     {
    02099         return internalRequestAllProperties();
    02100     }
    02101
    02102 public Q_SLOTS:
    02133     inline QDBusPendingReply<> StartTone(uint streamID, uchar event, int timeout = -1)
    02134     {
    02135         if (!invalidationReason().isEmpty()) {
    02136             return QDBusPendingReply<>(QDBusMessage::createError(
    02137                 invalidationReason(),
    02138                 invalidationMessage()
    02139             ));
    02140         }
    02141
    02142         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02143                 this->staticInterfaceName(), QLatin1String("StartTone"));
    02144         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(event);
    02145         return this->connection().asyncCall(callMessage, timeout);
    02146     }
    02147
    02170     inline QDBusPendingReply<> StopTone(uint streamID, int timeout = -1)
    02171     {
    02172         if (!invalidationReason().isEmpty()) {
    02173             return QDBusPendingReply<>(QDBusMessage::createError(
    02174                 invalidationReason(),
    02175                 invalidationMessage()
    02176             ));
    02177         }
    02178
    02179         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02180                 this->staticInterfaceName(), QLatin1String("StopTone"));
    02181         callMessage << QVariant::fromValue(streamID);
    02182         return this->connection().asyncCall(callMessage, timeout);
    02183     }
    02184
    02230     inline QDBusPendingReply<> MultipleTones(const QString& tones, int timeout = -1)
    02231     {
    02232         if (!invalidationReason().isEmpty()) {
    02233             return QDBusPendingReply<>(QDBusMessage::createError(
    02234                 invalidationReason(),
    02235                 invalidationMessage()
    02236             ));
    02237         }
    02238
    02239         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02240                 this->staticInterfaceName(), QLatin1String("MultipleTones"));
    02241         callMessage << QVariant::fromValue(tones);
    02242         return this->connection().asyncCall(callMessage, timeout);
    02243     }
    02244
    02245 Q_SIGNALS:
    02273     void TonesDeferred(const QString& tones);
    02274
    02291     void SendingTones(const QString& tones);
    02292
    02304     void StoppedTones(bool cancelled);
    02305
    02306 protected:
    02307     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02308 };
    02309
    02317 class TP_QT_EXPORT ChannelInterfaceDestroyableInterface : public Tp::AbstractInterface
    02318 {
    02319     Q_OBJECT
    02320
    02321 public:
    02328     static inline QLatin1String staticInterfaceName()
    02329     {
    02330         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Destroyable");
    02331     }
    02332
    02340     ChannelInterfaceDestroyableInterface(
    02341         const QString& busName,
    02342         const QString& objectPath,
    02343         QObject* parent = 0
    02344     );
    02345
    02354     ChannelInterfaceDestroyableInterface(
    02355         const QDBusConnection& connection,
    02356         const QString& busName,
    02357         const QString& objectPath,
    02358         QObject* parent = 0
    02359     );
    02360
    02367     ChannelInterfaceDestroyableInterface(Tp::DBusProxy *proxy);
    02368
    02376     explicit ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface);
    02377
    02385     ChannelInterfaceDestroyableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02386
    02393     Tp::PendingVariantMap *requestAllProperties() const
    02394     {
    02395         return internalRequestAllProperties();
    02396     }
    02397
    02398 public Q_SLOTS:
    02443     inline QDBusPendingReply<> Destroy(int timeout = -1)
    02444     {
    02445         if (!invalidationReason().isEmpty()) {
    02446             return QDBusPendingReply<>(QDBusMessage::createError(
    02447                 invalidationReason(),
    02448                 invalidationMessage()
    02449             ));
    02450         }
    02451
    02452         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02453                 this->staticInterfaceName(), QLatin1String("Destroy"));
    02454         return this->connection().asyncCall(callMessage, timeout);
    02455     }
    02456
    02457 protected:
    02458     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02459 };
    02460
    02468 class TP_QT_EXPORT ChannelInterfaceFileTransferMetadataInterface : public Tp::AbstractInterface
    02469 {
    02470     Q_OBJECT
    02471
    02472 public:
    02479     static inline QLatin1String staticInterfaceName()
    02480     {
    02481         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.FileTransfer.Metadata");
    02482     }
    02483
    02491     ChannelInterfaceFileTransferMetadataInterface(
    02492         const QString& busName,
    02493         const QString& objectPath,
    02494         QObject* parent = 0
    02495     );
    02496
    02505     ChannelInterfaceFileTransferMetadataInterface(
    02506         const QDBusConnection& connection,
    02507         const QString& busName,
    02508         const QString& objectPath,
    02509         QObject* parent = 0
    02510     );
    02511
    02518     ChannelInterfaceFileTransferMetadataInterface(Tp::DBusProxy *proxy);
    02519
    02527     explicit ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface);
    02528
    02536     ChannelInterfaceFileTransferMetadataInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02537
    02554     inline Tp::PendingVariant *requestPropertyServiceName() const
    02555     {
    02556         return internalRequestProperty(QLatin1String("ServiceName"));
    02557     }
    02558
    02575     inline Tp::PendingOperation *setPropertyServiceName(QString newValue)
    02576     {
    02577         return internalSetProperty(QLatin1String("ServiceName"), QVariant::fromValue(newValue));
    02578     }
    02579
    02593     inline Tp::PendingVariant *requestPropertyMetadata() const
    02594     {
    02595         return internalRequestProperty(QLatin1String("Metadata"));
    02596     }
    02597
    02611     inline Tp::PendingOperation *setPropertyMetadata(Tp::Metadata newValue)
    02612     {
    02613         return internalSetProperty(QLatin1String("Metadata"), QVariant::fromValue(newValue));
    02614     }
    02615
    02622     Tp::PendingVariantMap *requestAllProperties() const
    02623     {
    02624         return internalRequestAllProperties();
    02625     }
    02626
    02627 protected:
    02628     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02629 };
    02630
    02638 class TP_QT_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
    02639 {
    02640     Q_OBJECT
    02641
    02642 public:
    02649     static inline QLatin1String staticInterfaceName()
    02650     {
    02651         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Group");
    02652     }
    02653
    02661     ChannelInterfaceGroupInterface(
    02662         const QString& busName,
    02663         const QString& objectPath,
    02664         QObject* parent = 0
    02665     );
    02666
    02675     ChannelInterfaceGroupInterface(
    02676         const QDBusConnection& connection,
    02677         const QString& busName,
    02678         const QString& objectPath,
    02679         QObject* parent = 0
    02680     );
    02681
    02688     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
    02689
    02697     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
    02698
    02706     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02707
    02720     inline Tp::PendingVariant *requestPropertyGroupFlags() const
    02721     {
    02722         return internalRequestProperty(QLatin1String("GroupFlags"));
    02723     }
    02724
    02740     inline Tp::PendingVariant *requestPropertyHandleOwners() const
    02741     {
    02742         return internalRequestProperty(QLatin1String("HandleOwners"));
    02743     }
    02744
    02755     inline Tp::PendingVariant *requestPropertyLocalPendingMembers() const
    02756     {
    02757         return internalRequestProperty(QLatin1String("LocalPendingMembers"));
    02758     }
    02759
    02769     inline Tp::PendingVariant *requestPropertyMembers() const
    02770     {
    02771         return internalRequestProperty(QLatin1String("Members"));
    02772     }
    02773
    02784     inline Tp::PendingVariant *requestPropertyRemotePendingMembers() const
    02785     {
    02786         return internalRequestProperty(QLatin1String("RemotePendingMembers"));
    02787     }
    02788
    02803     inline Tp::PendingVariant *requestPropertySelfHandle() const
    02804     {
    02805         return internalRequestProperty(QLatin1String("SelfHandle"));
    02806     }
    02807
    02821     inline Tp::PendingVariant *requestPropertyMemberIdentifiers() const
    02822     {
    02823         return internalRequestProperty(QLatin1String("MemberIdentifiers"));
    02824     }
    02825
    02832     Tp::PendingVariantMap *requestAllProperties() const
    02833     {
    02834         return internalRequestAllProperties();
    02835     }
    02836
    02837 public Q_SLOTS:
    02868     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
    02869     {
    02870         if (!invalidationReason().isEmpty()) {
    02871             return QDBusPendingReply<>(QDBusMessage::createError(
    02872                 invalidationReason(),
    02873                 invalidationMessage()
    02874             ));
    02875         }
    02876
    02877         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02878                 this->staticInterfaceName(), QLatin1String("AddMembers"));
    02879         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    02880         return this->connection().asyncCall(callMessage, timeout);
    02881     }
    02882
    02905     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers(int timeout = -1)
    02906     {
    02907         if (!invalidationReason().isEmpty()) {
    02908             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
    02909                 invalidationReason(),
    02910                 invalidationMessage()
    02911             ));
    02912         }
    02913
    02914         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02915                 this->staticInterfaceName(), QLatin1String("GetAllMembers"));
    02916         return this->connection().asyncCall(callMessage, timeout);
    02917     }
    02918
    02933     inline QDBusPendingReply<uint> GetGroupFlags(int timeout = -1)
    02934     {
    02935         if (!invalidationReason().isEmpty()) {
    02936             return QDBusPendingReply<uint>(QDBusMessage::createError(
    02937                 invalidationReason(),
    02938                 invalidationMessage()
    02939             ));
    02940         }
    02941
    02942         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02943                 this->staticInterfaceName(), QLatin1String("GetGroupFlags"));
    02944         return this->connection().asyncCall(callMessage, timeout);
    02945     }
    02946
    02972     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles, int timeout = -1)
    02973     {
    02974         if (!invalidationReason().isEmpty()) {
    02975             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    02976                 invalidationReason(),
    02977                 invalidationMessage()
    02978             ));
    02979         }
    02980
    02981         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02982                 this->staticInterfaceName(), QLatin1String("GetHandleOwners"));
    02983         callMessage << QVariant::fromValue(handles);
    02984         return this->connection().asyncCall(callMessage, timeout);
    02985     }
    02986
    02998     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers(int timeout = -1)
    02999     {
    03000         if (!invalidationReason().isEmpty()) {
    03001             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    03002                 invalidationReason(),
    03003                 invalidationMessage()
    03004             ));
    03005         }
    03006
    03007         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03008                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembers"));
    03009         return this->connection().asyncCall(callMessage, timeout);
    03010     }
    03011
    03030     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo(int timeout = -1)
    03031     {
    03032         if (!invalidationReason().isEmpty()) {
    03033             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
    03034                 invalidationReason(),
    03035                 invalidationMessage()
    03036             ));
    03037         }
    03038
    03039         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03040                 this->staticInterfaceName(), QLatin1String("GetLocalPendingMembersWithInfo"));
    03041         return this->connection().asyncCall(callMessage, timeout);
    03042     }
    03043
    03054     inline QDBusPendingReply<Tp::UIntList> GetMembers(int timeout = -1)
    03055     {
    03056         if (!invalidationReason().isEmpty()) {
    03057             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    03058                 invalidationReason(),
    03059                 invalidationMessage()
    03060             ));
    03061         }
    03062
    03063         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03064                 this->staticInterfaceName(), QLatin1String("GetMembers"));
    03065         return this->connection().asyncCall(callMessage, timeout);
    03066     }
    03067
    03079     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers(int timeout = -1)
    03080     {
    03081         if (!invalidationReason().isEmpty()) {
    03082             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    03083                 invalidationReason(),
    03084                 invalidationMessage()
    03085             ));
    03086         }
    03087
    03088         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03089                 this->staticInterfaceName(), QLatin1String("GetRemotePendingMembers"));
    03090         return this->connection().asyncCall(callMessage, timeout);
    03091     }
    03092
    03103     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
    03104     {
    03105         if (!invalidationReason().isEmpty()) {
    03106             return QDBusPendingReply<uint>(QDBusMessage::createError(
    03107                 invalidationReason(),
    03108                 invalidationMessage()
    03109             ));
    03110         }
    03111
    03112         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03113                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
    03114         return this->connection().asyncCall(callMessage, timeout);
    03115     }
    03116
    03172     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
    03173     {
    03174         if (!invalidationReason().isEmpty()) {
    03175             return QDBusPendingReply<>(QDBusMessage::createError(
    03176                 invalidationReason(),
    03177                 invalidationMessage()
    03178             ));
    03179         }
    03180
    03181         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03182                 this->staticInterfaceName(), QLatin1String("RemoveMembers"));
    03183         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    03184         return this->connection().asyncCall(callMessage, timeout);
    03185     }
    03186
    03211     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason, int timeout = -1)
    03212     {
    03213         if (!invalidationReason().isEmpty()) {
    03214             return QDBusPendingReply<>(QDBusMessage::createError(
    03215                 invalidationReason(),
    03216                 invalidationMessage()
    03217             ));
    03218         }
    03219
    03220         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03221                 this->staticInterfaceName(), QLatin1String("RemoveMembersWithReason"));
    03222         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
    03223         return this->connection().asyncCall(callMessage, timeout);
    03224     }
    03225
    03226 Q_SIGNALS:
    03245     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
    03246
    03275     void HandleOwnersChangedDetailed(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed, const Tp::HandleIdentifierMap& identifiers);
    03276
    03286     void SelfHandleChanged(uint selfHandle);
    03287
    03303     void SelfContactChanged(uint selfHandle, const QString& selfID);
    03304
    03319     void GroupFlagsChanged(uint added, uint removed);
    03320
    03374     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);
    03375
    03484     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
    03485
    03486 protected:
    03487     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03488 };
    03489
    03497 class TP_QT_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
    03498 {
    03499     Q_OBJECT
    03500
    03501 public:
    03508     static inline QLatin1String staticInterfaceName()
    03509     {
    03510         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Hold");
    03511     }
    03512
    03520     ChannelInterfaceHoldInterface(
    03521         const QString& busName,
    03522         const QString& objectPath,
    03523         QObject* parent = 0
    03524     );
    03525
    03534     ChannelInterfaceHoldInterface(
    03535         const QDBusConnection& connection,
    03536         const QString& busName,
    03537         const QString& objectPath,
    03538         QObject* parent = 0
    03539     );
    03540
    03547     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
    03548
    03556     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
    03557
    03565     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03566
    03573     Tp::PendingVariantMap *requestAllProperties() const
    03574     {
    03575         return internalRequestAllProperties();
    03576     }
    03577
    03578 public Q_SLOTS:
    03597     inline QDBusPendingReply<uint, uint> GetHoldState(int timeout = -1)
    03598     {
    03599         if (!invalidationReason().isEmpty()) {
    03600             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
    03601                 invalidationReason(),
    03602                 invalidationMessage()
    03603             ));
    03604         }
    03605
    03606         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03607                 this->staticInterfaceName(), QLatin1String("GetHoldState"));
    03608         return this->connection().asyncCall(callMessage, timeout);
    03609     }
    03610
    03674     inline QDBusPendingReply<> RequestHold(bool hold, int timeout = -1)
    03675     {
    03676         if (!invalidationReason().isEmpty()) {
    03677             return QDBusPendingReply<>(QDBusMessage::createError(
    03678                 invalidationReason(),
    03679                 invalidationMessage()
    03680             ));
    03681         }
    03682
    03683         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03684                 this->staticInterfaceName(), QLatin1String("RequestHold"));
    03685         callMessage << QVariant::fromValue(hold);
    03686         return this->connection().asyncCall(callMessage, timeout);
    03687     }
    03688
    03689 Q_SIGNALS:
    03706     void HoldStateChanged(uint holdState, uint reason);
    03707
    03708 protected:
    03709     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03710 };
    03711
    03719 class TP_QT_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
    03720 {
    03721     Q_OBJECT
    03722
    03723 public:
    03730     static inline QLatin1String staticInterfaceName()
    03731     {
    03732         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.MediaSignalling");
    03733     }
    03734
    03742     ChannelInterfaceMediaSignallingInterface(
    03743         const QString& busName,
    03744         const QString& objectPath,
    03745         QObject* parent = 0
    03746     );
    03747
    03756     ChannelInterfaceMediaSignallingInterface(
    03757         const QDBusConnection& connection,
    03758         const QString& busName,
    03759         const QString& objectPath,
    03760         QObject* parent = 0
    03761     );
    03762
    03769     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
    03770
    03778     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
    03779
    03787     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03788
    03795     Tp::PendingVariantMap *requestAllProperties() const
    03796     {
    03797         return internalRequestAllProperties();
    03798     }
    03799
    03800 public Q_SLOTS:
    03812     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers(int timeout = -1)
    03813     {
    03814         if (!invalidationReason().isEmpty()) {
    03815             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
    03816                 invalidationReason(),
    03817                 invalidationMessage()
    03818             ));
    03819         }
    03820
    03821         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03822                 this->staticInterfaceName(), QLatin1String("GetSessionHandlers"));
    03823         return this->connection().asyncCall(callMessage, timeout);
    03824     }
    03825
    03826 Q_SIGNALS:
    03842     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
    03843
    03844 protected:
    03845     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03846 };
    03847
    03855 class TP_QT_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
    03856 {
    03857     Q_OBJECT
    03858
    03859 public:
    03866     static inline QLatin1String staticInterfaceName()
    03867     {
    03868         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Messages");
    03869     }
    03870
    03878     ChannelInterfaceMessagesInterface(
    03879         const QString& busName,
    03880         const QString& objectPath,
    03881         QObject* parent = 0
    03882     );
    03883
    03892     ChannelInterfaceMessagesInterface(
    03893         const QDBusConnection& connection,
    03894         const QString& busName,
    03895         const QString& objectPath,
    03896         QObject* parent = 0
    03897     );
    03898
    03905     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
    03906
    03914     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
    03915
    03923     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03924
    03978     inline Tp::PendingVariant *requestPropertySupportedContentTypes() const
    03979     {
    03980         return internalRequestProperty(QLatin1String("SupportedContentTypes"));
    03981     }
    03982
    03994     inline Tp::PendingVariant *requestPropertyMessageTypes() const
    03995     {
    03996         return internalRequestProperty(QLatin1String("MessageTypes"));
    03997     }
    03998
    04008     inline Tp::PendingVariant *requestPropertyMessagePartSupportFlags() const
    04009     {
    04010         return internalRequestProperty(QLatin1String("MessagePartSupportFlags"));
    04011     }
    04012
    04033     inline Tp::PendingVariant *requestPropertyPendingMessages() const
    04034     {
    04035         return internalRequestProperty(QLatin1String("PendingMessages"));
    04036     }
    04037
    04047     inline Tp::PendingVariant *requestPropertyDeliveryReportingSupport() const
    04048     {
    04049         return internalRequestProperty(QLatin1String("DeliveryReportingSupport"));
    04050     }
    04051
    04058     Tp::PendingVariantMap *requestAllProperties() const
    04059     {
    04060         return internalRequestAllProperties();
    04061     }
    04062
    04063 public Q_SLOTS:
    04126     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags, int timeout = -1)
    04127     {
    04128         if (!invalidationReason().isEmpty()) {
    04129             return QDBusPendingReply<QString>(QDBusMessage::createError(
    04130                 invalidationReason(),
    04131                 invalidationMessage()
    04132             ));
    04133         }
    04134
    04135         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04136                 this->staticInterfaceName(), QLatin1String("SendMessage"));
    04137         callMessage << QVariant::fromValue(message) << QVariant::fromValue(flags);
    04138         return this->connection().asyncCall(callMessage, timeout);
    04139     }
    04140
    04181     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts, int timeout = -1)
    04182     {
    04183         if (!invalidationReason().isEmpty()) {
    04184             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
    04185                 invalidationReason(),
    04186                 invalidationMessage()
    04187             ));
    04188         }
    04189
    04190         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04191                 this->staticInterfaceName(), QLatin1String("GetPendingMessageContent"));
    04192         callMessage << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
    04193         return this->connection().asyncCall(callMessage, timeout);
    04194     }
    04195
    04196 Q_SIGNALS:
    04256     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
    04257
    04271     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
    04272
    04293     void MessageReceived(const Tp::MessagePartList& message);
    04294
    04295 protected:
    04296     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04297 };
    04298
    04306 class TP_QT_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
    04307 {
    04308     Q_OBJECT
    04309
    04310 public:
    04317     static inline QLatin1String staticInterfaceName()
    04318     {
    04319         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Password");
    04320     }
    04321
    04329     ChannelInterfacePasswordInterface(
    04330         const QString& busName,
    04331         const QString& objectPath,
    04332         QObject* parent = 0
    04333     );
    04334
    04343     ChannelInterfacePasswordInterface(
    04344         const QDBusConnection& connection,
    04345         const QString& busName,
    04346         const QString& objectPath,
    04347         QObject* parent = 0
    04348     );
    04349
    04356     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
    04357
    04365     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
    04366
    04374     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04375
    04382     Tp::PendingVariantMap *requestAllProperties() const
    04383     {
    04384         return internalRequestAllProperties();
    04385     }
    04386
    04387 public Q_SLOTS:
    04405     inline QDBusPendingReply<uint> GetPasswordFlags(int timeout = -1)
    04406     {
    04407         if (!invalidationReason().isEmpty()) {
    04408             return QDBusPendingReply<uint>(QDBusMessage::createError(
    04409                 invalidationReason(),
    04410                 invalidationMessage()
    04411             ));
    04412         }
    04413
    04414         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04415                 this->staticInterfaceName(), QLatin1String("GetPasswordFlags"));
    04416         return this->connection().asyncCall(callMessage, timeout);
    04417     }
    04418
    04439     inline QDBusPendingReply<bool> ProvidePassword(const QString& password, int timeout = -1)
    04440     {
    04441         if (!invalidationReason().isEmpty()) {
    04442             return QDBusPendingReply<bool>(QDBusMessage::createError(
    04443                 invalidationReason(),
    04444                 invalidationMessage()
    04445             ));
    04446         }
    04447
    04448         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04449                 this->staticInterfaceName(), QLatin1String("ProvidePassword"));
    04450         callMessage << QVariant::fromValue(password);
    04451         return this->connection().asyncCall(callMessage, timeout);
    04452     }
    04453
    04454 Q_SIGNALS:
    04469     void PasswordFlagsChanged(uint added, uint removed);
    04470
    04471 protected:
    04472     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04473 };
    04474
    04482 class TP_QT_EXPORT ChannelInterfaceSASLAuthenticationInterface : public Tp::AbstractInterface
    04483 {
    04484     Q_OBJECT
    04485
    04486 public:
    04493     static inline QLatin1String staticInterfaceName()
    04494     {
    04495         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SASLAuthentication");
    04496     }
    04497
    04505     ChannelInterfaceSASLAuthenticationInterface(
    04506         const QString& busName,
    04507         const QString& objectPath,
    04508         QObject* parent = 0
    04509     );
    04510
    04519     ChannelInterfaceSASLAuthenticationInterface(
    04520         const QDBusConnection& connection,
    04521         const QString& busName,
    04522         const QString& objectPath,
    04523         QObject* parent = 0
    04524     );
    04525
    04532     ChannelInterfaceSASLAuthenticationInterface(Tp::DBusProxy *proxy);
    04533
    04541     explicit ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
    04542
    04550     ChannelInterfaceSASLAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04551
    04574     inline Tp::PendingVariant *requestPropertyAvailableMechanisms() const
    04575     {
    04576         return internalRequestProperty(QLatin1String("AvailableMechanisms"));
    04577     }
    04578
    04600     inline Tp::PendingVariant *requestPropertyHasInitialData() const
    04601     {
    04602         return internalRequestProperty(QLatin1String("HasInitialData"));
    04603     }
    04604
    04625     inline Tp::PendingVariant *requestPropertyCanTryAgain() const
    04626     {
    04627         return internalRequestProperty(QLatin1String("CanTryAgain"));
    04628     }
    04629
    04643     inline Tp::PendingVariant *requestPropertySASLStatus() const
    04644     {
    04645         return internalRequestProperty(QLatin1String("SASLStatus"));
    04646     }
    04647
    04676     inline Tp::PendingVariant *requestPropertySASLError() const
    04677     {
    04678         return internalRequestProperty(QLatin1String("SASLError"));
    04679     }
    04680
    04702     inline Tp::PendingVariant *requestPropertySASLErrorDetails() const
    04703     {
    04704         return internalRequestProperty(QLatin1String("SASLErrorDetails"));
    04705     }
    04706
    04771     inline Tp::PendingVariant *requestPropertyAuthorizationIdentity() const
    04772     {
    04773         return internalRequestProperty(QLatin1String("AuthorizationIdentity"));
    04774     }
    04775
    04837     inline Tp::PendingVariant *requestPropertyDefaultUsername() const
    04838     {
    04839         return internalRequestProperty(QLatin1String("DefaultUsername"));
    04840     }
    04841
    04869     inline Tp::PendingVariant *requestPropertyDefaultRealm() const
    04870     {
    04871         return internalRequestProperty(QLatin1String("DefaultRealm"));
    04872     }
    04873
    04895     inline Tp::PendingVariant *requestPropertyMaySaveResponse() const
    04896     {
    04897         return internalRequestProperty(QLatin1String("MaySaveResponse"));
    04898     }
    04899
    04906     Tp::PendingVariantMap *requestAllProperties() const
    04907     {
    04908         return internalRequestAllProperties();
    04909     }
    04910
    04911 public Q_SLOTS:
    04938     inline QDBusPendingReply<> StartMechanism(const QString& mechanism, int timeout = -1)
    04939     {
    04940         if (!invalidationReason().isEmpty()) {
    04941             return QDBusPendingReply<>(QDBusMessage::createError(
    04942                 invalidationReason(),
    04943                 invalidationMessage()
    04944             ));
    04945         }
    04946
    04947         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04948                 this->staticInterfaceName(), QLatin1String("StartMechanism"));
    04949         callMessage << QVariant::fromValue(mechanism);
    04950         return this->connection().asyncCall(callMessage, timeout);
    04951     }
    04952
    05007     inline QDBusPendingReply<> StartMechanismWithData(const QString& mechanism, const QByteArray& initialData, int timeout = -1)
    05008     {
    05009         if (!invalidationReason().isEmpty()) {
    05010             return QDBusPendingReply<>(QDBusMessage::createError(
    05011                 invalidationReason(),
    05012                 invalidationMessage()
    05013             ));
    05014         }
    05015
    05016         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05017                 this->staticInterfaceName(), QLatin1String("StartMechanismWithData"));
    05018         callMessage << QVariant::fromValue(mechanism) << QVariant::fromValue(initialData);
    05019         return this->connection().asyncCall(callMessage, timeout);
    05020     }
    05021
    05039     inline QDBusPendingReply<> Respond(const QByteArray& responseData, int timeout = -1)
    05040     {
    05041         if (!invalidationReason().isEmpty()) {
    05042             return QDBusPendingReply<>(QDBusMessage::createError(
    05043                 invalidationReason(),
    05044                 invalidationMessage()
    05045             ));
    05046         }
    05047
    05048         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05049                 this->staticInterfaceName(), QLatin1String("Respond"));
    05050         callMessage << QVariant::fromValue(responseData);
    05051         return this->connection().asyncCall(callMessage, timeout);
    05052     }
    05053
    05082     inline QDBusPendingReply<> AcceptSASL(int timeout = -1)
    05083     {
    05084         if (!invalidationReason().isEmpty()) {
    05085             return QDBusPendingReply<>(QDBusMessage::createError(
    05086                 invalidationReason(),
    05087                 invalidationMessage()
    05088             ));
    05089         }
    05090
    05091         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05092                 this->staticInterfaceName(), QLatin1String("AcceptSASL"));
    05093         return this->connection().asyncCall(callMessage, timeout);
    05094     }
    05095
    05124     inline QDBusPendingReply<> AbortSASL(uint reason, const QString& debugMessage, int timeout = -1)
    05125     {
    05126         if (!invalidationReason().isEmpty()) {
    05127             return QDBusPendingReply<>(QDBusMessage::createError(
    05128                 invalidationReason(),
    05129                 invalidationMessage()
    05130             ));
    05131         }
    05132
    05133         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05134                 this->staticInterfaceName(), QLatin1String("AbortSASL"));
    05135         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(debugMessage);
    05136         return this->connection().asyncCall(callMessage, timeout);
    05137     }
    05138
    05139 Q_SIGNALS:
    05157     void SASLStatusChanged(uint status, const QString& reason, const QVariantMap& details);
    05158
    05178     void NewChallenge(const QByteArray& challengeData);
    05179
    05180 protected:
    05181     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05182 };
    05183
    05191 class TP_QT_EXPORT ChannelInterfaceSMSInterface : public Tp::AbstractInterface
    05192 {
    05193     Q_OBJECT
    05194
    05195 public:
    05202     static inline QLatin1String staticInterfaceName()
    05203     {
    05204         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.SMS");
    05205     }
    05206
    05214     ChannelInterfaceSMSInterface(
    05215         const QString& busName,
    05216         const QString& objectPath,
    05217         QObject* parent = 0
    05218     );
    05219
    05228     ChannelInterfaceSMSInterface(
    05229         const QDBusConnection& connection,
    05230         const QString& busName,
    05231         const QString& objectPath,
    05232         QObject* parent = 0
    05233     );
    05234
    05241     ChannelInterfaceSMSInterface(Tp::DBusProxy *proxy);
    05242
    05250     explicit ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface);
    05251
    05259     ChannelInterfaceSMSInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05260
    05300     inline Tp::PendingVariant *requestPropertyFlash() const
    05301     {
    05302         return internalRequestProperty(QLatin1String("Flash"));
    05303     }
    05304
    05367     inline Tp::PendingVariant *requestPropertySMSChannel() const
    05368     {
    05369         return internalRequestProperty(QLatin1String("SMSChannel"));
    05370     }
    05371
    05378     Tp::PendingVariantMap *requestAllProperties() const
    05379     {
    05380         return internalRequestAllProperties();
    05381     }
    05382
    05383 public Q_SLOTS:
    05448     inline QDBusPendingReply<uint, int, int> GetSMSLength(const Tp::MessagePartList& message, int timeout = -1)
    05449     {
    05450         if (!invalidationReason().isEmpty()) {
    05451             return QDBusPendingReply<uint, int, int>(QDBusMessage::createError(
    05452                 invalidationReason(),
    05453                 invalidationMessage()
    05454             ));
    05455         }
    05456
    05457         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05458                 this->staticInterfaceName(), QLatin1String("GetSMSLength"));
    05459         callMessage << QVariant::fromValue(message);
    05460         return this->connection().asyncCall(callMessage, timeout);
    05461     }
    05462
    05463 Q_SIGNALS:
    05473     void SMSChannelChanged(bool SMSChannel);
    05474
    05475 protected:
    05476     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05477 };
    05478
    05486 class TP_QT_EXPORT ChannelInterfaceSecurableInterface : public Tp::AbstractInterface
    05487 {
    05488     Q_OBJECT
    05489
    05490 public:
    05497     static inline QLatin1String staticInterfaceName()
    05498     {
    05499         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Securable");
    05500     }
    05501
    05509     ChannelInterfaceSecurableInterface(
    05510         const QString& busName,
    05511         const QString& objectPath,
    05512         QObject* parent = 0
    05513     );
    05514
    05523     ChannelInterfaceSecurableInterface(
    05524         const QDBusConnection& connection,
    05525         const QString& busName,
    05526         const QString& objectPath,
    05527         QObject* parent = 0
    05528     );
    05529
    05536     ChannelInterfaceSecurableInterface(Tp::DBusProxy *proxy);
    05537
    05545     explicit ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface);
    05546
    05554     ChannelInterfaceSecurableInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05555
    05577     inline Tp::PendingVariant *requestPropertyEncrypted() const
    05578     {
    05579         return internalRequestProperty(QLatin1String("Encrypted"));
    05580     }
    05581
    05598     inline Tp::PendingVariant *requestPropertyVerified() const
    05599     {
    05600         return internalRequestProperty(QLatin1String("Verified"));
    05601     }
    05602
    05609     Tp::PendingVariantMap *requestAllProperties() const
    05610     {
    05611         return internalRequestAllProperties();
    05612     }
    05613
    05614 protected:
    05615     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05616 };
    05617
    05625 class TP_QT_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
    05626 {
    05627     Q_OBJECT
    05628
    05629 public:
    05636     static inline QLatin1String staticInterfaceName()
    05637     {
    05638         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.ServicePoint");
    05639     }
    05640
    05648     ChannelInterfaceServicePointInterface(
    05649         const QString& busName,
    05650         const QString& objectPath,
    05651         QObject* parent = 0
    05652     );
    05653
    05662     ChannelInterfaceServicePointInterface(
    05663         const QDBusConnection& connection,
    05664         const QString& busName,
    05665         const QString& objectPath,
    05666         QObject* parent = 0
    05667     );
    05668
    05675     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
    05676
    05684     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
    05685
    05693     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05694
    05714     inline Tp::PendingVariant *requestPropertyInitialServicePoint() const
    05715     {
    05716         return internalRequestProperty(QLatin1String("InitialServicePoint"));
    05717     }
    05718
    05731     inline Tp::PendingVariant *requestPropertyCurrentServicePoint() const
    05732     {
    05733         return internalRequestProperty(QLatin1String("CurrentServicePoint"));
    05734     }
    05735
    05742     Tp::PendingVariantMap *requestAllProperties() const
    05743     {
    05744         return internalRequestAllProperties();
    05745     }
    05746
    05747 Q_SIGNALS:
    05764     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
    05765
    05766 protected:
    05767     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05768 };
    05769
    05777 class TP_QT_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
    05778 {
    05779     Q_OBJECT
    05780
    05781 public:
    05788     static inline QLatin1String staticInterfaceName()
    05789     {
    05790         return QLatin1String("org.freedesktop.Telepathy.Channel.Interface.Tube");
    05791     }
    05792
    05800     ChannelInterfaceTubeInterface(
    05801         const QString& busName,
    05802         const QString& objectPath,
    05803         QObject* parent = 0
    05804     );
    05805
    05814     ChannelInterfaceTubeInterface(
    05815         const QDBusConnection& connection,
    05816         const QString& busName,
    05817         const QString& objectPath,
    05818         QObject* parent = 0
    05819     );
    05820
    05827     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
    05828
    05836     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    05837
    05845     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    05846
    05892     inline Tp::PendingVariant *requestPropertyParameters() const
    05893     {
    05894         return internalRequestProperty(QLatin1String("Parameters"));
    05895     }
    05896
    05912     inline Tp::PendingVariant *requestPropertyState() const
    05913     {
    05914         return internalRequestProperty(QLatin1String("State"));
    05915     }
    05916
    05923     Tp::PendingVariantMap *requestAllProperties() const
    05924     {
    05925         return internalRequestAllProperties();
    05926     }
    05927
    05928 Q_SIGNALS:
    05939     void TubeChannelStateChanged(uint state);
    05940
    05941 protected:
    05942     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05943 };
    05944
    05952 class TP_QT_EXPORT ChannelTypeCallInterface : public Tp::AbstractInterface
    05953 {
    05954     Q_OBJECT
    05955
    05956 public:
    05963     static inline QLatin1String staticInterfaceName()
    05964     {
    05965         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Call1");
    05966     }
    05967
    05975     ChannelTypeCallInterface(
    05976         const QString& busName,
    05977         const QString& objectPath,
    05978         QObject* parent = 0
    05979     );
    05980
    05989     ChannelTypeCallInterface(
    05990         const QDBusConnection& connection,
    05991         const QString& busName,
    05992         const QString& objectPath,
    05993         QObject* parent = 0
    05994     );
    05995
    06002     ChannelTypeCallInterface(Tp::DBusProxy *proxy);
    06003
    06011     explicit ChannelTypeCallInterface(const Tp::Client::ChannelInterface& mainInterface);
    06012
    06020     ChannelTypeCallInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    06021
    06037     inline Tp::PendingVariant *requestPropertyContents() const
    06038     {
    06039         return internalRequestProperty(QLatin1String("Contents"));
    06040     }
    06041
    06105     inline Tp::PendingVariant *requestPropertyCallStateDetails() const
    06106     {
    06107         return internalRequestProperty(QLatin1String("CallStateDetails"));
    06108     }
    06109
    06134     inline Tp::PendingVariant *requestPropertyCallState() const
    06135     {
    06136         return internalRequestProperty(QLatin1String("CallState"));
    06137     }
    06138
    06158     inline Tp::PendingVariant *requestPropertyCallFlags() const
    06159     {
    06160         return internalRequestProperty(QLatin1String("CallFlags"));
    06161     }
    06162
    06178     inline Tp::PendingVariant *requestPropertyCallStateReason() const
    06179     {
    06180         return internalRequestProperty(QLatin1String("CallStateReason"));
    06181     }
    06182
    06216     inline Tp::PendingVariant *requestPropertyHardwareStreaming() const
    06217     {
    06218         return internalRequestProperty(QLatin1String("HardwareStreaming"));
    06219     }
    06220
    06246     inline Tp::PendingVariant *requestPropertyCallMembers() const
    06247     {
    06248         return internalRequestProperty(QLatin1String("CallMembers"));
    06249     }
    06250
    06262     inline Tp::PendingVariant *requestPropertyMemberIdentifiers() const
    06263     {
    06264         return internalRequestProperty(QLatin1String("MemberIdentifiers"));
    06265     }
    06266
    06288     inline Tp::PendingVariant *requestPropertyInitialTransport() const
    06289     {
    06290         return internalRequestProperty(QLatin1String("InitialTransport"));
    06291     }
    06292
    06362     inline Tp::PendingVariant *requestPropertyInitialAudio() const
    06363     {
    06364         return internalRequestProperty(QLatin1String("InitialAudio"));
    06365     }
    06366
    06387     inline Tp::PendingVariant *requestPropertyInitialVideo() const
    06388     {
    06389         return internalRequestProperty(QLatin1String("InitialVideo"));
    06390     }
    06391
    06419     inline Tp::PendingVariant *requestPropertyInitialAudioName() const
    06420     {
    06421         return internalRequestProperty(QLatin1String("InitialAudioName"));
    06422     }
    06423
    06439     inline Tp::PendingVariant *requestPropertyInitialVideoName() const
    06440     {
    06441         return internalRequestProperty(QLatin1String("InitialVideoName"));
    06442     }
    06443
    06475     inline Tp::PendingVariant *requestPropertyMutableContents() const
    06476     {
    06477         return internalRequestProperty(QLatin1String("MutableContents"));
    06478     }
    06479
    06486     Tp::PendingVariantMap *requestAllProperties() const
    06487     {
    06488         return internalRequestAllProperties();
    06489     }
    06490
    06491 public Q_SLOTS:
    06520     inline QDBusPendingReply<> SetRinging(int timeout = -1)
    06521     {
    06522         if (!invalidationReason().isEmpty()) {
    06523             return QDBusPendingReply<>(QDBusMessage::createError(
    06524                 invalidationReason(),
    06525                 invalidationMessage()
    06526             ));
    06527         }
    06528
    06529         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06530                 this->staticInterfaceName(), QLatin1String("SetRinging"));
    06531         return this->connection().asyncCall(callMessage, timeout);
    06532     }
    06533
    06564     inline QDBusPendingReply<> SetQueued(int timeout = -1)
    06565     {
    06566         if (!invalidationReason().isEmpty()) {
    06567             return QDBusPendingReply<>(QDBusMessage::createError(
    06568                 invalidationReason(),
    06569                 invalidationMessage()
    06570             ));
    06571         }
    06572
    06573         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06574                 this->staticInterfaceName(), QLatin1String("SetQueued"));
    06575         return this->connection().asyncCall(callMessage, timeout);
    06576     }
    06577
    06612     inline QDBusPendingReply<> Accept(int timeout = -1)
    06613     {
    06614         if (!invalidationReason().isEmpty()) {
    06615             return QDBusPendingReply<>(QDBusMessage::createError(
    06616                 invalidationReason(),
    06617                 invalidationMessage()
    06618             ));
    06619         }
    06620
    06621         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06622                 this->staticInterfaceName(), QLatin1String("Accept"));
    06623         return this->connection().asyncCall(callMessage, timeout);
    06624     }
    06625
    06651     inline QDBusPendingReply<> Hangup(uint reason, const QString& detailedHangupReason, const QString& message, int timeout = -1)
    06652     {
    06653         if (!invalidationReason().isEmpty()) {
    06654             return QDBusPendingReply<>(QDBusMessage::createError(
    06655                 invalidationReason(),
    06656                 invalidationMessage()
    06657             ));
    06658         }
    06659
    06660         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06661                 this->staticInterfaceName(), QLatin1String("Hangup"));
    06662         callMessage << QVariant::fromValue(reason) << QVariant::fromValue(detailedHangupReason) << QVariant::fromValue(message);
    06663         return this->connection().asyncCall(callMessage, timeout);
    06664     }
    06665
    06704     inline QDBusPendingReply<QDBusObjectPath> AddContent(const QString& contentName, uint contentType, uint initialDirection, int timeout = -1)
    06705     {
    06706         if (!invalidationReason().isEmpty()) {
    06707             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
    06708                 invalidationReason(),
    06709                 invalidationMessage()
    06710             ));
    06711         }
    06712
    06713         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06714                 this->staticInterfaceName(), QLatin1String("AddContent"));
    06715         callMessage << QVariant::fromValue(contentName) << QVariant::fromValue(contentType) << QVariant::fromValue(initialDirection);
    06716         return this->connection().asyncCall(callMessage, timeout);
    06717     }
    06718
    06719 Q_SIGNALS:
    06731     void ContentAdded(const QDBusObjectPath& content);
    06732
    06748     void ContentRemoved(const QDBusObjectPath& content, const Tp::CallStateReason& reason);
    06749
    06777     void CallStateChanged(uint callState, uint callFlags, const Tp::CallStateReason& callStateReason, const QVariantMap& callStateDetails);
    06778
    06807     void CallMembersChanged(const Tp::CallMemberMap& flagsChanged, const Tp::HandleIdentifierMap& identifiers, const Tp::UIntList& removed, const Tp::CallStateReason& reason);
    06808
    06809 protected:
    06810     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06811 };
    06812
    06820 class TP_QT_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
    06821 {
    06822     Q_OBJECT
    06823
    06824 public:
    06831     static inline QLatin1String staticInterfaceName()
    06832     {
    06833         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactList");
    06834     }
    06835
    06843     ChannelTypeContactListInterface(
    06844         const QString& busName,
    06845         const QString& objectPath,
    06846         QObject* parent = 0
    06847     );
    06848
    06857     ChannelTypeContactListInterface(
    06858         const QDBusConnection& connection,
    06859         const QString& busName,
    06860         const QString& objectPath,
    06861         QObject* parent = 0
    06862     );
    06863
    06870     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
    06871
    06879     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
    06880
    06888     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    06889
    06896     Tp::PendingVariantMap *requestAllProperties() const
    06897     {
    06898         return internalRequestAllProperties();
    06899     }
    06900
    06901 protected:
    06902     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06903 };
    06904
    06912 class TP_QT_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
    06913 {
    06914     Q_OBJECT
    06915
    06916 public:
    06923     static inline QLatin1String staticInterfaceName()
    06924     {
    06925         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ContactSearch");
    06926     }
    06927
    06935     ChannelTypeContactSearchInterface(
    06936         const QString& busName,
    06937         const QString& objectPath,
    06938         QObject* parent = 0
    06939     );
    06940
    06949     ChannelTypeContactSearchInterface(
    06950         const QDBusConnection& connection,
    06951         const QString& busName,
    06952         const QString& objectPath,
    06953         QObject* parent = 0
    06954     );
    06955
    06962     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
    06963
    06971     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
    06972
    06980     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    06981
    06992     inline Tp::PendingVariant *requestPropertySearchState() const
    06993     {
    06994         return internalRequestProperty(QLatin1String("SearchState"));
    06995     }
    06996
    07022     inline Tp::PendingVariant *requestPropertyLimit() const
    07023     {
    07024         return internalRequestProperty(QLatin1String("Limit"));
    07025     }
    07026
    07041     inline Tp::PendingVariant *requestPropertyAvailableSearchKeys() const
    07042     {
    07043         return internalRequestProperty(QLatin1String("AvailableSearchKeys"));
    07044     }
    07045
    07066     inline Tp::PendingVariant *requestPropertyServer() const
    07067     {
    07068         return internalRequestProperty(QLatin1String("Server"));
    07069     }
    07070
    07077     Tp::PendingVariantMap *requestAllProperties() const
    07078     {
    07079         return internalRequestAllProperties();
    07080     }
    07081
    07082 public Q_SLOTS:
    07100     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms, int timeout = -1)
    07101     {
    07102         if (!invalidationReason().isEmpty()) {
    07103             return QDBusPendingReply<>(QDBusMessage::createError(
    07104                 invalidationReason(),
    07105                 invalidationMessage()
    07106             ));
    07107         }
    07108
    07109         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07110                 this->staticInterfaceName(), QLatin1String("Search"));
    07111         callMessage << QVariant::fromValue(terms);
    07112         return this->connection().asyncCall(callMessage, timeout);
    07113     }
    07114
    07129     inline QDBusPendingReply<> More(int timeout = -1)
    07130     {
    07131         if (!invalidationReason().isEmpty()) {
    07132             return QDBusPendingReply<>(QDBusMessage::createError(
    07133                 invalidationReason(),
    07134                 invalidationMessage()
    07135             ));
    07136         }
    07137
    07138         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07139                 this->staticInterfaceName(), QLatin1String("More"));
    07140         return this->connection().asyncCall(callMessage, timeout);
    07141     }
    07142
    07175     inline QDBusPendingReply<> Stop(int timeout = -1)
    07176     {
    07177         if (!invalidationReason().isEmpty()) {
    07178             return QDBusPendingReply<>(QDBusMessage::createError(
    07179                 invalidationReason(),
    07180                 invalidationMessage()
    07181             ));
    07182         }
    07183
    07184         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07185                 this->staticInterfaceName(), QLatin1String("Stop"));
    07186         return this->connection().asyncCall(callMessage, timeout);
    07187     }
    07188
    07189 Q_SIGNALS:
    07239     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
    07240
    07253     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
    07254
    07255 protected:
    07256     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07257 };
    07258
    07266 class TP_QT_EXPORT ChannelTypeDBusTubeInterface : public Tp::AbstractInterface
    07267 {
    07268     Q_OBJECT
    07269
    07270 public:
    07277     static inline QLatin1String staticInterfaceName()
    07278     {
    07279         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.DBusTube");
    07280     }
    07281
    07289     ChannelTypeDBusTubeInterface(
    07290         const QString& busName,
    07291         const QString& objectPath,
    07292         QObject* parent = 0
    07293     );
    07294
    07303     ChannelTypeDBusTubeInterface(
    07304         const QDBusConnection& connection,
    07305         const QString& busName,
    07306         const QString& objectPath,
    07307         QObject* parent = 0
    07308     );
    07309
    07316     ChannelTypeDBusTubeInterface(Tp::DBusProxy *proxy);
    07317
    07325     explicit ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    07326
    07334     ChannelTypeDBusTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    07335
    07354     inline Tp::PendingVariant *requestPropertyServiceName() const
    07355     {
    07356         return internalRequestProperty(QLatin1String("ServiceName"));
    07357     }
    07358
    07371     inline Tp::PendingVariant *requestPropertyDBusNames() const
    07372     {
    07373         return internalRequestProperty(QLatin1String("DBusNames"));
    07374     }
    07375
    07403     inline Tp::PendingVariant *requestPropertySupportedAccessControls() const
    07404     {
    07405         return internalRequestProperty(QLatin1String("SupportedAccessControls"));
    07406     }
    07407
    07414     Tp::PendingVariantMap *requestAllProperties() const
    07415     {
    07416         return internalRequestAllProperties();
    07417     }
    07418
    07419 public Q_SLOTS:
    07444     inline QDBusPendingReply<QString> Offer(const QVariantMap& parameters, uint accesscontrol, int timeout = -1)
    07445     {
    07446         if (!invalidationReason().isEmpty()) {
    07447             return QDBusPendingReply<QString>(QDBusMessage::createError(
    07448                 invalidationReason(),
    07449                 invalidationMessage()
    07450             ));
    07451         }
    07452
    07453         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07454                 this->staticInterfaceName(), QLatin1String("Offer"));
    07455         callMessage << QVariant::fromValue(parameters) << QVariant::fromValue(accesscontrol);
    07456         return this->connection().asyncCall(callMessage, timeout);
    07457     }
    07458
    07482     inline QDBusPendingReply<QString> Accept(uint accesscontrol, int timeout = -1)
    07483     {
    07484         if (!invalidationReason().isEmpty()) {
    07485             return QDBusPendingReply<QString>(QDBusMessage::createError(
    07486                 invalidationReason(),
    07487                 invalidationMessage()
    07488             ));
    07489         }
    07490
    07491         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07492                 this->staticInterfaceName(), QLatin1String("Accept"));
    07493         callMessage << QVariant::fromValue(accesscontrol);
    07494         return this->connection().asyncCall(callMessage, timeout);
    07495     }
    07496
    07497 Q_SIGNALS:
    07513     void DBusNamesChanged(const Tp::DBusTubeParticipants& added, const Tp::UIntList& removed);
    07514
    07515 protected:
    07516     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07517 };
    07518
    07526 class TP_QT_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
    07527 {
    07528     Q_OBJECT
    07529
    07530 public:
    07537     static inline QLatin1String staticInterfaceName()
    07538     {
    07539         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.FileTransfer");
    07540     }
    07541
    07549     ChannelTypeFileTransferInterface(
    07550         const QString& busName,
    07551         const QString& objectPath,
    07552         QObject* parent = 0
    07553     );
    07554
    07563     ChannelTypeFileTransferInterface(
    07564         const QDBusConnection& connection,
    07565         const QString& busName,
    07566         const QString& objectPath,
    07567         QObject* parent = 0
    07568     );
    07569
    07576     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
    07577
    07585     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
    07586
    07594     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    07595
    07608     inline Tp::PendingVariant *requestPropertyState() const
    07609     {
    07610         return internalRequestProperty(QLatin1String("State"));
    07611     }
    07612
    07630     inline Tp::PendingVariant *requestPropertyContentType() const
    07631     {
    07632         return internalRequestProperty(QLatin1String("ContentType"));
    07633     }
    07634
    07656     inline Tp::PendingVariant *requestPropertyFilename() const
    07657     {
    07658         return internalRequestProperty(QLatin1String("Filename"));
    07659     }
    07660
    07684     inline Tp::PendingVariant *requestPropertySize() const
    07685     {
    07686         return internalRequestProperty(QLatin1String("Size"));
    07687     }
    07688
    07715     inline Tp::PendingVariant *requestPropertyContentHashType() const
    07716     {
    07717         return internalRequestProperty(QLatin1String("ContentHashType"));
    07718     }
    07719
    07740     inline Tp::PendingVariant *requestPropertyContentHash() const
    07741     {
    07742         return internalRequestProperty(QLatin1String("ContentHash"));
    07743     }
    07744
    07762     inline Tp::PendingVariant *requestPropertyDescription() const
    07763     {
    07764         return internalRequestProperty(QLatin1String("Description"));
    07765     }
    07766
    07783     inline Tp::PendingVariant *requestPropertyDate() const
    07784     {
    07785         return internalRequestProperty(QLatin1String("Date"));
    07786     }
    07787
    07816     inline Tp::PendingVariant *requestPropertyAvailableSocketTypes() const
    07817     {
    07818         return internalRequestProperty(QLatin1String("AvailableSocketTypes"));
    07819     }
    07820
    07834     inline Tp::PendingVariant *requestPropertyTransferredBytes() const
    07835     {
    07836         return internalRequestProperty(QLatin1String("TransferredBytes"));
    07837     }
    07838
    07861     inline Tp::PendingVariant *requestPropertyInitialOffset() const
    07862     {
    07863         return internalRequestProperty(QLatin1String("InitialOffset"));
    07864     }
    07865
    07901     inline Tp::PendingVariant *requestPropertyURI() const
    07902     {
    07903         return internalRequestProperty(QLatin1String("URI"));
    07904     }
    07905
    07941     inline Tp::PendingOperation *setPropertyURI(QString newValue)
    07942     {
    07943         return internalSetProperty(QLatin1String("URI"), QVariant::fromValue(newValue));
    07944     }
    07945
    07952     Tp::PendingVariantMap *requestAllProperties() const
    07953     {
    07954         return internalRequestAllProperties();
    07955     }
    07956
    07957 public Q_SLOTS:
    08002     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset, int timeout = -1)
    08003     {
    08004         if (!invalidationReason().isEmpty()) {
    08005             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    08006                 invalidationReason(),
    08007                 invalidationMessage()
    08008             ));
    08009         }
    08010
    08011         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08012                 this->staticInterfaceName(), QLatin1String("AcceptFile"));
    08013         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
    08014         return this->connection().asyncCall(callMessage, timeout);
    08015     }
    08016
    08050     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
    08051     {
    08052         if (!invalidationReason().isEmpty()) {
    08053             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    08054                 invalidationReason(),
    08055                 invalidationMessage()
    08056             ));
    08057         }
    08058
    08059         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08060                 this->staticInterfaceName(), QLatin1String("ProvideFile"));
    08061         callMessage << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    08062         return this->connection().asyncCall(callMessage, timeout);
    08063     }
    08064
    08065 Q_SIGNALS:
    08083     void FileTransferStateChanged(uint state, uint reason);
    08084
    08097     void TransferredBytesChanged(qulonglong count);
    08098
    08110     void InitialOffsetDefined(qulonglong initialOffset);
    08111
    08123     void URIDefined(const QString& URI);
    08124
    08125 protected:
    08126     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    08127 };
    08128
    08136 class TP_QT_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
    08137 {
    08138     Q_OBJECT
    08139
    08140 public:
    08147     static inline QLatin1String staticInterfaceName()
    08148     {
    08149         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.RoomList");
    08150     }
    08151
    08159     ChannelTypeRoomListInterface(
    08160         const QString& busName,
    08161         const QString& objectPath,
    08162         QObject* parent = 0
    08163     );
    08164
    08173     ChannelTypeRoomListInterface(
    08174         const QDBusConnection& connection,
    08175         const QString& busName,
    08176         const QString& objectPath,
    08177         QObject* parent = 0
    08178     );
    08179
    08186     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
    08187
    08195     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
    08196
    08204     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    08205
    08219     inline Tp::PendingVariant *requestPropertyServer() const
    08220     {
    08221         return internalRequestProperty(QLatin1String("Server"));
    08222     }
    08223
    08230     Tp::PendingVariantMap *requestAllProperties() const
    08231     {
    08232         return internalRequestAllProperties();
    08233     }
    08234
    08235 public Q_SLOTS:
    08251     inline QDBusPendingReply<bool> GetListingRooms(int timeout = -1)
    08252     {
    08253         if (!invalidationReason().isEmpty()) {
    08254             return QDBusPendingReply<bool>(QDBusMessage::createError(
    08255                 invalidationReason(),
    08256                 invalidationMessage()
    08257             ));
    08258         }
    08259
    08260         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08261                 this->staticInterfaceName(), QLatin1String("GetListingRooms"));
    08262         return this->connection().asyncCall(callMessage, timeout);
    08263     }
    08264
    08278     inline QDBusPendingReply<> ListRooms(int timeout = -1)
    08279     {
    08280         if (!invalidationReason().isEmpty()) {
    08281             return QDBusPendingReply<>(QDBusMessage::createError(
    08282                 invalidationReason(),
    08283                 invalidationMessage()
    08284             ));
    08285         }
    08286
    08287         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08288                 this->staticInterfaceName(), QLatin1String("ListRooms"));
    08289         return this->connection().asyncCall(callMessage, timeout);
    08290     }
    08291
    08304     inline QDBusPendingReply<> StopListing(int timeout = -1)
    08305     {
    08306         if (!invalidationReason().isEmpty()) {
    08307             return QDBusPendingReply<>(QDBusMessage::createError(
    08308                 invalidationReason(),
    08309                 invalidationMessage()
    08310             ));
    08311         }
    08312
    08313         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08314                 this->staticInterfaceName(), QLatin1String("StopListing"));
    08315         return this->connection().asyncCall(callMessage, timeout);
    08316     }
    08317
    08318 Q_SIGNALS:
    08376     void GotRooms(const Tp::RoomInfoList& rooms);
    08377
    08388     void ListingRooms(bool listing);
    08389
    08390 protected:
    08391     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    08392 };
    08393
    08401 class TP_QT_EXPORT ChannelTypeServerAuthenticationInterface : public Tp::AbstractInterface
    08402 {
    08403     Q_OBJECT
    08404
    08405 public:
    08412     static inline QLatin1String staticInterfaceName()
    08413     {
    08414         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerAuthentication");
    08415     }
    08416
    08424     ChannelTypeServerAuthenticationInterface(
    08425         const QString& busName,
    08426         const QString& objectPath,
    08427         QObject* parent = 0
    08428     );
    08429
    08438     ChannelTypeServerAuthenticationInterface(
    08439         const QDBusConnection& connection,
    08440         const QString& busName,
    08441         const QString& objectPath,
    08442         QObject* parent = 0
    08443     );
    08444
    08451     ChannelTypeServerAuthenticationInterface(Tp::DBusProxy *proxy);
    08452
    08460     explicit ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface);
    08461
    08469     ChannelTypeServerAuthenticationInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    08470
    08487     inline Tp::PendingVariant *requestPropertyAuthenticationMethod() const
    08488     {
    08489         return internalRequestProperty(QLatin1String("AuthenticationMethod"));
    08490     }
    08491
    08498     Tp::PendingVariantMap *requestAllProperties() const
    08499     {
    08500         return internalRequestAllProperties();
    08501     }
    08502
    08503 protected:
    08504     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    08505 };
    08506
    08514 class TP_QT_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
    08515 {
    08516     Q_OBJECT
    08517
    08518 public:
    08525     static inline QLatin1String staticInterfaceName()
    08526     {
    08527         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection");
    08528     }
    08529
    08537     ChannelTypeServerTLSConnectionInterface(
    08538         const QString& busName,
    08539         const QString& objectPath,
    08540         QObject* parent = 0
    08541     );
    08542
    08551     ChannelTypeServerTLSConnectionInterface(
    08552         const QDBusConnection& connection,
    08553         const QString& busName,
    08554         const QString& objectPath,
    08555         QObject* parent = 0
    08556     );
    08557
    08564     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
    08565
    08573     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
    08574
    08582     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    08583
    08594     inline Tp::PendingVariant *requestPropertyServerCertificate() const
    08595     {
    08596         return internalRequestProperty(QLatin1String("ServerCertificate"));
    08597     }
    08598
    08612     inline Tp::PendingVariant *requestPropertyHostname() const
    08613     {
    08614         return internalRequestProperty(QLatin1String("Hostname"));
    08615     }
    08616
    08643     inline Tp::PendingVariant *requestPropertyReferenceIdentities() const
    08644     {
    08645         return internalRequestProperty(QLatin1String("ReferenceIdentities"));
    08646     }
    08647
    08654     Tp::PendingVariantMap *requestAllProperties() const
    08655     {
    08656         return internalRequestAllProperties();
    08657     }
    08658
    08659 protected:
    08660     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    08661 };
    08662
    08670 class TP_QT_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
    08671 {
    08672     Q_OBJECT
    08673
    08674 public:
    08681     static inline QLatin1String staticInterfaceName()
    08682     {
    08683         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamTube");
    08684     }
    08685
    08693     ChannelTypeStreamTubeInterface(
    08694         const QString& busName,
    08695         const QString& objectPath,
    08696         QObject* parent = 0
    08697     );
    08698
    08707     ChannelTypeStreamTubeInterface(
    08708         const QDBusConnection& connection,
    08709         const QString& busName,
    08710         const QString& objectPath,
    08711         QObject* parent = 0
    08712     );
    08713
    08720     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
    08721
    08729     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    08730
    08738     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    08739
    08762     inline Tp::PendingVariant *requestPropertyService() const
    08763     {
    08764         return internalRequestProperty(QLatin1String("Service"));
    08765     }
    08766
    08801     inline Tp::PendingVariant *requestPropertySupportedSocketTypes() const
    08802     {
    08803         return internalRequestProperty(QLatin1String("SupportedSocketTypes"));
    08804     }
    08805
    08812     Tp::PendingVariantMap *requestAllProperties() const
    08813     {
    08814         return internalRequestAllProperties();
    08815     }
    08816
    08817 public Q_SLOTS:
    08848     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters, int timeout = -1)
    08849     {
    08850         if (!invalidationReason().isEmpty()) {
    08851             return QDBusPendingReply<>(QDBusMessage::createError(
    08852                 invalidationReason(),
    08853                 invalidationMessage()
    08854             ));
    08855         }
    08856
    08857         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08858                 this->staticInterfaceName(), QLatin1String("Offer"));
    08859         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
    08860         return this->connection().asyncCall(callMessage, timeout);
    08861     }
    08862
    08903     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam, int timeout = -1)
    08904     {
    08905         if (!invalidationReason().isEmpty()) {
    08906             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    08907                 invalidationReason(),
    08908                 invalidationMessage()
    08909             ));
    08910         }
    08911
    08912         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    08913                 this->staticInterfaceName(), QLatin1String("Accept"));
    08914         callMessage << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
    08915         return this->connection().asyncCall(callMessage, timeout);
    08916     }
    08917
    08918 Q_SIGNALS:
    08959     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
    08960
    08976     void NewLocalConnection(uint connectionID);
    08977
    09009     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
    09010
    09011 protected:
    09012     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    09013 };
    09014
    09022 class TP_QT_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
    09023 {
    09024     Q_OBJECT
    09025
    09026 public:
    09033     static inline QLatin1String staticInterfaceName()
    09034     {
    09035         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.StreamedMedia");
    09036     }
    09037
    09045     ChannelTypeStreamedMediaInterface(
    09046         const QString& busName,
    09047         const QString& objectPath,
    09048         QObject* parent = 0
    09049     );
    09050
    09059     ChannelTypeStreamedMediaInterface(
    09060         const QDBusConnection& connection,
    09061         const QString& busName,
    09062         const QString& objectPath,
    09063         QObject* parent = 0
    09064     );
    09065
    09072     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
    09073
    09081     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
    09082
    09090     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    09091
    09180     inline Tp::PendingVariant *requestPropertyInitialAudio() const
    09181     {
    09182         return internalRequestProperty(QLatin1String("InitialAudio"));
    09183     }
    09184
    09205     inline Tp::PendingVariant *requestPropertyInitialVideo() const
    09206     {
    09207         return internalRequestProperty(QLatin1String("InitialVideo"));
    09208     }
    09209
    09252     inline Tp::PendingVariant *requestPropertyImmutableStreams() const
    09253     {
    09254         return internalRequestProperty(QLatin1String("ImmutableStreams"));
    09255     }
    09256
    09263     Tp::PendingVariantMap *requestAllProperties() const
    09264     {
    09265         return internalRequestAllProperties();
    09266     }
    09267
    09268 public Q_SLOTS:
    09296     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams(int timeout = -1)
    09297     {
    09298         if (!invalidationReason().isEmpty()) {
    09299             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    09300                 invalidationReason(),
    09301                 invalidationMessage()
    09302             ));
    09303         }
    09304
    09305         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09306                 this->staticInterfaceName(), QLatin1String("ListStreams"));
    09307         return this->connection().asyncCall(callMessage, timeout);
    09308     }
    09309
    09336     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams, int timeout = -1)
    09337     {
    09338         if (!invalidationReason().isEmpty()) {
    09339             return QDBusPendingReply<>(QDBusMessage::createError(
    09340                 invalidationReason(),
    09341                 invalidationMessage()
    09342             ));
    09343         }
    09344
    09345         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09346                 this->staticInterfaceName(), QLatin1String("RemoveStreams"));
    09347         callMessage << QVariant::fromValue(streams);
    09348         return this->connection().asyncCall(callMessage, timeout);
    09349     }
    09350
    09387     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection, int timeout = -1)
    09388     {
    09389         if (!invalidationReason().isEmpty()) {
    09390             return QDBusPendingReply<>(QDBusMessage::createError(
    09391                 invalidationReason(),
    09392                 invalidationMessage()
    09393             ));
    09394         }
    09395
    09396         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09397                 this->staticInterfaceName(), QLatin1String("RequestStreamDirection"));
    09398         callMessage << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
    09399         return this->connection().asyncCall(callMessage, timeout);
    09400     }
    09401
    09454     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types, int timeout = -1)
    09455     {
    09456         if (!invalidationReason().isEmpty()) {
    09457             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    09458                 invalidationReason(),
    09459                 invalidationMessage()
    09460             ));
    09461         }
    09462
    09463         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09464                 this->staticInterfaceName(), QLatin1String("RequestStreams"));
    09465         callMessage << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
    09466         return this->connection().asyncCall(callMessage, timeout);
    09467     }
    09468
    09469 Q_SIGNALS:
    09536     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
    09537
    09569     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
    09570
    09588     void StreamError(uint streamID, uint errorCode, const QString& message);
    09589
    09599     void StreamRemoved(uint streamID);
    09600
    09614     void StreamStateChanged(uint streamID, uint streamState);
    09615
    09616 protected:
    09617     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    09618 };
    09619
    09627 class TP_QT_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
    09628 {
    09629     Q_OBJECT
    09630
    09631 public:
    09638     static inline QLatin1String staticInterfaceName()
    09639     {
    09640         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Text");
    09641     }
    09642
    09650     ChannelTypeTextInterface(
    09651         const QString& busName,
    09652         const QString& objectPath,
    09653         QObject* parent = 0
    09654     );
    09655
    09664     ChannelTypeTextInterface(
    09665         const QDBusConnection& connection,
    09666         const QString& busName,
    09667         const QString& objectPath,
    09668         QObject* parent = 0
    09669     );
    09670
    09677     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
    09678
    09686     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
    09687
    09695     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    09696
    09703     Tp::PendingVariantMap *requestAllProperties() const
    09704     {
    09705         return internalRequestAllProperties();
    09706     }
    09707
    09708 public Q_SLOTS:
    09724     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs, int timeout = -1)
    09725     {
    09726         if (!invalidationReason().isEmpty()) {
    09727             return QDBusPendingReply<>(QDBusMessage::createError(
    09728                 invalidationReason(),
    09729                 invalidationMessage()
    09730             ));
    09731         }
    09732
    09733         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09734                 this->staticInterfaceName(), QLatin1String("AcknowledgePendingMessages"));
    09735         callMessage << QVariant::fromValue(IDs);
    09736         return this->connection().asyncCall(callMessage, timeout);
    09737     }
    09738
    09754     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes(int timeout = -1)
    09755     {
    09756         if (!invalidationReason().isEmpty()) {
    09757             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    09758                 invalidationReason(),
    09759                 invalidationMessage()
    09760             ));
    09761         }
    09762
    09763         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09764                 this->staticInterfaceName(), QLatin1String("GetMessageTypes"));
    09765         return this->connection().asyncCall(callMessage, timeout);
    09766     }
    09767
    09798     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear, int timeout = -1)
    09799     {
    09800         if (!invalidationReason().isEmpty()) {
    09801             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
    09802                 invalidationReason(),
    09803                 invalidationMessage()
    09804             ));
    09805         }
    09806
    09807         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09808                 this->staticInterfaceName(), QLatin1String("ListPendingMessages"));
    09809         callMessage << QVariant::fromValue(clear);
    09810         return this->connection().asyncCall(callMessage, timeout);
    09811     }
    09812
    09845     inline QDBusPendingReply<> Send(uint type, const QString& text, int timeout = -1)
    09846     {
    09847         if (!invalidationReason().isEmpty()) {
    09848             return QDBusPendingReply<>(QDBusMessage::createError(
    09849                 invalidationReason(),
    09850                 invalidationMessage()
    09851             ));
    09852         }
    09853
    09854         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    09855                 this->staticInterfaceName(), QLatin1String("Send"));
    09856         callMessage << QVariant::fromValue(type) << QVariant::fromValue(text);
    09857         return this->connection().asyncCall(callMessage, timeout);
    09858     }
    09859
    09860 Q_SIGNALS:
    09868     void LostMessage();
    09869
    09903     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
    09904
    09933     void SendError(uint error, uint timestamp, uint type, const QString& text);
    09934
    09958     void Sent(uint timestamp, uint type, const QString& text);
    09959
    09960 protected:
    09961     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    09962 };
    09963
    09971 class TP_QT_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
    09972 {
    09973     Q_OBJECT
    09974
    09975 public:
    09982     static inline QLatin1String staticInterfaceName()
    09983     {
    09984         return QLatin1String("org.freedesktop.Telepathy.Channel.Type.Tubes");
    09985     }
    09986
    09994     ChannelTypeTubesInterface(
    09995         const QString& busName,
    09996         const QString& objectPath,
    09997         QObject* parent = 0
    09998     );
    09999
    10008     ChannelTypeTubesInterface(
    10009         const QDBusConnection& connection,
    10010         const QString& busName,
    10011         const QString& objectPath,
    10012         QObject* parent = 0
    10013     );
    10014
    10021     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
    10022
    10030     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
    10031
    10039     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    10040
    10047     Tp::PendingVariantMap *requestAllProperties() const
    10048     {
    10049         return internalRequestAllProperties();
    10050     }
    10051
    10052 public Q_SLOTS:
    10089     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes(int timeout = -1)
    10090     {
    10091         if (!invalidationReason().isEmpty()) {
    10092             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
    10093                 invalidationReason(),
    10094                 invalidationMessage()
    10095             ));
    10096         }
    10097
    10098         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10099                 this->staticInterfaceName(), QLatin1String("GetAvailableStreamTubeTypes"));
    10100         return this->connection().asyncCall(callMessage, timeout);
    10101     }
    10102
    10116     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes(int timeout = -1)
    10117     {
    10118         if (!invalidationReason().isEmpty()) {
    10119             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    10120                 invalidationReason(),
    10121                 invalidationMessage()
    10122             ));
    10123         }
    10124
    10125         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10126                 this->staticInterfaceName(), QLatin1String("GetAvailableTubeTypes"));
    10127         return this->connection().asyncCall(callMessage, timeout);
    10128     }
    10129
    10145     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes(int timeout = -1)
    10146     {
    10147         if (!invalidationReason().isEmpty()) {
    10148             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
    10149                 invalidationReason(),
    10150                 invalidationMessage()
    10151             ));
    10152         }
    10153
    10154         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10155                 this->staticInterfaceName(), QLatin1String("ListTubes"));
    10156         return this->connection().asyncCall(callMessage, timeout);
    10157     }
    10158
    10186     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters, int timeout = -1)
    10187     {
    10188         if (!invalidationReason().isEmpty()) {
    10189             return QDBusPendingReply<uint>(QDBusMessage::createError(
    10190                 invalidationReason(),
    10191                 invalidationMessage()
    10192             ));
    10193         }
    10194
    10195         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10196                 this->staticInterfaceName(), QLatin1String("OfferDBusTube"));
    10197         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters);
    10198         return this->connection().asyncCall(callMessage, timeout);
    10199     }
    10200
    10260     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
    10261     {
    10262         if (!invalidationReason().isEmpty()) {
    10263             return QDBusPendingReply<uint>(QDBusMessage::createError(
    10264                 invalidationReason(),
    10265                 invalidationMessage()
    10266             ));
    10267         }
    10268
    10269         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10270                 this->staticInterfaceName(), QLatin1String("OfferStreamTube"));
    10271         callMessage << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    10272         return this->connection().asyncCall(callMessage, timeout);
    10273     }
    10274
    10297     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID, int timeout = -1)
    10298     {
    10299         if (!invalidationReason().isEmpty()) {
    10300             return QDBusPendingReply<QString>(QDBusMessage::createError(
    10301                 invalidationReason(),
    10302                 invalidationMessage()
    10303             ));
    10304         }
    10305
    10306         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10307                 this->staticInterfaceName(), QLatin1String("AcceptDBusTube"));
    10308         callMessage << QVariant::fromValue(ID);
    10309         return this->connection().asyncCall(callMessage, timeout);
    10310     }
    10311
    10349     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam, int timeout = -1)
    10350     {
    10351         if (!invalidationReason().isEmpty()) {
    10352             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    10353                 invalidationReason(),
    10354                 invalidationMessage()
    10355             ));
    10356         }
    10357
    10358         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10359                 this->staticInterfaceName(), QLatin1String("AcceptStreamTube"));
    10360         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    10361         return this->connection().asyncCall(callMessage, timeout);
    10362     }
    10363
    10378     inline QDBusPendingReply<> CloseTube(uint ID, int timeout = -1)
    10379     {
    10380         if (!invalidationReason().isEmpty()) {
    10381             return QDBusPendingReply<>(QDBusMessage::createError(
    10382                 invalidationReason(),
    10383                 invalidationMessage()
    10384             ));
    10385         }
    10386
    10387         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10388                 this->staticInterfaceName(), QLatin1String("CloseTube"));
    10389         callMessage << QVariant::fromValue(ID);
    10390         return this->connection().asyncCall(callMessage, timeout);
    10391     }
    10392
    10412     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID, int timeout = -1)
    10413     {
    10414         if (!invalidationReason().isEmpty()) {
    10415             return QDBusPendingReply<QString>(QDBusMessage::createError(
    10416                 invalidationReason(),
    10417                 invalidationMessage()
    10418             ));
    10419         }
    10420
    10421         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10422                 this->staticInterfaceName(), QLatin1String("GetDBusTubeAddress"));
    10423         callMessage << QVariant::fromValue(ID);
    10424         return this->connection().asyncCall(callMessage, timeout);
    10425     }
    10426
    10447     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID, int timeout = -1)
    10448     {
    10449         if (!invalidationReason().isEmpty()) {
    10450             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
    10451                 invalidationReason(),
    10452                 invalidationMessage()
    10453             ));
    10454         }
    10455
    10456         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10457                 this->staticInterfaceName(), QLatin1String("GetDBusNames"));
    10458         callMessage << QVariant::fromValue(ID);
    10459         return this->connection().asyncCall(callMessage, timeout);
    10460     }
    10461
    10487     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID, int timeout = -1)
    10488     {
    10489         if (!invalidationReason().isEmpty()) {
    10490             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
    10491                 invalidationReason(),
    10492                 invalidationMessage()
    10493             ));
    10494         }
    10495
    10496         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    10497                 this->staticInterfaceName(), QLatin1String("GetStreamTubeSocketAddress"));
    10498         callMessage << QVariant::fromValue(ID);
    10499         return this->connection().asyncCall(callMessage, timeout);
    10500     }
    10501
    10502 Q_SIGNALS:
    10532     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
    10533
    10547     void TubeStateChanged(uint ID, uint state);
    10548
    10559     void TubeClosed(uint ID);
    10560
    10579     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
    10580
    10595     void StreamTubeNewConnection(uint ID, uint handle);
    10596
    10597 protected:
    10598     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    10599 };
    10600 }
    10601 }
    10602 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
    10603 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
    10604 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
    10605 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface*)
    10606 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
    10607 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
    10608 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
    10609 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDestroyableInterface*)
    10610 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceFileTransferMetadataInterface*)
    10611 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
    10612 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
    10613 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
    10614 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
    10615 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
    10616 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSASLAuthenticationInterface*)
    10617 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSMSInterface*)
    10618 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceSecurableInterface*)
    10619 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
    10620 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
    10621 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeCallInterface*)
    10622 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
    10623 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
    10624 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeDBusTubeInterface*)
    10625 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
    10626 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
    10627 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerAuthenticationInterface*)
    10628 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
    10629 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
    10630 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
    10631 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
    10632 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)