/****************************************************************************
** Meta object code from reading C++ file 'cli-channel.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.4.2)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'cli-channel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.4.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_Tp__Client__ChannelInterface_t {
    QByteArrayData data[12];
    char stringdata[197];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterface_t qt_meta_stringdata_Tp__Client__ChannelInterface = {
    {
QT_MOC_LITERAL(0, 0, 28), // "Tp::Client::ChannelInterface"
QT_MOC_LITERAL(1, 29, 6), // "Closed"
QT_MOC_LITERAL(2, 36, 0), // ""
QT_MOC_LITERAL(3, 37, 5), // "Close"
QT_MOC_LITERAL(4, 43, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(5, 63, 7), // "timeout"
QT_MOC_LITERAL(6, 71, 14), // "GetChannelType"
QT_MOC_LITERAL(7, 86, 26), // "QDBusPendingReply<QString>"
QT_MOC_LITERAL(8, 113, 9), // "GetHandle"
QT_MOC_LITERAL(9, 123, 28), // "QDBusPendingReply<uint,uint>"
QT_MOC_LITERAL(10, 152, 13), // "GetInterfaces"
QT_MOC_LITERAL(11, 166, 30) // "QDBusPendingReply<QStringList>"

    },
    "Tp::Client::ChannelInterface\0Closed\0"
    "\0Close\0QDBusPendingReply<>\0timeout\0"
    "GetChannelType\0QDBusPendingReply<QString>\0"
    "GetHandle\0QDBusPendingReply<uint,uint>\0"
    "GetInterfaces\0QDBusPendingReply<QStringList>"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       9,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    0,   59,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       3,    1,   60,    2, 0x0a /* Public */,
       3,    0,   63,    2, 0x2a /* Public | MethodCloned */,
       6,    1,   64,    2, 0x0a /* Public */,
       6,    0,   67,    2, 0x2a /* Public | MethodCloned */,
       8,    1,   68,    2, 0x0a /* Public */,
       8,    0,   71,    2, 0x2a /* Public | MethodCloned */,
      10,    1,   72,    2, 0x0a /* Public */,
      10,    0,   75,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void,

 // slots: parameters
    0x80000000 | 4, QMetaType::Int,    5,
    0x80000000 | 4,
    0x80000000 | 7, QMetaType::Int,    5,
    0x80000000 | 7,
    0x80000000 | 9, QMetaType::Int,    5,
    0x80000000 | 9,
    0x80000000 | 11, QMetaType::Int,    5,
    0x80000000 | 11,

       0        // eod
};

void Tp::Client::ChannelInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterface *_t = static_cast<ChannelInterface *>(_o);
        switch (_id) {
        case 0: _t->Closed(); break;
        case 1: { QDBusPendingReply<> _r = _t->Close((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<> _r = _t->Close();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<QString> _r = _t->GetChannelType((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<QString> _r = _t->GetChannelType();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<uint,uint> _r = _t->GetHandle((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,uint>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<uint,uint> _r = _t->GetHandle();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,uint>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<QStringList> _r = _t->GetInterfaces((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QStringList>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<QStringList> _r = _t->GetInterfaces();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QStringList>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterface::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterface::Closed)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterface.data,
      qt_meta_data_Tp__Client__ChannelInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 9)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 9;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterface::Closed()
{
    QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceAnonymityInterface_t {
    QByteArrayData data[1];
    char stringdata[47];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceAnonymityInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceAnonymityInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceAnonymityInterface = {
    {
QT_MOC_LITERAL(0, 0, 46) // "Tp::Client::ChannelInterfaceA..."

    },
    "Tp::Client::ChannelInterfaceAnonymityInterface"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceAnonymityInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Tp::Client::ChannelInterfaceAnonymityInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Tp::Client::ChannelInterfaceAnonymityInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceAnonymityInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceAnonymityInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceAnonymityInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceAnonymityInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceAnonymityInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceAnonymityInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceAnonymityInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceCallStateInterface_t {
    QByteArrayData data[8];
    char stringdata[144];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceCallStateInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceCallStateInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceCallStateInterface = {
    {
QT_MOC_LITERAL(0, 0, 46), // "Tp::Client::ChannelInterfaceC..."
QT_MOC_LITERAL(1, 47, 16), // "CallStateChanged"
QT_MOC_LITERAL(2, 64, 0), // ""
QT_MOC_LITERAL(3, 65, 7), // "contact"
QT_MOC_LITERAL(4, 73, 5), // "state"
QT_MOC_LITERAL(5, 79, 13), // "GetCallStates"
QT_MOC_LITERAL(6, 93, 42), // "QDBusPendingReply<Tp::Channel..."
QT_MOC_LITERAL(7, 136, 7) // "timeout"

    },
    "Tp::Client::ChannelInterfaceCallStateInterface\0"
    "CallStateChanged\0\0contact\0state\0"
    "GetCallStates\0QDBusPendingReply<Tp::ChannelCallStateMap>\0"
    "timeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceCallStateInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   29,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       5,    1,   34,    2, 0x0a /* Public */,
       5,    0,   37,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    4,

 // slots: parameters
    0x80000000 | 6, QMetaType::Int,    7,
    0x80000000 | 6,

       0        // eod
};

void Tp::Client::ChannelInterfaceCallStateInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceCallStateInterface *_t = static_cast<ChannelInterfaceCallStateInterface *>(_o);
        switch (_id) {
        case 0: _t->CallStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 1: { QDBusPendingReply<Tp::ChannelCallStateMap> _r = _t->GetCallStates((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::ChannelCallStateMap>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<Tp::ChannelCallStateMap> _r = _t->GetCallStates();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::ChannelCallStateMap>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceCallStateInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceCallStateInterface::CallStateChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceCallStateInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceCallStateInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceCallStateInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceCallStateInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceCallStateInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceCallStateInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceCallStateInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceCallStateInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceCallStateInterface::CallStateChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface_t {
    QByteArrayData data[16];
    char stringdata[285];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface = {
    {
QT_MOC_LITERAL(0, 0, 58), // "Tp::Client::ChannelInterfaceC..."
QT_MOC_LITERAL(1, 59, 11), // "GetCaptchas"
QT_MOC_LITERAL(2, 71, 51), // "QDBusPendingReply<Tp::Captcha..."
QT_MOC_LITERAL(3, 123, 0), // ""
QT_MOC_LITERAL(4, 124, 7), // "timeout"
QT_MOC_LITERAL(5, 132, 14), // "GetCaptchaData"
QT_MOC_LITERAL(6, 147, 29), // "QDBusPendingReply<QByteArray>"
QT_MOC_LITERAL(7, 177, 2), // "ID"
QT_MOC_LITERAL(8, 180, 8), // "mimeType"
QT_MOC_LITERAL(9, 189, 14), // "AnswerCaptchas"
QT_MOC_LITERAL(10, 204, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(11, 224, 18), // "Tp::CaptchaAnswers"
QT_MOC_LITERAL(12, 243, 7), // "answers"
QT_MOC_LITERAL(13, 251, 13), // "CancelCaptcha"
QT_MOC_LITERAL(14, 265, 6), // "reason"
QT_MOC_LITERAL(15, 272, 12) // "debugMessage"

    },
    "Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface\0"
    "GetCaptchas\0"
    "QDBusPendingReply<Tp::CaptchaInfoList,uint,QString>\0"
    "\0timeout\0GetCaptchaData\0"
    "QDBusPendingReply<QByteArray>\0ID\0"
    "mimeType\0AnswerCaptchas\0QDBusPendingReply<>\0"
    "Tp::CaptchaAnswers\0answers\0CancelCaptcha\0"
    "reason\0debugMessage"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       8,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   54,    3, 0x0a /* Public */,
       1,    0,   57,    3, 0x2a /* Public | MethodCloned */,
       5,    3,   58,    3, 0x0a /* Public */,
       5,    2,   65,    3, 0x2a /* Public | MethodCloned */,
       9,    2,   70,    3, 0x0a /* Public */,
       9,    1,   75,    3, 0x2a /* Public | MethodCloned */,
      13,    3,   78,    3, 0x0a /* Public */,
      13,    2,   85,    3, 0x2a /* Public | MethodCloned */,

 // slots: parameters
    0x80000000 | 2, QMetaType::Int,    4,
    0x80000000 | 2,
    0x80000000 | 6, QMetaType::UInt, QMetaType::QString, QMetaType::Int,    7,    8,    4,
    0x80000000 | 6, QMetaType::UInt, QMetaType::QString,    7,    8,
    0x80000000 | 10, 0x80000000 | 11, QMetaType::Int,   12,    4,
    0x80000000 | 10, 0x80000000 | 11,   12,
    0x80000000 | 10, QMetaType::UInt, QMetaType::QString, QMetaType::Int,   14,   15,    4,
    0x80000000 | 10, QMetaType::UInt, QMetaType::QString,   14,   15,

       0        // eod
};

void Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceCaptchaAuthenticationInterface *_t = static_cast<ChannelInterfaceCaptchaAuthenticationInterface *>(_o);
        switch (_id) {
        case 0: { QDBusPendingReply<Tp::CaptchaInfoList,uint,QString> _r = _t->GetCaptchas((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::CaptchaInfoList,uint,QString>*>(_a[0]) = _r; }  break;
        case 1: { QDBusPendingReply<Tp::CaptchaInfoList,uint,QString> _r = _t->GetCaptchas();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::CaptchaInfoList,uint,QString>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<QByteArray> _r = _t->GetCaptchaData((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QByteArray>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<QByteArray> _r = _t->GetCaptchaData((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QByteArray>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<> _r = _t->AnswerCaptchas((*reinterpret_cast< const Tp::CaptchaAnswers(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<> _r = _t->AnswerCaptchas((*reinterpret_cast< const Tp::CaptchaAnswers(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<> _r = _t->CancelCaptcha((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<> _r = _t->CancelCaptcha((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::CaptchaAnswers >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::CaptchaAnswers >(); break;
            }
            break;
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceCaptchaAuthenticationInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceCaptchaAuthenticationInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceCaptchaAuthenticationInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceChatStateInterface_t {
    QByteArrayData data[8];
    char stringdata[120];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceChatStateInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceChatStateInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceChatStateInterface = {
    {
QT_MOC_LITERAL(0, 0, 46), // "Tp::Client::ChannelInterfaceC..."
QT_MOC_LITERAL(1, 47, 16), // "ChatStateChanged"
QT_MOC_LITERAL(2, 64, 0), // ""
QT_MOC_LITERAL(3, 65, 7), // "contact"
QT_MOC_LITERAL(4, 73, 5), // "state"
QT_MOC_LITERAL(5, 79, 12), // "SetChatState"
QT_MOC_LITERAL(6, 92, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(7, 112, 7) // "timeout"

    },
    "Tp::Client::ChannelInterfaceChatStateInterface\0"
    "ChatStateChanged\0\0contact\0state\0"
    "SetChatState\0QDBusPendingReply<>\0"
    "timeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceChatStateInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   29,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       5,    2,   34,    2, 0x0a /* Public */,
       5,    1,   39,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    4,

 // slots: parameters
    0x80000000 | 6, QMetaType::UInt, QMetaType::Int,    4,    7,
    0x80000000 | 6, QMetaType::UInt,    4,

       0        // eod
};

void Tp::Client::ChannelInterfaceChatStateInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceChatStateInterface *_t = static_cast<ChannelInterfaceChatStateInterface *>(_o);
        switch (_id) {
        case 0: _t->ChatStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 1: { QDBusPendingReply<> _r = _t->SetChatState((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<> _r = _t->SetChatState((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceChatStateInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceChatStateInterface::ChatStateChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceChatStateInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceChatStateInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceChatStateInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceChatStateInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceChatStateInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceChatStateInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceChatStateInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceChatStateInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceChatStateInterface::ChatStateChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceConferenceInterface_t {
    QByteArrayData data[9];
    char stringdata[143];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceConferenceInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceConferenceInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceConferenceInterface = {
    {
QT_MOC_LITERAL(0, 0, 47), // "Tp::Client::ChannelInterfaceC..."
QT_MOC_LITERAL(1, 48, 13), // "ChannelMerged"
QT_MOC_LITERAL(2, 62, 0), // ""
QT_MOC_LITERAL(3, 63, 15), // "QDBusObjectPath"
QT_MOC_LITERAL(4, 79, 7), // "channel"
QT_MOC_LITERAL(5, 87, 21), // "channelSpecificHandle"
QT_MOC_LITERAL(6, 109, 10), // "properties"
QT_MOC_LITERAL(7, 120, 14), // "ChannelRemoved"
QT_MOC_LITERAL(8, 135, 7) // "details"

    },
    "Tp::Client::ChannelInterfaceConferenceInterface\0"
    "ChannelMerged\0\0QDBusObjectPath\0channel\0"
    "channelSpecificHandle\0properties\0"
    "ChannelRemoved\0details"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceConferenceInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       2,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    3,   24,    2, 0x06 /* Public */,
       7,    2,   31,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3, QMetaType::UInt, QMetaType::QVariantMap,    4,    5,    6,
    QMetaType::Void, 0x80000000 | 3, QMetaType::QVariantMap,    4,    8,

       0        // eod
};

void Tp::Client::ChannelInterfaceConferenceInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceConferenceInterface *_t = static_cast<ChannelInterfaceConferenceInterface *>(_o);
        switch (_id) {
        case 0: _t->ChannelMerged((*reinterpret_cast< const QDBusObjectPath(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QVariantMap(*)>(_a[3]))); break;
        case 1: _t->ChannelRemoved((*reinterpret_cast< const QDBusObjectPath(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceConferenceInterface::*_t)(const QDBusObjectPath & , uint , const QVariantMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceConferenceInterface::ChannelMerged)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelInterfaceConferenceInterface::*_t)(const QDBusObjectPath & , const QVariantMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceConferenceInterface::ChannelRemoved)) {
                *result = 1;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceConferenceInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceConferenceInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceConferenceInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceConferenceInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceConferenceInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceConferenceInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceConferenceInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceConferenceInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceConferenceInterface::ChannelMerged(const QDBusObjectPath & _t1, uint _t2, const QVariantMap & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelInterfaceConferenceInterface::ChannelRemoved(const QDBusObjectPath & _t1, const QVariantMap & _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceDTMFInterface_t {
    QByteArrayData data[14];
    char stringdata[175];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceDTMFInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceDTMFInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceDTMFInterface = {
    {
QT_MOC_LITERAL(0, 0, 41), // "Tp::Client::ChannelInterfaceD..."
QT_MOC_LITERAL(1, 42, 13), // "TonesDeferred"
QT_MOC_LITERAL(2, 56, 0), // ""
QT_MOC_LITERAL(3, 57, 5), // "tones"
QT_MOC_LITERAL(4, 63, 12), // "SendingTones"
QT_MOC_LITERAL(5, 76, 12), // "StoppedTones"
QT_MOC_LITERAL(6, 89, 9), // "cancelled"
QT_MOC_LITERAL(7, 99, 9), // "StartTone"
QT_MOC_LITERAL(8, 109, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(9, 129, 8), // "streamID"
QT_MOC_LITERAL(10, 138, 5), // "event"
QT_MOC_LITERAL(11, 144, 7), // "timeout"
QT_MOC_LITERAL(12, 152, 8), // "StopTone"
QT_MOC_LITERAL(13, 161, 13) // "MultipleTones"

    },
    "Tp::Client::ChannelInterfaceDTMFInterface\0"
    "TonesDeferred\0\0tones\0SendingTones\0"
    "StoppedTones\0cancelled\0StartTone\0"
    "QDBusPendingReply<>\0streamID\0event\0"
    "timeout\0StopTone\0MultipleTones"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceDTMFInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       9,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       3,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   59,    2, 0x06 /* Public */,
       4,    1,   62,    2, 0x06 /* Public */,
       5,    1,   65,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       7,    3,   68,    2, 0x0a /* Public */,
       7,    2,   75,    2, 0x2a /* Public | MethodCloned */,
      12,    2,   80,    2, 0x0a /* Public */,
      12,    1,   85,    2, 0x2a /* Public | MethodCloned */,
      13,    2,   88,    2, 0x0a /* Public */,
      13,    1,   93,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::QString,    3,
    QMetaType::Void, QMetaType::QString,    3,
    QMetaType::Void, QMetaType::Bool,    6,

 // slots: parameters
    0x80000000 | 8, QMetaType::UInt, QMetaType::UChar, QMetaType::Int,    9,   10,   11,
    0x80000000 | 8, QMetaType::UInt, QMetaType::UChar,    9,   10,
    0x80000000 | 8, QMetaType::UInt, QMetaType::Int,    9,   11,
    0x80000000 | 8, QMetaType::UInt,    9,
    0x80000000 | 8, QMetaType::QString, QMetaType::Int,    3,   11,
    0x80000000 | 8, QMetaType::QString,    3,

       0        // eod
};

void Tp::Client::ChannelInterfaceDTMFInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceDTMFInterface *_t = static_cast<ChannelInterfaceDTMFInterface *>(_o);
        switch (_id) {
        case 0: _t->TonesDeferred((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 1: _t->SendingTones((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 2: _t->StoppedTones((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 3: { QDBusPendingReply<> _r = _t->StartTone((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uchar(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<> _r = _t->StartTone((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uchar(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<> _r = _t->StopTone((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<> _r = _t->StopTone((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<> _r = _t->MultipleTones((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<> _r = _t->MultipleTones((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceDTMFInterface::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceDTMFInterface::TonesDeferred)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelInterfaceDTMFInterface::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceDTMFInterface::SendingTones)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelInterfaceDTMFInterface::*_t)(bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceDTMFInterface::StoppedTones)) {
                *result = 2;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceDTMFInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceDTMFInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceDTMFInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceDTMFInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceDTMFInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceDTMFInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceDTMFInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceDTMFInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 9)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 9;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceDTMFInterface::TonesDeferred(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelInterfaceDTMFInterface::SendingTones(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelInterfaceDTMFInterface::StoppedTones(bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceDestroyableInterface_t {
    QByteArrayData data[5];
    char stringdata[86];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceDestroyableInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceDestroyableInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceDestroyableInterface = {
    {
QT_MOC_LITERAL(0, 0, 48), // "Tp::Client::ChannelInterfaceD..."
QT_MOC_LITERAL(1, 49, 7), // "Destroy"
QT_MOC_LITERAL(2, 57, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 77, 0), // ""
QT_MOC_LITERAL(4, 78, 7) // "timeout"

    },
    "Tp::Client::ChannelInterfaceDestroyableInterface\0"
    "Destroy\0QDBusPendingReply<>\0\0timeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceDestroyableInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   24,    3, 0x0a /* Public */,
       1,    0,   27,    3, 0x2a /* Public | MethodCloned */,

 // slots: parameters
    0x80000000 | 2, QMetaType::Int,    4,
    0x80000000 | 2,

       0        // eod
};

void Tp::Client::ChannelInterfaceDestroyableInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceDestroyableInterface *_t = static_cast<ChannelInterfaceDestroyableInterface *>(_o);
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->Destroy((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 1: { QDBusPendingReply<> _r = _t->Destroy();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceDestroyableInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceDestroyableInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceDestroyableInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceDestroyableInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceDestroyableInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceDestroyableInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceDestroyableInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceDestroyableInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceFileTransferMetadataInterface_t {
    QByteArrayData data[1];
    char stringdata[58];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceFileTransferMetadataInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceFileTransferMetadataInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceFileTransferMetadataInterface = {
    {
QT_MOC_LITERAL(0, 0, 57) // "Tp::Client::ChannelInterfaceF..."

    },
    "Tp::Client::ChannelInterfaceFileTransferMetadataInterface"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceFileTransferMetadataInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Tp::Client::ChannelInterfaceFileTransferMetadataInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Tp::Client::ChannelInterfaceFileTransferMetadataInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceFileTransferMetadataInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceFileTransferMetadataInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceFileTransferMetadataInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceFileTransferMetadataInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceFileTransferMetadataInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceFileTransferMetadataInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceFileTransferMetadataInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceGroupInterface_t {
    QByteArrayData data[42];
    char stringdata[740];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceGroupInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceGroupInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceGroupInterface = {
    {
QT_MOC_LITERAL(0, 0, 42), // "Tp::Client::ChannelInterfaceG..."
QT_MOC_LITERAL(1, 43, 19), // "HandleOwnersChanged"
QT_MOC_LITERAL(2, 63, 0), // ""
QT_MOC_LITERAL(3, 64, 18), // "Tp::HandleOwnerMap"
QT_MOC_LITERAL(4, 83, 5), // "added"
QT_MOC_LITERAL(5, 89, 12), // "Tp::UIntList"
QT_MOC_LITERAL(6, 102, 7), // "removed"
QT_MOC_LITERAL(7, 110, 27), // "HandleOwnersChangedDetailed"
QT_MOC_LITERAL(8, 138, 23), // "Tp::HandleIdentifierMap"
QT_MOC_LITERAL(9, 162, 11), // "identifiers"
QT_MOC_LITERAL(10, 174, 17), // "SelfHandleChanged"
QT_MOC_LITERAL(11, 192, 10), // "selfHandle"
QT_MOC_LITERAL(12, 203, 18), // "SelfContactChanged"
QT_MOC_LITERAL(13, 222, 6), // "selfID"
QT_MOC_LITERAL(14, 229, 17), // "GroupFlagsChanged"
QT_MOC_LITERAL(15, 247, 14), // "MembersChanged"
QT_MOC_LITERAL(16, 262, 7), // "message"
QT_MOC_LITERAL(17, 270, 12), // "localPending"
QT_MOC_LITERAL(18, 283, 13), // "remotePending"
QT_MOC_LITERAL(19, 297, 5), // "actor"
QT_MOC_LITERAL(20, 303, 6), // "reason"
QT_MOC_LITERAL(21, 310, 22), // "MembersChangedDetailed"
QT_MOC_LITERAL(22, 333, 7), // "details"
QT_MOC_LITERAL(23, 341, 10), // "AddMembers"
QT_MOC_LITERAL(24, 352, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(25, 372, 8), // "contacts"
QT_MOC_LITERAL(26, 381, 7), // "timeout"
QT_MOC_LITERAL(27, 389, 13), // "GetAllMembers"
QT_MOC_LITERAL(28, 403, 57), // "QDBusPendingReply<Tp::UIntLis..."
QT_MOC_LITERAL(29, 461, 13), // "GetGroupFlags"
QT_MOC_LITERAL(30, 475, 23), // "QDBusPendingReply<uint>"
QT_MOC_LITERAL(31, 499, 15), // "GetHandleOwners"
QT_MOC_LITERAL(32, 515, 31), // "QDBusPendingReply<Tp::UIntList>"
QT_MOC_LITERAL(33, 547, 7), // "handles"
QT_MOC_LITERAL(34, 555, 22), // "GetLocalPendingMembers"
QT_MOC_LITERAL(35, 578, 30), // "GetLocalPendingMembersWithInfo"
QT_MOC_LITERAL(36, 609, 43), // "QDBusPendingReply<Tp::LocalPe..."
QT_MOC_LITERAL(37, 653, 10), // "GetMembers"
QT_MOC_LITERAL(38, 664, 23), // "GetRemotePendingMembers"
QT_MOC_LITERAL(39, 688, 13), // "GetSelfHandle"
QT_MOC_LITERAL(40, 702, 13), // "RemoveMembers"
QT_MOC_LITERAL(41, 716, 23) // "RemoveMembersWithReason"

    },
    "Tp::Client::ChannelInterfaceGroupInterface\0"
    "HandleOwnersChanged\0\0Tp::HandleOwnerMap\0"
    "added\0Tp::UIntList\0removed\0"
    "HandleOwnersChangedDetailed\0"
    "Tp::HandleIdentifierMap\0identifiers\0"
    "SelfHandleChanged\0selfHandle\0"
    "SelfContactChanged\0selfID\0GroupFlagsChanged\0"
    "MembersChanged\0message\0localPending\0"
    "remotePending\0actor\0reason\0"
    "MembersChangedDetailed\0details\0"
    "AddMembers\0QDBusPendingReply<>\0contacts\0"
    "timeout\0GetAllMembers\0"
    "QDBusPendingReply<Tp::UIntList,Tp::UIntList,Tp::UIntList>\0"
    "GetGroupFlags\0QDBusPendingReply<uint>\0"
    "GetHandleOwners\0QDBusPendingReply<Tp::UIntList>\0"
    "handles\0GetLocalPendingMembers\0"
    "GetLocalPendingMembersWithInfo\0"
    "QDBusPendingReply<Tp::LocalPendingInfoList>\0"
    "GetMembers\0GetRemotePendingMembers\0"
    "GetSelfHandle\0RemoveMembers\0"
    "RemoveMembersWithReason"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceGroupInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      29,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       7,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,  159,    2, 0x06 /* Public */,
       7,    3,  164,    2, 0x06 /* Public */,
      10,    1,  171,    2, 0x06 /* Public */,
      12,    2,  174,    2, 0x06 /* Public */,
      14,    2,  179,    2, 0x06 /* Public */,
      15,    7,  184,    2, 0x06 /* Public */,
      21,    5,  199,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      23,    3,  210,    2, 0x0a /* Public */,
      23,    2,  217,    2, 0x2a /* Public | MethodCloned */,
      27,    1,  222,    2, 0x0a /* Public */,
      27,    0,  225,    2, 0x2a /* Public | MethodCloned */,
      29,    1,  226,    2, 0x0a /* Public */,
      29,    0,  229,    2, 0x2a /* Public | MethodCloned */,
      31,    2,  230,    2, 0x0a /* Public */,
      31,    1,  235,    2, 0x2a /* Public | MethodCloned */,
      34,    1,  238,    2, 0x0a /* Public */,
      34,    0,  241,    2, 0x2a /* Public | MethodCloned */,
      35,    1,  242,    2, 0x0a /* Public */,
      35,    0,  245,    2, 0x2a /* Public | MethodCloned */,
      37,    1,  246,    2, 0x0a /* Public */,
      37,    0,  249,    2, 0x2a /* Public | MethodCloned */,
      38,    1,  250,    2, 0x0a /* Public */,
      38,    0,  253,    2, 0x2a /* Public | MethodCloned */,
      39,    1,  254,    2, 0x0a /* Public */,
      39,    0,  257,    2, 0x2a /* Public | MethodCloned */,
      40,    3,  258,    2, 0x0a /* Public */,
      40,    2,  265,    2, 0x2a /* Public | MethodCloned */,
      41,    4,  270,    2, 0x0a /* Public */,
      41,    3,  279,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 5,    4,    6,
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 5, 0x80000000 | 8,    4,    6,    9,
    QMetaType::Void, QMetaType::UInt,   11,
    QMetaType::Void, QMetaType::UInt, QMetaType::QString,   11,   13,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    4,    6,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 5, 0x80000000 | 5, 0x80000000 | 5, 0x80000000 | 5, QMetaType::UInt, QMetaType::UInt,   16,    4,    6,   17,   18,   19,   20,
    QMetaType::Void, 0x80000000 | 5, 0x80000000 | 5, 0x80000000 | 5, 0x80000000 | 5, QMetaType::QVariantMap,    4,    6,   17,   18,   22,

 // slots: parameters
    0x80000000 | 24, 0x80000000 | 5, QMetaType::QString, QMetaType::Int,   25,   16,   26,
    0x80000000 | 24, 0x80000000 | 5, QMetaType::QString,   25,   16,
    0x80000000 | 28, QMetaType::Int,   26,
    0x80000000 | 28,
    0x80000000 | 30, QMetaType::Int,   26,
    0x80000000 | 30,
    0x80000000 | 32, 0x80000000 | 5, QMetaType::Int,   33,   26,
    0x80000000 | 32, 0x80000000 | 5,   33,
    0x80000000 | 32, QMetaType::Int,   26,
    0x80000000 | 32,
    0x80000000 | 36, QMetaType::Int,   26,
    0x80000000 | 36,
    0x80000000 | 32, QMetaType::Int,   26,
    0x80000000 | 32,
    0x80000000 | 32, QMetaType::Int,   26,
    0x80000000 | 32,
    0x80000000 | 30, QMetaType::Int,   26,
    0x80000000 | 30,
    0x80000000 | 24, 0x80000000 | 5, QMetaType::QString, QMetaType::Int,   25,   16,   26,
    0x80000000 | 24, 0x80000000 | 5, QMetaType::QString,   25,   16,
    0x80000000 | 24, 0x80000000 | 5, QMetaType::QString, QMetaType::UInt, QMetaType::Int,   25,   16,   20,   26,
    0x80000000 | 24, 0x80000000 | 5, QMetaType::QString, QMetaType::UInt,   25,   16,   20,

       0        // eod
};

void Tp::Client::ChannelInterfaceGroupInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceGroupInterface *_t = static_cast<ChannelInterfaceGroupInterface *>(_o);
        switch (_id) {
        case 0: _t->HandleOwnersChanged((*reinterpret_cast< const Tp::HandleOwnerMap(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2]))); break;
        case 1: _t->HandleOwnersChangedDetailed((*reinterpret_cast< const Tp::HandleOwnerMap(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2])),(*reinterpret_cast< const Tp::HandleIdentifierMap(*)>(_a[3]))); break;
        case 2: _t->SelfHandleChanged((*reinterpret_cast< uint(*)>(_a[1]))); break;
        case 3: _t->SelfContactChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        case 4: _t->GroupFlagsChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 5: _t->MembersChanged((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[3])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[4])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[5])),(*reinterpret_cast< uint(*)>(_a[6])),(*reinterpret_cast< uint(*)>(_a[7]))); break;
        case 6: _t->MembersChangedDetailed((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[3])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[4])),(*reinterpret_cast< const QVariantMap(*)>(_a[5]))); break;
        case 7: { QDBusPendingReply<> _r = _t->AddMembers((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<> _r = _t->AddMembers((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 9: { QDBusPendingReply<Tp::UIntList,Tp::UIntList,Tp::UIntList> _r = _t->GetAllMembers((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList,Tp::UIntList,Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 10: { QDBusPendingReply<Tp::UIntList,Tp::UIntList,Tp::UIntList> _r = _t->GetAllMembers();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList,Tp::UIntList,Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 11: { QDBusPendingReply<uint> _r = _t->GetGroupFlags((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 12: { QDBusPendingReply<uint> _r = _t->GetGroupFlags();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 13: { QDBusPendingReply<Tp::UIntList> _r = _t->GetHandleOwners((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 14: { QDBusPendingReply<Tp::UIntList> _r = _t->GetHandleOwners((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 15: { QDBusPendingReply<Tp::UIntList> _r = _t->GetLocalPendingMembers((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 16: { QDBusPendingReply<Tp::UIntList> _r = _t->GetLocalPendingMembers();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 17: { QDBusPendingReply<Tp::LocalPendingInfoList> _r = _t->GetLocalPendingMembersWithInfo((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::LocalPendingInfoList>*>(_a[0]) = _r; }  break;
        case 18: { QDBusPendingReply<Tp::LocalPendingInfoList> _r = _t->GetLocalPendingMembersWithInfo();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::LocalPendingInfoList>*>(_a[0]) = _r; }  break;
        case 19: { QDBusPendingReply<Tp::UIntList> _r = _t->GetMembers((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 20: { QDBusPendingReply<Tp::UIntList> _r = _t->GetMembers();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 21: { QDBusPendingReply<Tp::UIntList> _r = _t->GetRemotePendingMembers((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 22: { QDBusPendingReply<Tp::UIntList> _r = _t->GetRemotePendingMembers();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 23: { QDBusPendingReply<uint> _r = _t->GetSelfHandle((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 24: { QDBusPendingReply<uint> _r = _t->GetSelfHandle();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 25: { QDBusPendingReply<> _r = _t->RemoveMembers((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 26: { QDBusPendingReply<> _r = _t->RemoveMembers((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 27: { QDBusPendingReply<> _r = _t->RemoveMembersWithReason((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 28: { QDBusPendingReply<> _r = _t->RemoveMembersWithReason((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::HandleOwnerMap >(); break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::HandleIdentifierMap >(); break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::HandleOwnerMap >(); break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 4:
            case 3:
            case 2:
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
            case 2:
            case 1:
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 13:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 25:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 26:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 27:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceGroupInterface::*_t)(const Tp::HandleOwnerMap & , const Tp::UIntList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceGroupInterface::HandleOwnersChanged)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelInterfaceGroupInterface::*_t)(const Tp::HandleOwnerMap & , const Tp::UIntList & , const Tp::HandleIdentifierMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceGroupInterface::HandleOwnersChangedDetailed)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelInterfaceGroupInterface::*_t)(uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceGroupInterface::SelfHandleChanged)) {
                *result = 2;
            }
        }
        {
            typedef void (ChannelInterfaceGroupInterface::*_t)(uint , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceGroupInterface::SelfContactChanged)) {
                *result = 3;
            }
        }
        {
            typedef void (ChannelInterfaceGroupInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceGroupInterface::GroupFlagsChanged)) {
                *result = 4;
            }
        }
        {
            typedef void (ChannelInterfaceGroupInterface::*_t)(const QString & , const Tp::UIntList & , const Tp::UIntList & , const Tp::UIntList & , const Tp::UIntList & , uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceGroupInterface::MembersChanged)) {
                *result = 5;
            }
        }
        {
            typedef void (ChannelInterfaceGroupInterface::*_t)(const Tp::UIntList & , const Tp::UIntList & , const Tp::UIntList & , const Tp::UIntList & , const QVariantMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceGroupInterface::MembersChangedDetailed)) {
                *result = 6;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceGroupInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceGroupInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceGroupInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceGroupInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceGroupInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceGroupInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceGroupInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceGroupInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 29)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 29;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 29)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 29;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceGroupInterface::HandleOwnersChanged(const Tp::HandleOwnerMap & _t1, const Tp::UIntList & _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelInterfaceGroupInterface::HandleOwnersChangedDetailed(const Tp::HandleOwnerMap & _t1, const Tp::UIntList & _t2, const Tp::HandleIdentifierMap & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelInterfaceGroupInterface::SelfHandleChanged(uint _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void Tp::Client::ChannelInterfaceGroupInterface::SelfContactChanged(uint _t1, const QString & _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void Tp::Client::ChannelInterfaceGroupInterface::GroupFlagsChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}

// SIGNAL 5
void Tp::Client::ChannelInterfaceGroupInterface::MembersChanged(const QString & _t1, const Tp::UIntList & _t2, const Tp::UIntList & _t3, const Tp::UIntList & _t4, const Tp::UIntList & _t5, uint _t6, uint _t7)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)), const_cast<void*>(reinterpret_cast<const void*>(&_t5)), const_cast<void*>(reinterpret_cast<const void*>(&_t6)), const_cast<void*>(reinterpret_cast<const void*>(&_t7)) };
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
}

// SIGNAL 6
void Tp::Client::ChannelInterfaceGroupInterface::MembersChangedDetailed(const Tp::UIntList & _t1, const Tp::UIntList & _t2, const Tp::UIntList & _t3, const Tp::UIntList & _t4, const QVariantMap & _t5)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)), const_cast<void*>(reinterpret_cast<const void*>(&_t5)) };
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceHoldInterface_t {
    QByteArrayData data[11];
    char stringdata[164];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceHoldInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceHoldInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceHoldInterface = {
    {
QT_MOC_LITERAL(0, 0, 41), // "Tp::Client::ChannelInterfaceH..."
QT_MOC_LITERAL(1, 42, 16), // "HoldStateChanged"
QT_MOC_LITERAL(2, 59, 0), // ""
QT_MOC_LITERAL(3, 60, 9), // "holdState"
QT_MOC_LITERAL(4, 70, 6), // "reason"
QT_MOC_LITERAL(5, 77, 12), // "GetHoldState"
QT_MOC_LITERAL(6, 90, 28), // "QDBusPendingReply<uint,uint>"
QT_MOC_LITERAL(7, 119, 7), // "timeout"
QT_MOC_LITERAL(8, 127, 11), // "RequestHold"
QT_MOC_LITERAL(9, 139, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(10, 159, 4) // "hold"

    },
    "Tp::Client::ChannelInterfaceHoldInterface\0"
    "HoldStateChanged\0\0holdState\0reason\0"
    "GetHoldState\0QDBusPendingReply<uint,uint>\0"
    "timeout\0RequestHold\0QDBusPendingReply<>\0"
    "hold"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceHoldInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       5,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   39,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       5,    1,   44,    2, 0x0a /* Public */,
       5,    0,   47,    2, 0x2a /* Public | MethodCloned */,
       8,    2,   48,    2, 0x0a /* Public */,
       8,    1,   53,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    4,

 // slots: parameters
    0x80000000 | 6, QMetaType::Int,    7,
    0x80000000 | 6,
    0x80000000 | 9, QMetaType::Bool, QMetaType::Int,   10,    7,
    0x80000000 | 9, QMetaType::Bool,   10,

       0        // eod
};

void Tp::Client::ChannelInterfaceHoldInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceHoldInterface *_t = static_cast<ChannelInterfaceHoldInterface *>(_o);
        switch (_id) {
        case 0: _t->HoldStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 1: { QDBusPendingReply<uint,uint> _r = _t->GetHoldState((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,uint>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<uint,uint> _r = _t->GetHoldState();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,uint>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<> _r = _t->RequestHold((*reinterpret_cast< bool(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<> _r = _t->RequestHold((*reinterpret_cast< bool(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceHoldInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceHoldInterface::HoldStateChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceHoldInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceHoldInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceHoldInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceHoldInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceHoldInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceHoldInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceHoldInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceHoldInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceHoldInterface::HoldStateChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceMediaSignallingInterface_t {
    QByteArrayData data[9];
    char stringdata[193];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceMediaSignallingInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceMediaSignallingInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceMediaSignallingInterface = {
    {
QT_MOC_LITERAL(0, 0, 52), // "Tp::Client::ChannelInterfaceM..."
QT_MOC_LITERAL(1, 53, 17), // "NewSessionHandler"
QT_MOC_LITERAL(2, 71, 0), // ""
QT_MOC_LITERAL(3, 72, 15), // "QDBusObjectPath"
QT_MOC_LITERAL(4, 88, 14), // "sessionHandler"
QT_MOC_LITERAL(5, 103, 11), // "sessionType"
QT_MOC_LITERAL(6, 115, 18), // "GetSessionHandlers"
QT_MOC_LITERAL(7, 134, 50), // "QDBusPendingReply<Tp::MediaSe..."
QT_MOC_LITERAL(8, 185, 7) // "timeout"

    },
    "Tp::Client::ChannelInterfaceMediaSignallingInterface\0"
    "NewSessionHandler\0\0QDBusObjectPath\0"
    "sessionHandler\0sessionType\0"
    "GetSessionHandlers\0"
    "QDBusPendingReply<Tp::MediaSessionHandlerInfoList>\0"
    "timeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceMediaSignallingInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   29,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       6,    1,   34,    2, 0x0a /* Public */,
       6,    0,   37,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3, QMetaType::QString,    4,    5,

 // slots: parameters
    0x80000000 | 7, QMetaType::Int,    8,
    0x80000000 | 7,

       0        // eod
};

void Tp::Client::ChannelInterfaceMediaSignallingInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceMediaSignallingInterface *_t = static_cast<ChannelInterfaceMediaSignallingInterface *>(_o);
        switch (_id) {
        case 0: _t->NewSessionHandler((*reinterpret_cast< const QDBusObjectPath(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        case 1: { QDBusPendingReply<Tp::MediaSessionHandlerInfoList> _r = _t->GetSessionHandlers((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MediaSessionHandlerInfoList>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<Tp::MediaSessionHandlerInfoList> _r = _t->GetSessionHandlers();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MediaSessionHandlerInfoList>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceMediaSignallingInterface::*_t)(const QDBusObjectPath & , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceMediaSignallingInterface::NewSessionHandler)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceMediaSignallingInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceMediaSignallingInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceMediaSignallingInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceMediaSignallingInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceMediaSignallingInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceMediaSignallingInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceMediaSignallingInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceMediaSignallingInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceMediaSignallingInterface::NewSessionHandler(const QDBusObjectPath & _t1, const QString & _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceMessagesInterface_t {
    QByteArrayData data[19];
    char stringdata[310];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceMessagesInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceMessagesInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceMessagesInterface = {
    {
QT_MOC_LITERAL(0, 0, 45), // "Tp::Client::ChannelInterfaceM..."
QT_MOC_LITERAL(1, 46, 11), // "MessageSent"
QT_MOC_LITERAL(2, 58, 0), // ""
QT_MOC_LITERAL(3, 59, 19), // "Tp::MessagePartList"
QT_MOC_LITERAL(4, 79, 7), // "content"
QT_MOC_LITERAL(5, 87, 5), // "flags"
QT_MOC_LITERAL(6, 93, 12), // "messageToken"
QT_MOC_LITERAL(7, 106, 22), // "PendingMessagesRemoved"
QT_MOC_LITERAL(8, 129, 12), // "Tp::UIntList"
QT_MOC_LITERAL(9, 142, 10), // "messageIDs"
QT_MOC_LITERAL(10, 153, 15), // "MessageReceived"
QT_MOC_LITERAL(11, 169, 7), // "message"
QT_MOC_LITERAL(12, 177, 11), // "SendMessage"
QT_MOC_LITERAL(13, 189, 26), // "QDBusPendingReply<QString>"
QT_MOC_LITERAL(14, 216, 7), // "timeout"
QT_MOC_LITERAL(15, 224, 24), // "GetPendingMessageContent"
QT_MOC_LITERAL(16, 249, 44), // "QDBusPendingReply<Tp::Message..."
QT_MOC_LITERAL(17, 294, 9), // "messageID"
QT_MOC_LITERAL(18, 304, 5) // "parts"

    },
    "Tp::Client::ChannelInterfaceMessagesInterface\0"
    "MessageSent\0\0Tp::MessagePartList\0"
    "content\0flags\0messageToken\0"
    "PendingMessagesRemoved\0Tp::UIntList\0"
    "messageIDs\0MessageReceived\0message\0"
    "SendMessage\0QDBusPendingReply<QString>\0"
    "timeout\0GetPendingMessageContent\0"
    "QDBusPendingReply<Tp::MessagePartContentMap>\0"
    "messageID\0parts"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceMessagesInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       7,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       3,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    3,   49,    2, 0x06 /* Public */,
       7,    1,   56,    2, 0x06 /* Public */,
      10,    1,   59,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      12,    3,   62,    2, 0x0a /* Public */,
      12,    2,   69,    2, 0x2a /* Public | MethodCloned */,
      15,    3,   74,    2, 0x0a /* Public */,
      15,    2,   81,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3, QMetaType::UInt, QMetaType::QString,    4,    5,    6,
    QMetaType::Void, 0x80000000 | 8,    9,
    QMetaType::Void, 0x80000000 | 3,   11,

 // slots: parameters
    0x80000000 | 13, 0x80000000 | 3, QMetaType::UInt, QMetaType::Int,   11,    5,   14,
    0x80000000 | 13, 0x80000000 | 3, QMetaType::UInt,   11,    5,
    0x80000000 | 16, QMetaType::UInt, 0x80000000 | 8, QMetaType::Int,   17,   18,   14,
    0x80000000 | 16, QMetaType::UInt, 0x80000000 | 8,   17,   18,

       0        // eod
};

void Tp::Client::ChannelInterfaceMessagesInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceMessagesInterface *_t = static_cast<ChannelInterfaceMessagesInterface *>(_o);
        switch (_id) {
        case 0: _t->MessageSent((*reinterpret_cast< const Tp::MessagePartList(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
        case 1: _t->PendingMessagesRemoved((*reinterpret_cast< const Tp::UIntList(*)>(_a[1]))); break;
        case 2: _t->MessageReceived((*reinterpret_cast< const Tp::MessagePartList(*)>(_a[1]))); break;
        case 3: { QDBusPendingReply<QString> _r = _t->SendMessage((*reinterpret_cast< const Tp::MessagePartList(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<QString> _r = _t->SendMessage((*reinterpret_cast< const Tp::MessagePartList(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<Tp::MessagePartContentMap> _r = _t->GetPendingMessageContent((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MessagePartContentMap>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<Tp::MessagePartContentMap> _r = _t->GetPendingMessageContent((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MessagePartContentMap>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::MessagePartList >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::MessagePartList >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::MessagePartList >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::MessagePartList >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceMessagesInterface::*_t)(const Tp::MessagePartList & , uint , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceMessagesInterface::MessageSent)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelInterfaceMessagesInterface::*_t)(const Tp::UIntList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceMessagesInterface::PendingMessagesRemoved)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelInterfaceMessagesInterface::*_t)(const Tp::MessagePartList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceMessagesInterface::MessageReceived)) {
                *result = 2;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceMessagesInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceMessagesInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceMessagesInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceMessagesInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceMessagesInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceMessagesInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceMessagesInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceMessagesInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceMessagesInterface::MessageSent(const Tp::MessagePartList & _t1, uint _t2, const QString & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelInterfaceMessagesInterface::PendingMessagesRemoved(const Tp::UIntList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelInterfaceMessagesInterface::MessageReceived(const Tp::MessagePartList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfacePasswordInterface_t {
    QByteArrayData data[11];
    char stringdata[180];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfacePasswordInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfacePasswordInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfacePasswordInterface = {
    {
QT_MOC_LITERAL(0, 0, 45), // "Tp::Client::ChannelInterfaceP..."
QT_MOC_LITERAL(1, 46, 20), // "PasswordFlagsChanged"
QT_MOC_LITERAL(2, 67, 0), // ""
QT_MOC_LITERAL(3, 68, 5), // "added"
QT_MOC_LITERAL(4, 74, 7), // "removed"
QT_MOC_LITERAL(5, 82, 16), // "GetPasswordFlags"
QT_MOC_LITERAL(6, 99, 23), // "QDBusPendingReply<uint>"
QT_MOC_LITERAL(7, 123, 7), // "timeout"
QT_MOC_LITERAL(8, 131, 15), // "ProvidePassword"
QT_MOC_LITERAL(9, 147, 23), // "QDBusPendingReply<bool>"
QT_MOC_LITERAL(10, 171, 8) // "password"

    },
    "Tp::Client::ChannelInterfacePasswordInterface\0"
    "PasswordFlagsChanged\0\0added\0removed\0"
    "GetPasswordFlags\0QDBusPendingReply<uint>\0"
    "timeout\0ProvidePassword\0QDBusPendingReply<bool>\0"
    "password"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfacePasswordInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       5,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   39,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       5,    1,   44,    2, 0x0a /* Public */,
       5,    0,   47,    2, 0x2a /* Public | MethodCloned */,
       8,    2,   48,    2, 0x0a /* Public */,
       8,    1,   53,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    4,

 // slots: parameters
    0x80000000 | 6, QMetaType::Int,    7,
    0x80000000 | 6,
    0x80000000 | 9, QMetaType::QString, QMetaType::Int,   10,    7,
    0x80000000 | 9, QMetaType::QString,   10,

       0        // eod
};

void Tp::Client::ChannelInterfacePasswordInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfacePasswordInterface *_t = static_cast<ChannelInterfacePasswordInterface *>(_o);
        switch (_id) {
        case 0: _t->PasswordFlagsChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 1: { QDBusPendingReply<uint> _r = _t->GetPasswordFlags((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<uint> _r = _t->GetPasswordFlags();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<bool> _r = _t->ProvidePassword((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<bool> _r = _t->ProvidePassword((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfacePasswordInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfacePasswordInterface::PasswordFlagsChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfacePasswordInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfacePasswordInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfacePasswordInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfacePasswordInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfacePasswordInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfacePasswordInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfacePasswordInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfacePasswordInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfacePasswordInterface::PasswordFlagsChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomConfigInterface_t {
    QByteArrayData data[6];
    char stringdata[108];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomConfigInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomConfigInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomConfigInterface = {
    {
QT_MOC_LITERAL(0, 0, 47), // "Tp::Client::ChannelInterfaceR..."
QT_MOC_LITERAL(1, 48, 19), // "UpdateConfiguration"
QT_MOC_LITERAL(2, 68, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 88, 0), // ""
QT_MOC_LITERAL(4, 89, 10), // "properties"
QT_MOC_LITERAL(5, 100, 7) // "timeout"

    },
    "Tp::Client::ChannelInterfaceRoomConfigInterface\0"
    "UpdateConfiguration\0QDBusPendingReply<>\0"
    "\0properties\0timeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceRoomConfigInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    2,   24,    3, 0x0a /* Public */,
       1,    1,   29,    3, 0x2a /* Public | MethodCloned */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QVariantMap, QMetaType::Int,    4,    5,
    0x80000000 | 2, QMetaType::QVariantMap,    4,

       0        // eod
};

void Tp::Client::ChannelInterfaceRoomConfigInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceRoomConfigInterface *_t = static_cast<ChannelInterfaceRoomConfigInterface *>(_o);
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->UpdateConfiguration((*reinterpret_cast< const QVariantMap(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 1: { QDBusPendingReply<> _r = _t->UpdateConfiguration((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceRoomConfigInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomConfigInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceRoomConfigInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceRoomConfigInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceRoomConfigInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomConfigInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceRoomConfigInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceRoomConfigInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomInterface_t {
    QByteArrayData data[1];
    char stringdata[42];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomInterface = {
    {
QT_MOC_LITERAL(0, 0, 41) // "Tp::Client::ChannelInterfaceR..."

    },
    "Tp::Client::ChannelInterfaceRoomInterface"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceRoomInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Tp::Client::ChannelInterfaceRoomInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Tp::Client::ChannelInterfaceRoomInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceRoomInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceRoomInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceRoomInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceRoomInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceRoomInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceRoomInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceSASLAuthenticationInterface_t {
    QByteArrayData data[19];
    char stringdata[267];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceSASLAuthenticationInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceSASLAuthenticationInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceSASLAuthenticationInterface = {
    {
QT_MOC_LITERAL(0, 0, 55), // "Tp::Client::ChannelInterfaceS..."
QT_MOC_LITERAL(1, 56, 17), // "SASLStatusChanged"
QT_MOC_LITERAL(2, 74, 0), // ""
QT_MOC_LITERAL(3, 75, 6), // "status"
QT_MOC_LITERAL(4, 82, 6), // "reason"
QT_MOC_LITERAL(5, 89, 7), // "details"
QT_MOC_LITERAL(6, 97, 12), // "NewChallenge"
QT_MOC_LITERAL(7, 110, 13), // "challengeData"
QT_MOC_LITERAL(8, 124, 14), // "StartMechanism"
QT_MOC_LITERAL(9, 139, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(10, 159, 9), // "mechanism"
QT_MOC_LITERAL(11, 169, 7), // "timeout"
QT_MOC_LITERAL(12, 177, 22), // "StartMechanismWithData"
QT_MOC_LITERAL(13, 200, 11), // "initialData"
QT_MOC_LITERAL(14, 212, 7), // "Respond"
QT_MOC_LITERAL(15, 220, 12), // "responseData"
QT_MOC_LITERAL(16, 233, 10), // "AcceptSASL"
QT_MOC_LITERAL(17, 244, 9), // "AbortSASL"
QT_MOC_LITERAL(18, 254, 12) // "debugMessage"

    },
    "Tp::Client::ChannelInterfaceSASLAuthenticationInterface\0"
    "SASLStatusChanged\0\0status\0reason\0"
    "details\0NewChallenge\0challengeData\0"
    "StartMechanism\0QDBusPendingReply<>\0"
    "mechanism\0timeout\0StartMechanismWithData\0"
    "initialData\0Respond\0responseData\0"
    "AcceptSASL\0AbortSASL\0debugMessage"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceSASLAuthenticationInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      12,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       2,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    3,   74,    2, 0x06 /* Public */,
       6,    1,   81,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       8,    2,   84,    2, 0x0a /* Public */,
       8,    1,   89,    2, 0x2a /* Public | MethodCloned */,
      12,    3,   92,    2, 0x0a /* Public */,
      12,    2,   99,    2, 0x2a /* Public | MethodCloned */,
      14,    2,  104,    2, 0x0a /* Public */,
      14,    1,  109,    2, 0x2a /* Public | MethodCloned */,
      16,    1,  112,    2, 0x0a /* Public */,
      16,    0,  115,    2, 0x2a /* Public | MethodCloned */,
      17,    3,  116,    2, 0x0a /* Public */,
      17,    2,  123,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::QString, QMetaType::QVariantMap,    3,    4,    5,
    QMetaType::Void, QMetaType::QByteArray,    7,

 // slots: parameters
    0x80000000 | 9, QMetaType::QString, QMetaType::Int,   10,   11,
    0x80000000 | 9, QMetaType::QString,   10,
    0x80000000 | 9, QMetaType::QString, QMetaType::QByteArray, QMetaType::Int,   10,   13,   11,
    0x80000000 | 9, QMetaType::QString, QMetaType::QByteArray,   10,   13,
    0x80000000 | 9, QMetaType::QByteArray, QMetaType::Int,   15,   11,
    0x80000000 | 9, QMetaType::QByteArray,   15,
    0x80000000 | 9, QMetaType::Int,   11,
    0x80000000 | 9,
    0x80000000 | 9, QMetaType::UInt, QMetaType::QString, QMetaType::Int,    4,   18,   11,
    0x80000000 | 9, QMetaType::UInt, QMetaType::QString,    4,   18,

       0        // eod
};

void Tp::Client::ChannelInterfaceSASLAuthenticationInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceSASLAuthenticationInterface *_t = static_cast<ChannelInterfaceSASLAuthenticationInterface *>(_o);
        switch (_id) {
        case 0: _t->SASLStatusChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QVariantMap(*)>(_a[3]))); break;
        case 1: _t->NewChallenge((*reinterpret_cast< const QByteArray(*)>(_a[1]))); break;
        case 2: { QDBusPendingReply<> _r = _t->StartMechanism((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<> _r = _t->StartMechanism((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<> _r = _t->StartMechanismWithData((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QByteArray(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<> _r = _t->StartMechanismWithData((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QByteArray(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<> _r = _t->Respond((*reinterpret_cast< const QByteArray(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<> _r = _t->Respond((*reinterpret_cast< const QByteArray(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<> _r = _t->AcceptSASL((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 9: { QDBusPendingReply<> _r = _t->AcceptSASL();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 10: { QDBusPendingReply<> _r = _t->AbortSASL((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 11: { QDBusPendingReply<> _r = _t->AbortSASL((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceSASLAuthenticationInterface::*_t)(uint , const QString & , const QVariantMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceSASLAuthenticationInterface::SASLStatusChanged)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelInterfaceSASLAuthenticationInterface::*_t)(const QByteArray & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceSASLAuthenticationInterface::NewChallenge)) {
                *result = 1;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceSASLAuthenticationInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceSASLAuthenticationInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceSASLAuthenticationInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceSASLAuthenticationInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceSASLAuthenticationInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceSASLAuthenticationInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceSASLAuthenticationInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceSASLAuthenticationInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 12)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 12;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 12)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 12;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceSASLAuthenticationInterface::SASLStatusChanged(uint _t1, const QString & _t2, const QVariantMap & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelInterfaceSASLAuthenticationInterface::NewChallenge(const QByteArray & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceSMSInterface_t {
    QByteArrayData data[9];
    char stringdata[152];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceSMSInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceSMSInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceSMSInterface = {
    {
QT_MOC_LITERAL(0, 0, 40), // "Tp::Client::ChannelInterfaceS..."
QT_MOC_LITERAL(1, 41, 17), // "SMSChannelChanged"
QT_MOC_LITERAL(2, 59, 0), // ""
QT_MOC_LITERAL(3, 60, 10), // "SMSChannel"
QT_MOC_LITERAL(4, 71, 12), // "GetSMSLength"
QT_MOC_LITERAL(5, 84, 31), // "QDBusPendingReply<uint,int,int>"
QT_MOC_LITERAL(6, 116, 19), // "Tp::MessagePartList"
QT_MOC_LITERAL(7, 136, 7), // "message"
QT_MOC_LITERAL(8, 144, 7) // "timeout"

    },
    "Tp::Client::ChannelInterfaceSMSInterface\0"
    "SMSChannelChanged\0\0SMSChannel\0"
    "GetSMSLength\0QDBusPendingReply<uint,int,int>\0"
    "Tp::MessagePartList\0message\0timeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceSMSInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   29,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       4,    2,   32,    2, 0x0a /* Public */,
       4,    1,   37,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::Bool,    3,

 // slots: parameters
    0x80000000 | 5, 0x80000000 | 6, QMetaType::Int,    7,    8,
    0x80000000 | 5, 0x80000000 | 6,    7,

       0        // eod
};

void Tp::Client::ChannelInterfaceSMSInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceSMSInterface *_t = static_cast<ChannelInterfaceSMSInterface *>(_o);
        switch (_id) {
        case 0: _t->SMSChannelChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: { QDBusPendingReply<uint,int,int> _r = _t->GetSMSLength((*reinterpret_cast< const Tp::MessagePartList(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,int,int>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<uint,int,int> _r = _t->GetSMSLength((*reinterpret_cast< const Tp::MessagePartList(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,int,int>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::MessagePartList >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::MessagePartList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceSMSInterface::*_t)(bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceSMSInterface::SMSChannelChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceSMSInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceSMSInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceSMSInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceSMSInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceSMSInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceSMSInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceSMSInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceSMSInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceSMSInterface::SMSChannelChanged(bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceSecurableInterface_t {
    QByteArrayData data[1];
    char stringdata[47];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceSecurableInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceSecurableInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceSecurableInterface = {
    {
QT_MOC_LITERAL(0, 0, 46) // "Tp::Client::ChannelInterfaceS..."

    },
    "Tp::Client::ChannelInterfaceSecurableInterface"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceSecurableInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Tp::Client::ChannelInterfaceSecurableInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Tp::Client::ChannelInterfaceSecurableInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceSecurableInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceSecurableInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceSecurableInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceSecurableInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceSecurableInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceSecurableInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceSecurableInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceServicePointInterface_t {
    QByteArrayData data[5];
    char stringdata[101];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceServicePointInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceServicePointInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceServicePointInterface = {
    {
QT_MOC_LITERAL(0, 0, 49), // "Tp::Client::ChannelInterfaceS..."
QT_MOC_LITERAL(1, 50, 19), // "ServicePointChanged"
QT_MOC_LITERAL(2, 70, 0), // ""
QT_MOC_LITERAL(3, 71, 16), // "Tp::ServicePoint"
QT_MOC_LITERAL(4, 88, 12) // "servicePoint"

    },
    "Tp::Client::ChannelInterfaceServicePointInterface\0"
    "ServicePointChanged\0\0Tp::ServicePoint\0"
    "servicePoint"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceServicePointInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3,    4,

       0        // eod
};

void Tp::Client::ChannelInterfaceServicePointInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceServicePointInterface *_t = static_cast<ChannelInterfaceServicePointInterface *>(_o);
        switch (_id) {
        case 0: _t->ServicePointChanged((*reinterpret_cast< const Tp::ServicePoint(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::ServicePoint >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceServicePointInterface::*_t)(const Tp::ServicePoint & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceServicePointInterface::ServicePointChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceServicePointInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceServicePointInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceServicePointInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceServicePointInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceServicePointInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceServicePointInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceServicePointInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceServicePointInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceServicePointInterface::ServicePointChanged(const Tp::ServicePoint & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceSubjectInterface_t {
    QByteArrayData data[6];
    char stringdata[93];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceSubjectInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceSubjectInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceSubjectInterface = {
    {
QT_MOC_LITERAL(0, 0, 44), // "Tp::Client::ChannelInterfaceS..."
QT_MOC_LITERAL(1, 45, 10), // "SetSubject"
QT_MOC_LITERAL(2, 56, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 76, 0), // ""
QT_MOC_LITERAL(4, 77, 7), // "subject"
QT_MOC_LITERAL(5, 85, 7) // "timeout"

    },
    "Tp::Client::ChannelInterfaceSubjectInterface\0"
    "SetSubject\0QDBusPendingReply<>\0\0subject\0"
    "timeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceSubjectInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    2,   24,    3, 0x0a /* Public */,
       1,    1,   29,    3, 0x2a /* Public | MethodCloned */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QString, QMetaType::Int,    4,    5,
    0x80000000 | 2, QMetaType::QString,    4,

       0        // eod
};

void Tp::Client::ChannelInterfaceSubjectInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceSubjectInterface *_t = static_cast<ChannelInterfaceSubjectInterface *>(_o);
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->SetSubject((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 1: { QDBusPendingReply<> _r = _t->SetSubject((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceSubjectInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceSubjectInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceSubjectInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceSubjectInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceSubjectInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceSubjectInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceSubjectInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceSubjectInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelInterfaceTubeInterface_t {
    QByteArrayData data[4];
    char stringdata[73];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelInterfaceTubeInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelInterfaceTubeInterface_t qt_meta_stringdata_Tp__Client__ChannelInterfaceTubeInterface = {
    {
QT_MOC_LITERAL(0, 0, 41), // "Tp::Client::ChannelInterfaceT..."
QT_MOC_LITERAL(1, 42, 23), // "TubeChannelStateChanged"
QT_MOC_LITERAL(2, 66, 0), // ""
QT_MOC_LITERAL(3, 67, 5) // "state"

    },
    "Tp::Client::ChannelInterfaceTubeInterface\0"
    "TubeChannelStateChanged\0\0state"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelInterfaceTubeInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt,    3,

       0        // eod
};

void Tp::Client::ChannelInterfaceTubeInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelInterfaceTubeInterface *_t = static_cast<ChannelInterfaceTubeInterface *>(_o);
        switch (_id) {
        case 0: _t->TubeChannelStateChanged((*reinterpret_cast< uint(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelInterfaceTubeInterface::*_t)(uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelInterfaceTubeInterface::TubeChannelStateChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelInterfaceTubeInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelInterfaceTubeInterface.data,
      qt_meta_data_Tp__Client__ChannelInterfaceTubeInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelInterfaceTubeInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelInterfaceTubeInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelInterfaceTubeInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelInterfaceTubeInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelInterfaceTubeInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelInterfaceTubeInterface::TubeChannelStateChanged(uint _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeCallInterface_t {
    QByteArrayData data[33];
    char stringdata[473];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeCallInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeCallInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeCallInterface = {
    {
QT_MOC_LITERAL(0, 0, 36), // "Tp::Client::ChannelTypeCallIn..."
QT_MOC_LITERAL(1, 37, 12), // "ContentAdded"
QT_MOC_LITERAL(2, 50, 0), // ""
QT_MOC_LITERAL(3, 51, 15), // "QDBusObjectPath"
QT_MOC_LITERAL(4, 67, 7), // "content"
QT_MOC_LITERAL(5, 75, 14), // "ContentRemoved"
QT_MOC_LITERAL(6, 90, 19), // "Tp::CallStateReason"
QT_MOC_LITERAL(7, 110, 6), // "reason"
QT_MOC_LITERAL(8, 117, 16), // "CallStateChanged"
QT_MOC_LITERAL(9, 134, 9), // "callState"
QT_MOC_LITERAL(10, 144, 9), // "callFlags"
QT_MOC_LITERAL(11, 154, 15), // "callStateReason"
QT_MOC_LITERAL(12, 170, 16), // "callStateDetails"
QT_MOC_LITERAL(13, 187, 18), // "CallMembersChanged"
QT_MOC_LITERAL(14, 206, 17), // "Tp::CallMemberMap"
QT_MOC_LITERAL(15, 224, 12), // "flagsChanged"
QT_MOC_LITERAL(16, 237, 23), // "Tp::HandleIdentifierMap"
QT_MOC_LITERAL(17, 261, 11), // "identifiers"
QT_MOC_LITERAL(18, 273, 12), // "Tp::UIntList"
QT_MOC_LITERAL(19, 286, 7), // "removed"
QT_MOC_LITERAL(20, 294, 10), // "SetRinging"
QT_MOC_LITERAL(21, 305, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(22, 325, 7), // "timeout"
QT_MOC_LITERAL(23, 333, 9), // "SetQueued"
QT_MOC_LITERAL(24, 343, 6), // "Accept"
QT_MOC_LITERAL(25, 350, 6), // "Hangup"
QT_MOC_LITERAL(26, 357, 20), // "detailedHangupReason"
QT_MOC_LITERAL(27, 378, 7), // "message"
QT_MOC_LITERAL(28, 386, 10), // "AddContent"
QT_MOC_LITERAL(29, 397, 34), // "QDBusPendingReply<QDBusObject..."
QT_MOC_LITERAL(30, 432, 11), // "contentName"
QT_MOC_LITERAL(31, 444, 11), // "contentType"
QT_MOC_LITERAL(32, 456, 16) // "initialDirection"

    },
    "Tp::Client::ChannelTypeCallInterface\0"
    "ContentAdded\0\0QDBusObjectPath\0content\0"
    "ContentRemoved\0Tp::CallStateReason\0"
    "reason\0CallStateChanged\0callState\0"
    "callFlags\0callStateReason\0callStateDetails\0"
    "CallMembersChanged\0Tp::CallMemberMap\0"
    "flagsChanged\0Tp::HandleIdentifierMap\0"
    "identifiers\0Tp::UIntList\0removed\0"
    "SetRinging\0QDBusPendingReply<>\0timeout\0"
    "SetQueued\0Accept\0Hangup\0detailedHangupReason\0"
    "message\0AddContent\0"
    "QDBusPendingReply<QDBusObjectPath>\0"
    "contentName\0contentType\0initialDirection"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeCallInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      14,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       4,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   84,    2, 0x06 /* Public */,
       5,    2,   87,    2, 0x06 /* Public */,
       8,    4,   92,    2, 0x06 /* Public */,
      13,    4,  101,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      20,    1,  110,    2, 0x0a /* Public */,
      20,    0,  113,    2, 0x2a /* Public | MethodCloned */,
      23,    1,  114,    2, 0x0a /* Public */,
      23,    0,  117,    2, 0x2a /* Public | MethodCloned */,
      24,    1,  118,    2, 0x0a /* Public */,
      24,    0,  121,    2, 0x2a /* Public | MethodCloned */,
      25,    4,  122,    2, 0x0a /* Public */,
      25,    3,  131,    2, 0x2a /* Public | MethodCloned */,
      28,    4,  138,    2, 0x0a /* Public */,
      28,    3,  147,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 6,    4,    7,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 6, QMetaType::QVariantMap,    9,   10,   11,   12,
    QMetaType::Void, 0x80000000 | 14, 0x80000000 | 16, 0x80000000 | 18, 0x80000000 | 6,   15,   17,   19,    7,

 // slots: parameters
    0x80000000 | 21, QMetaType::Int,   22,
    0x80000000 | 21,
    0x80000000 | 21, QMetaType::Int,   22,
    0x80000000 | 21,
    0x80000000 | 21, QMetaType::Int,   22,
    0x80000000 | 21,
    0x80000000 | 21, QMetaType::UInt, QMetaType::QString, QMetaType::QString, QMetaType::Int,    7,   26,   27,   22,
    0x80000000 | 21, QMetaType::UInt, QMetaType::QString, QMetaType::QString,    7,   26,   27,
    0x80000000 | 29, QMetaType::QString, QMetaType::UInt, QMetaType::UInt, QMetaType::Int,   30,   31,   32,   22,
    0x80000000 | 29, QMetaType::QString, QMetaType::UInt, QMetaType::UInt,   30,   31,   32,

       0        // eod
};

void Tp::Client::ChannelTypeCallInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeCallInterface *_t = static_cast<ChannelTypeCallInterface *>(_o);
        switch (_id) {
        case 0: _t->ContentAdded((*reinterpret_cast< const QDBusObjectPath(*)>(_a[1]))); break;
        case 1: _t->ContentRemoved((*reinterpret_cast< const QDBusObjectPath(*)>(_a[1])),(*reinterpret_cast< const Tp::CallStateReason(*)>(_a[2]))); break;
        case 2: _t->CallStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const Tp::CallStateReason(*)>(_a[3])),(*reinterpret_cast< const QVariantMap(*)>(_a[4]))); break;
        case 3: _t->CallMembersChanged((*reinterpret_cast< const Tp::CallMemberMap(*)>(_a[1])),(*reinterpret_cast< const Tp::HandleIdentifierMap(*)>(_a[2])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[3])),(*reinterpret_cast< const Tp::CallStateReason(*)>(_a[4]))); break;
        case 4: { QDBusPendingReply<> _r = _t->SetRinging((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<> _r = _t->SetRinging();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<> _r = _t->SetQueued((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<> _r = _t->SetQueued();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<> _r = _t->Accept((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 9: { QDBusPendingReply<> _r = _t->Accept();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 10: { QDBusPendingReply<> _r = _t->Hangup((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 11: { QDBusPendingReply<> _r = _t->Hangup((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 12: { QDBusPendingReply<QDBusObjectPath> _r = _t->AddContent((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = _r; }  break;
        case 13: { QDBusPendingReply<QDBusObjectPath> _r = _t->AddContent((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::CallStateReason >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::CallStateReason >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::CallMemberMap >(); break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::CallStateReason >(); break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::HandleIdentifierMap >(); break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeCallInterface::*_t)(const QDBusObjectPath & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeCallInterface::ContentAdded)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeCallInterface::*_t)(const QDBusObjectPath & , const Tp::CallStateReason & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeCallInterface::ContentRemoved)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelTypeCallInterface::*_t)(uint , uint , const Tp::CallStateReason & , const QVariantMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeCallInterface::CallStateChanged)) {
                *result = 2;
            }
        }
        {
            typedef void (ChannelTypeCallInterface::*_t)(const Tp::CallMemberMap & , const Tp::HandleIdentifierMap & , const Tp::UIntList & , const Tp::CallStateReason & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeCallInterface::CallMembersChanged)) {
                *result = 3;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeCallInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeCallInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeCallInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeCallInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeCallInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeCallInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeCallInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeCallInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 14)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 14;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 14)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 14;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeCallInterface::ContentAdded(const QDBusObjectPath & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelTypeCallInterface::ContentRemoved(const QDBusObjectPath & _t1, const Tp::CallStateReason & _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelTypeCallInterface::CallStateChanged(uint _t1, uint _t2, const Tp::CallStateReason & _t3, const QVariantMap & _t4)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void Tp::Client::ChannelTypeCallInterface::CallMembersChanged(const Tp::CallMemberMap & _t1, const Tp::HandleIdentifierMap & _t2, const Tp::UIntList & _t3, const Tp::CallStateReason & _t4)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeContactListInterface_t {
    QByteArrayData data[1];
    char stringdata[44];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeContactListInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeContactListInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeContactListInterface = {
    {
QT_MOC_LITERAL(0, 0, 43) // "Tp::Client::ChannelTypeContac..."

    },
    "Tp::Client::ChannelTypeContactListInterface"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeContactListInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Tp::Client::ChannelTypeContactListInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Tp::Client::ChannelTypeContactListInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeContactListInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeContactListInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeContactListInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeContactListInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeContactListInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeContactListInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeContactListInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeContactSearchInterface_t {
    QByteArrayData data[16];
    char stringdata[213];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeContactSearchInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeContactSearchInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeContactSearchInterface = {
    {
QT_MOC_LITERAL(0, 0, 45), // "Tp::Client::ChannelTypeContac..."
QT_MOC_LITERAL(1, 46, 18), // "SearchStateChanged"
QT_MOC_LITERAL(2, 65, 0), // ""
QT_MOC_LITERAL(3, 66, 5), // "state"
QT_MOC_LITERAL(4, 72, 5), // "error"
QT_MOC_LITERAL(5, 78, 7), // "details"
QT_MOC_LITERAL(6, 86, 20), // "SearchResultReceived"
QT_MOC_LITERAL(7, 107, 26), // "Tp::ContactSearchResultMap"
QT_MOC_LITERAL(8, 134, 6), // "result"
QT_MOC_LITERAL(9, 141, 6), // "Search"
QT_MOC_LITERAL(10, 148, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(11, 168, 20), // "Tp::ContactSearchMap"
QT_MOC_LITERAL(12, 189, 5), // "terms"
QT_MOC_LITERAL(13, 195, 7), // "timeout"
QT_MOC_LITERAL(14, 203, 4), // "More"
QT_MOC_LITERAL(15, 208, 4) // "Stop"

    },
    "Tp::Client::ChannelTypeContactSearchInterface\0"
    "SearchStateChanged\0\0state\0error\0details\0"
    "SearchResultReceived\0Tp::ContactSearchResultMap\0"
    "result\0Search\0QDBusPendingReply<>\0"
    "Tp::ContactSearchMap\0terms\0timeout\0"
    "More\0Stop"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeContactSearchInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       8,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       2,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    3,   54,    2, 0x06 /* Public */,
       6,    1,   61,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       9,    2,   64,    2, 0x0a /* Public */,
       9,    1,   69,    2, 0x2a /* Public | MethodCloned */,
      14,    1,   72,    2, 0x0a /* Public */,
      14,    0,   75,    2, 0x2a /* Public | MethodCloned */,
      15,    1,   76,    2, 0x0a /* Public */,
      15,    0,   79,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::QString, QMetaType::QVariantMap,    3,    4,    5,
    QMetaType::Void, 0x80000000 | 7,    8,

 // slots: parameters
    0x80000000 | 10, 0x80000000 | 11, QMetaType::Int,   12,   13,
    0x80000000 | 10, 0x80000000 | 11,   12,
    0x80000000 | 10, QMetaType::Int,   13,
    0x80000000 | 10,
    0x80000000 | 10, QMetaType::Int,   13,
    0x80000000 | 10,

       0        // eod
};

void Tp::Client::ChannelTypeContactSearchInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeContactSearchInterface *_t = static_cast<ChannelTypeContactSearchInterface *>(_o);
        switch (_id) {
        case 0: _t->SearchStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QVariantMap(*)>(_a[3]))); break;
        case 1: _t->SearchResultReceived((*reinterpret_cast< const Tp::ContactSearchResultMap(*)>(_a[1]))); break;
        case 2: { QDBusPendingReply<> _r = _t->Search((*reinterpret_cast< const Tp::ContactSearchMap(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<> _r = _t->Search((*reinterpret_cast< const Tp::ContactSearchMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<> _r = _t->More((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<> _r = _t->More();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<> _r = _t->Stop((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<> _r = _t->Stop();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::ContactSearchResultMap >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::ContactSearchMap >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::ContactSearchMap >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeContactSearchInterface::*_t)(uint , const QString & , const QVariantMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeContactSearchInterface::SearchStateChanged)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeContactSearchInterface::*_t)(const Tp::ContactSearchResultMap & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeContactSearchInterface::SearchResultReceived)) {
                *result = 1;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeContactSearchInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeContactSearchInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeContactSearchInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeContactSearchInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeContactSearchInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeContactSearchInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeContactSearchInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeContactSearchInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeContactSearchInterface::SearchStateChanged(uint _t1, const QString & _t2, const QVariantMap & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelTypeContactSearchInterface::SearchResultReceived(const Tp::ContactSearchResultMap & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeDBusTubeInterface_t {
    QByteArrayData data[13];
    char stringdata[184];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeDBusTubeInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeDBusTubeInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeDBusTubeInterface = {
    {
QT_MOC_LITERAL(0, 0, 40), // "Tp::Client::ChannelTypeDBusTu..."
QT_MOC_LITERAL(1, 41, 16), // "DBusNamesChanged"
QT_MOC_LITERAL(2, 58, 0), // ""
QT_MOC_LITERAL(3, 59, 24), // "Tp::DBusTubeParticipants"
QT_MOC_LITERAL(4, 84, 5), // "added"
QT_MOC_LITERAL(5, 90, 12), // "Tp::UIntList"
QT_MOC_LITERAL(6, 103, 7), // "removed"
QT_MOC_LITERAL(7, 111, 5), // "Offer"
QT_MOC_LITERAL(8, 117, 26), // "QDBusPendingReply<QString>"
QT_MOC_LITERAL(9, 144, 10), // "parameters"
QT_MOC_LITERAL(10, 155, 13), // "accesscontrol"
QT_MOC_LITERAL(11, 169, 7), // "timeout"
QT_MOC_LITERAL(12, 177, 6) // "Accept"

    },
    "Tp::Client::ChannelTypeDBusTubeInterface\0"
    "DBusNamesChanged\0\0Tp::DBusTubeParticipants\0"
    "added\0Tp::UIntList\0removed\0Offer\0"
    "QDBusPendingReply<QString>\0parameters\0"
    "accesscontrol\0timeout\0Accept"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeDBusTubeInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       5,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   39,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       7,    3,   44,    2, 0x0a /* Public */,
       7,    2,   51,    2, 0x2a /* Public | MethodCloned */,
      12,    2,   56,    2, 0x0a /* Public */,
      12,    1,   61,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3, 0x80000000 | 5,    4,    6,

 // slots: parameters
    0x80000000 | 8, QMetaType::QVariantMap, QMetaType::UInt, QMetaType::Int,    9,   10,   11,
    0x80000000 | 8, QMetaType::QVariantMap, QMetaType::UInt,    9,   10,
    0x80000000 | 8, QMetaType::UInt, QMetaType::Int,   10,   11,
    0x80000000 | 8, QMetaType::UInt,   10,

       0        // eod
};

void Tp::Client::ChannelTypeDBusTubeInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeDBusTubeInterface *_t = static_cast<ChannelTypeDBusTubeInterface *>(_o);
        switch (_id) {
        case 0: _t->DBusNamesChanged((*reinterpret_cast< const Tp::DBusTubeParticipants(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2]))); break;
        case 1: { QDBusPendingReply<QString> _r = _t->Offer((*reinterpret_cast< const QVariantMap(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 2: { QDBusPendingReply<QString> _r = _t->Offer((*reinterpret_cast< const QVariantMap(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<QString> _r = _t->Accept((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<QString> _r = _t->Accept((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::DBusTubeParticipants >(); break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeDBusTubeInterface::*_t)(const Tp::DBusTubeParticipants & , const Tp::UIntList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeDBusTubeInterface::DBusNamesChanged)) {
                *result = 0;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeDBusTubeInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeDBusTubeInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeDBusTubeInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeDBusTubeInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeDBusTubeInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeDBusTubeInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeDBusTubeInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeDBusTubeInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeDBusTubeInterface::DBusNamesChanged(const Tp::DBusTubeParticipants & _t1, const Tp::UIntList & _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeFileTransferInterface_t {
    QByteArrayData data[20];
    char stringdata[292];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeFileTransferInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeFileTransferInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeFileTransferInterface = {
    {
QT_MOC_LITERAL(0, 0, 44), // "Tp::Client::ChannelTypeFileTr..."
QT_MOC_LITERAL(1, 45, 24), // "FileTransferStateChanged"
QT_MOC_LITERAL(2, 70, 0), // ""
QT_MOC_LITERAL(3, 71, 5), // "state"
QT_MOC_LITERAL(4, 77, 6), // "reason"
QT_MOC_LITERAL(5, 84, 23), // "TransferredBytesChanged"
QT_MOC_LITERAL(6, 108, 5), // "count"
QT_MOC_LITERAL(7, 114, 20), // "InitialOffsetDefined"
QT_MOC_LITERAL(8, 135, 13), // "initialOffset"
QT_MOC_LITERAL(9, 149, 10), // "URIDefined"
QT_MOC_LITERAL(10, 160, 3), // "URI"
QT_MOC_LITERAL(11, 164, 10), // "AcceptFile"
QT_MOC_LITERAL(12, 175, 31), // "QDBusPendingReply<QDBusVariant>"
QT_MOC_LITERAL(13, 207, 11), // "addressType"
QT_MOC_LITERAL(14, 219, 13), // "accessControl"
QT_MOC_LITERAL(15, 233, 12), // "QDBusVariant"
QT_MOC_LITERAL(16, 246, 18), // "accessControlParam"
QT_MOC_LITERAL(17, 265, 6), // "offset"
QT_MOC_LITERAL(18, 272, 7), // "timeout"
QT_MOC_LITERAL(19, 280, 11) // "ProvideFile"

    },
    "Tp::Client::ChannelTypeFileTransferInterface\0"
    "FileTransferStateChanged\0\0state\0reason\0"
    "TransferredBytesChanged\0count\0"
    "InitialOffsetDefined\0initialOffset\0"
    "URIDefined\0URI\0AcceptFile\0"
    "QDBusPendingReply<QDBusVariant>\0"
    "addressType\0accessControl\0QDBusVariant\0"
    "accessControlParam\0offset\0timeout\0"
    "ProvideFile"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeFileTransferInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       8,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       4,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   54,    2, 0x06 /* Public */,
       5,    1,   59,    2, 0x06 /* Public */,
       7,    1,   62,    2, 0x06 /* Public */,
       9,    1,   65,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      11,    5,   68,    2, 0x0a /* Public */,
      11,    4,   79,    2, 0x2a /* Public | MethodCloned */,
      19,    4,   88,    2, 0x0a /* Public */,
      19,    3,   97,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    4,
    QMetaType::Void, QMetaType::ULongLong,    6,
    QMetaType::Void, QMetaType::ULongLong,    8,
    QMetaType::Void, QMetaType::QString,   10,

 // slots: parameters
    0x80000000 | 12, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 15, QMetaType::ULongLong, QMetaType::Int,   13,   14,   16,   17,   18,
    0x80000000 | 12, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 15, QMetaType::ULongLong,   13,   14,   16,   17,
    0x80000000 | 12, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 15, QMetaType::Int,   13,   14,   16,   18,
    0x80000000 | 12, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 15,   13,   14,   16,

       0        // eod
};

void Tp::Client::ChannelTypeFileTransferInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeFileTransferInterface *_t = static_cast<ChannelTypeFileTransferInterface *>(_o);
        switch (_id) {
        case 0: _t->FileTransferStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 1: _t->TransferredBytesChanged((*reinterpret_cast< qulonglong(*)>(_a[1]))); break;
        case 2: _t->InitialOffsetDefined((*reinterpret_cast< qulonglong(*)>(_a[1]))); break;
        case 3: _t->URIDefined((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 4: { QDBusPendingReply<QDBusVariant> _r = _t->AcceptFile((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QDBusVariant(*)>(_a[3])),(*reinterpret_cast< qulonglong(*)>(_a[4])),(*reinterpret_cast< int(*)>(_a[5])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<QDBusVariant> _r = _t->AcceptFile((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QDBusVariant(*)>(_a[3])),(*reinterpret_cast< qulonglong(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<QDBusVariant> _r = _t->ProvideFile((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QDBusVariant(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<QDBusVariant> _r = _t->ProvideFile((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QDBusVariant(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeFileTransferInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeFileTransferInterface::FileTransferStateChanged)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeFileTransferInterface::*_t)(qulonglong );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeFileTransferInterface::TransferredBytesChanged)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelTypeFileTransferInterface::*_t)(qulonglong );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeFileTransferInterface::InitialOffsetDefined)) {
                *result = 2;
            }
        }
        {
            typedef void (ChannelTypeFileTransferInterface::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeFileTransferInterface::URIDefined)) {
                *result = 3;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeFileTransferInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeFileTransferInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeFileTransferInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeFileTransferInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeFileTransferInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeFileTransferInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeFileTransferInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeFileTransferInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeFileTransferInterface::FileTransferStateChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelTypeFileTransferInterface::TransferredBytesChanged(qulonglong _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelTypeFileTransferInterface::InitialOffsetDefined(qulonglong _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void Tp::Client::ChannelTypeFileTransferInterface::URIDefined(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeRoomListInterface_t {
    QByteArrayData data[13];
    char stringdata[185];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeRoomListInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeRoomListInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeRoomListInterface = {
    {
QT_MOC_LITERAL(0, 0, 40), // "Tp::Client::ChannelTypeRoomLi..."
QT_MOC_LITERAL(1, 41, 8), // "GotRooms"
QT_MOC_LITERAL(2, 50, 0), // ""
QT_MOC_LITERAL(3, 51, 16), // "Tp::RoomInfoList"
QT_MOC_LITERAL(4, 68, 5), // "rooms"
QT_MOC_LITERAL(5, 74, 12), // "ListingRooms"
QT_MOC_LITERAL(6, 87, 7), // "listing"
QT_MOC_LITERAL(7, 95, 15), // "GetListingRooms"
QT_MOC_LITERAL(8, 111, 23), // "QDBusPendingReply<bool>"
QT_MOC_LITERAL(9, 135, 7), // "timeout"
QT_MOC_LITERAL(10, 143, 9), // "ListRooms"
QT_MOC_LITERAL(11, 153, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(12, 173, 11) // "StopListing"

    },
    "Tp::Client::ChannelTypeRoomListInterface\0"
    "GotRooms\0\0Tp::RoomInfoList\0rooms\0"
    "ListingRooms\0listing\0GetListingRooms\0"
    "QDBusPendingReply<bool>\0timeout\0"
    "ListRooms\0QDBusPendingReply<>\0StopListing"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeRoomListInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       8,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       2,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   54,    2, 0x06 /* Public */,
       5,    1,   57,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       7,    1,   60,    2, 0x0a /* Public */,
       7,    0,   63,    2, 0x2a /* Public | MethodCloned */,
      10,    1,   64,    2, 0x0a /* Public */,
      10,    0,   67,    2, 0x2a /* Public | MethodCloned */,
      12,    1,   68,    2, 0x0a /* Public */,
      12,    0,   71,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, QMetaType::Bool,    6,

 // slots: parameters
    0x80000000 | 8, QMetaType::Int,    9,
    0x80000000 | 8,
    0x80000000 | 11, QMetaType::Int,    9,
    0x80000000 | 11,
    0x80000000 | 11, QMetaType::Int,    9,
    0x80000000 | 11,

       0        // eod
};

void Tp::Client::ChannelTypeRoomListInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeRoomListInterface *_t = static_cast<ChannelTypeRoomListInterface *>(_o);
        switch (_id) {
        case 0: _t->GotRooms((*reinterpret_cast< const Tp::RoomInfoList(*)>(_a[1]))); break;
        case 1: _t->ListingRooms((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 2: { QDBusPendingReply<bool> _r = _t->GetListingRooms((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = _r; }  break;
        case 3: { QDBusPendingReply<bool> _r = _t->GetListingRooms();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<> _r = _t->ListRooms((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<> _r = _t->ListRooms();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<> _r = _t->StopListing((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<> _r = _t->StopListing();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::RoomInfoList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeRoomListInterface::*_t)(const Tp::RoomInfoList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeRoomListInterface::GotRooms)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeRoomListInterface::*_t)(bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeRoomListInterface::ListingRooms)) {
                *result = 1;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeRoomListInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeRoomListInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeRoomListInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeRoomListInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeRoomListInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeRoomListInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeRoomListInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeRoomListInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeRoomListInterface::GotRooms(const Tp::RoomInfoList & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelTypeRoomListInterface::ListingRooms(bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeServerAuthenticationInterface_t {
    QByteArrayData data[1];
    char stringdata[53];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeServerAuthenticationInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeServerAuthenticationInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeServerAuthenticationInterface = {
    {
QT_MOC_LITERAL(0, 0, 52) // "Tp::Client::ChannelTypeServer..."

    },
    "Tp::Client::ChannelTypeServerAuthenticationInterface"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeServerAuthenticationInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Tp::Client::ChannelTypeServerAuthenticationInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Tp::Client::ChannelTypeServerAuthenticationInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeServerAuthenticationInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeServerAuthenticationInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeServerAuthenticationInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeServerAuthenticationInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeServerAuthenticationInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeServerAuthenticationInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeServerAuthenticationInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeServerTLSConnectionInterface_t {
    QByteArrayData data[1];
    char stringdata[52];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeServerTLSConnectionInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeServerTLSConnectionInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeServerTLSConnectionInterface = {
    {
QT_MOC_LITERAL(0, 0, 51) // "Tp::Client::ChannelTypeServer..."

    },
    "Tp::Client::ChannelTypeServerTLSConnectionInterface"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeServerTLSConnectionInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Tp::Client::ChannelTypeServerTLSConnectionInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Tp::Client::ChannelTypeServerTLSConnectionInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeServerTLSConnectionInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeServerTLSConnectionInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeServerTLSConnectionInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeServerTLSConnectionInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeServerTLSConnectionInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeServerTLSConnectionInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeServerTLSConnectionInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeStreamTubeInterface_t {
    QByteArrayData data[21];
    char stringdata[300];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeStreamTubeInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeStreamTubeInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeStreamTubeInterface = {
    {
QT_MOC_LITERAL(0, 0, 42), // "Tp::Client::ChannelTypeStream..."
QT_MOC_LITERAL(1, 43, 19), // "NewRemoteConnection"
QT_MOC_LITERAL(2, 63, 0), // ""
QT_MOC_LITERAL(3, 64, 6), // "handle"
QT_MOC_LITERAL(4, 71, 12), // "QDBusVariant"
QT_MOC_LITERAL(5, 84, 15), // "connectionParam"
QT_MOC_LITERAL(6, 100, 12), // "connectionID"
QT_MOC_LITERAL(7, 113, 18), // "NewLocalConnection"
QT_MOC_LITERAL(8, 132, 16), // "ConnectionClosed"
QT_MOC_LITERAL(9, 149, 5), // "error"
QT_MOC_LITERAL(10, 155, 7), // "message"
QT_MOC_LITERAL(11, 163, 5), // "Offer"
QT_MOC_LITERAL(12, 169, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(13, 189, 11), // "addresstype"
QT_MOC_LITERAL(14, 201, 7), // "address"
QT_MOC_LITERAL(15, 209, 13), // "accesscontrol"
QT_MOC_LITERAL(16, 223, 10), // "parameters"
QT_MOC_LITERAL(17, 234, 7), // "timeout"
QT_MOC_LITERAL(18, 242, 6), // "Accept"
QT_MOC_LITERAL(19, 249, 31), // "QDBusPendingReply<QDBusVariant>"
QT_MOC_LITERAL(20, 281, 18) // "accesscontrolparam"

    },
    "Tp::Client::ChannelTypeStreamTubeInterface\0"
    "NewRemoteConnection\0\0handle\0QDBusVariant\0"
    "connectionParam\0connectionID\0"
    "NewLocalConnection\0ConnectionClosed\0"
    "error\0message\0Offer\0QDBusPendingReply<>\0"
    "addresstype\0address\0accesscontrol\0"
    "parameters\0timeout\0Accept\0"
    "QDBusPendingReply<QDBusVariant>\0"
    "accesscontrolparam"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeStreamTubeInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       7,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       3,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    3,   49,    2, 0x06 /* Public */,
       7,    1,   56,    2, 0x06 /* Public */,
       8,    3,   59,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      11,    5,   66,    2, 0x0a /* Public */,
      11,    4,   77,    2, 0x2a /* Public | MethodCloned */,
      18,    4,   86,    2, 0x0a /* Public */,
      18,    3,   95,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, 0x80000000 | 4, QMetaType::UInt,    3,    5,    6,
    QMetaType::Void, QMetaType::UInt,    6,
    QMetaType::Void, QMetaType::UInt, QMetaType::QString, QMetaType::QString,    6,    9,   10,

 // slots: parameters
    0x80000000 | 12, QMetaType::UInt, 0x80000000 | 4, QMetaType::UInt, QMetaType::QVariantMap, QMetaType::Int,   13,   14,   15,   16,   17,
    0x80000000 | 12, QMetaType::UInt, 0x80000000 | 4, QMetaType::UInt, QMetaType::QVariantMap,   13,   14,   15,   16,
    0x80000000 | 19, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 4, QMetaType::Int,   13,   15,   20,   17,
    0x80000000 | 19, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 4,   13,   15,   20,

       0        // eod
};

void Tp::Client::ChannelTypeStreamTubeInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeStreamTubeInterface *_t = static_cast<ChannelTypeStreamTubeInterface *>(_o);
        switch (_id) {
        case 0: _t->NewRemoteConnection((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QDBusVariant(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3]))); break;
        case 1: _t->NewLocalConnection((*reinterpret_cast< uint(*)>(_a[1]))); break;
        case 2: _t->ConnectionClosed((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
        case 3: { QDBusPendingReply<> _r = _t->Offer((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QDBusVariant(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QVariantMap(*)>(_a[4])),(*reinterpret_cast< int(*)>(_a[5])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 4: { QDBusPendingReply<> _r = _t->Offer((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QDBusVariant(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QVariantMap(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<QDBusVariant> _r = _t->Accept((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QDBusVariant(*)>(_a[3])),(*reinterpret_cast< int(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<QDBusVariant> _r = _t->Accept((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QDBusVariant(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeStreamTubeInterface::*_t)(uint , const QDBusVariant & , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamTubeInterface::NewRemoteConnection)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeStreamTubeInterface::*_t)(uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamTubeInterface::NewLocalConnection)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelTypeStreamTubeInterface::*_t)(uint , const QString & , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamTubeInterface::ConnectionClosed)) {
                *result = 2;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeStreamTubeInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeStreamTubeInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeStreamTubeInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeStreamTubeInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeStreamTubeInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeStreamTubeInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeStreamTubeInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeStreamTubeInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeStreamTubeInterface::NewRemoteConnection(uint _t1, const QDBusVariant & _t2, uint _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelTypeStreamTubeInterface::NewLocalConnection(uint _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelTypeStreamTubeInterface::ConnectionClosed(uint _t1, const QString & _t2, const QString & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeStreamedMediaInterface_t {
    QByteArrayData data[25];
    char stringdata[382];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeStreamedMediaInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeStreamedMediaInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeStreamedMediaInterface = {
    {
QT_MOC_LITERAL(0, 0, 45), // "Tp::Client::ChannelTypeStream..."
QT_MOC_LITERAL(1, 46, 11), // "StreamAdded"
QT_MOC_LITERAL(2, 58, 0), // ""
QT_MOC_LITERAL(3, 59, 8), // "streamID"
QT_MOC_LITERAL(4, 68, 13), // "contactHandle"
QT_MOC_LITERAL(5, 82, 10), // "streamType"
QT_MOC_LITERAL(6, 93, 22), // "StreamDirectionChanged"
QT_MOC_LITERAL(7, 116, 15), // "streamDirection"
QT_MOC_LITERAL(8, 132, 12), // "pendingFlags"
QT_MOC_LITERAL(9, 145, 11), // "StreamError"
QT_MOC_LITERAL(10, 157, 9), // "errorCode"
QT_MOC_LITERAL(11, 167, 7), // "message"
QT_MOC_LITERAL(12, 175, 13), // "StreamRemoved"
QT_MOC_LITERAL(13, 189, 18), // "StreamStateChanged"
QT_MOC_LITERAL(14, 208, 11), // "streamState"
QT_MOC_LITERAL(15, 220, 11), // "ListStreams"
QT_MOC_LITERAL(16, 232, 42), // "QDBusPendingReply<Tp::MediaSt..."
QT_MOC_LITERAL(17, 275, 7), // "timeout"
QT_MOC_LITERAL(18, 283, 13), // "RemoveStreams"
QT_MOC_LITERAL(19, 297, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(20, 317, 12), // "Tp::UIntList"
QT_MOC_LITERAL(21, 330, 7), // "streams"
QT_MOC_LITERAL(22, 338, 22), // "RequestStreamDirection"
QT_MOC_LITERAL(23, 361, 14), // "RequestStreams"
QT_MOC_LITERAL(24, 376, 5) // "types"

    },
    "Tp::Client::ChannelTypeStreamedMediaInterface\0"
    "StreamAdded\0\0streamID\0contactHandle\0"
    "streamType\0StreamDirectionChanged\0"
    "streamDirection\0pendingFlags\0StreamError\0"
    "errorCode\0message\0StreamRemoved\0"
    "StreamStateChanged\0streamState\0"
    "ListStreams\0QDBusPendingReply<Tp::MediaStreamInfoList>\0"
    "timeout\0RemoveStreams\0QDBusPendingReply<>\0"
    "Tp::UIntList\0streams\0RequestStreamDirection\0"
    "RequestStreams\0types"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeStreamedMediaInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      13,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       5,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    3,   79,    2, 0x06 /* Public */,
       6,    3,   86,    2, 0x06 /* Public */,
       9,    3,   93,    2, 0x06 /* Public */,
      12,    1,  100,    2, 0x06 /* Public */,
      13,    2,  103,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      15,    1,  108,    2, 0x0a /* Public */,
      15,    0,  111,    2, 0x2a /* Public | MethodCloned */,
      18,    2,  112,    2, 0x0a /* Public */,
      18,    1,  117,    2, 0x2a /* Public | MethodCloned */,
      22,    3,  120,    2, 0x0a /* Public */,
      22,    2,  127,    2, 0x2a /* Public | MethodCloned */,
      23,    3,  132,    2, 0x0a /* Public */,
      23,    2,  139,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt,    3,    4,    5,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt,    3,    7,    8,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, QMetaType::QString,    3,   10,   11,
    QMetaType::Void, QMetaType::UInt,    3,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,   14,

 // slots: parameters
    0x80000000 | 16, QMetaType::Int,   17,
    0x80000000 | 16,
    0x80000000 | 19, 0x80000000 | 20, QMetaType::Int,   21,   17,
    0x80000000 | 19, 0x80000000 | 20,   21,
    0x80000000 | 19, QMetaType::UInt, QMetaType::UInt, QMetaType::Int,    3,    7,   17,
    0x80000000 | 19, QMetaType::UInt, QMetaType::UInt,    3,    7,
    0x80000000 | 16, QMetaType::UInt, 0x80000000 | 20, QMetaType::Int,    4,   24,   17,
    0x80000000 | 16, QMetaType::UInt, 0x80000000 | 20,    4,   24,

       0        // eod
};

void Tp::Client::ChannelTypeStreamedMediaInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeStreamedMediaInterface *_t = static_cast<ChannelTypeStreamedMediaInterface *>(_o);
        switch (_id) {
        case 0: _t->StreamAdded((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3]))); break;
        case 1: _t->StreamDirectionChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3]))); break;
        case 2: _t->StreamError((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
        case 3: _t->StreamRemoved((*reinterpret_cast< uint(*)>(_a[1]))); break;
        case 4: _t->StreamStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 5: { QDBusPendingReply<Tp::MediaStreamInfoList> _r = _t->ListStreams((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MediaStreamInfoList>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<Tp::MediaStreamInfoList> _r = _t->ListStreams();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MediaStreamInfoList>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<> _r = _t->RemoveStreams((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<> _r = _t->RemoveStreams((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 9: { QDBusPendingReply<> _r = _t->RequestStreamDirection((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 10: { QDBusPendingReply<> _r = _t->RequestStreamDirection((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 11: { QDBusPendingReply<Tp::MediaStreamInfoList> _r = _t->RequestStreams((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MediaStreamInfoList>*>(_a[0]) = _r; }  break;
        case 12: { QDBusPendingReply<Tp::MediaStreamInfoList> _r = _t->RequestStreams((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::MediaStreamInfoList>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 11:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeStreamedMediaInterface::*_t)(uint , uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamedMediaInterface::StreamAdded)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeStreamedMediaInterface::*_t)(uint , uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamedMediaInterface::StreamDirectionChanged)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelTypeStreamedMediaInterface::*_t)(uint , uint , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamedMediaInterface::StreamError)) {
                *result = 2;
            }
        }
        {
            typedef void (ChannelTypeStreamedMediaInterface::*_t)(uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamedMediaInterface::StreamRemoved)) {
                *result = 3;
            }
        }
        {
            typedef void (ChannelTypeStreamedMediaInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeStreamedMediaInterface::StreamStateChanged)) {
                *result = 4;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeStreamedMediaInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeStreamedMediaInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeStreamedMediaInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeStreamedMediaInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeStreamedMediaInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeStreamedMediaInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeStreamedMediaInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeStreamedMediaInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 13)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 13;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 13)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 13;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeStreamedMediaInterface::StreamAdded(uint _t1, uint _t2, uint _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelTypeStreamedMediaInterface::StreamDirectionChanged(uint _t1, uint _t2, uint _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelTypeStreamedMediaInterface::StreamError(uint _t1, uint _t2, const QString & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void Tp::Client::ChannelTypeStreamedMediaInterface::StreamRemoved(uint _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void Tp::Client::ChannelTypeStreamedMediaInterface::StreamStateChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeTextInterface_t {
    QByteArrayData data[24];
    char stringdata[313];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeTextInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeTextInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeTextInterface = {
    {
QT_MOC_LITERAL(0, 0, 36), // "Tp::Client::ChannelTypeTextIn..."
QT_MOC_LITERAL(1, 37, 11), // "LostMessage"
QT_MOC_LITERAL(2, 49, 0), // ""
QT_MOC_LITERAL(3, 50, 8), // "Received"
QT_MOC_LITERAL(4, 59, 2), // "ID"
QT_MOC_LITERAL(5, 62, 9), // "timestamp"
QT_MOC_LITERAL(6, 72, 6), // "sender"
QT_MOC_LITERAL(7, 79, 4), // "type"
QT_MOC_LITERAL(8, 84, 5), // "flags"
QT_MOC_LITERAL(9, 90, 4), // "text"
QT_MOC_LITERAL(10, 95, 9), // "SendError"
QT_MOC_LITERAL(11, 105, 5), // "error"
QT_MOC_LITERAL(12, 111, 4), // "Sent"
QT_MOC_LITERAL(13, 116, 26), // "AcknowledgePendingMessages"
QT_MOC_LITERAL(14, 143, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(15, 163, 12), // "Tp::UIntList"
QT_MOC_LITERAL(16, 176, 3), // "IDs"
QT_MOC_LITERAL(17, 180, 7), // "timeout"
QT_MOC_LITERAL(18, 188, 15), // "GetMessageTypes"
QT_MOC_LITERAL(19, 204, 31), // "QDBusPendingReply<Tp::UIntList>"
QT_MOC_LITERAL(20, 236, 19), // "ListPendingMessages"
QT_MOC_LITERAL(21, 256, 45), // "QDBusPendingReply<Tp::Pending..."
QT_MOC_LITERAL(22, 302, 5), // "clear"
QT_MOC_LITERAL(23, 308, 4) // "Send"

    },
    "Tp::Client::ChannelTypeTextInterface\0"
    "LostMessage\0\0Received\0ID\0timestamp\0"
    "sender\0type\0flags\0text\0SendError\0error\0"
    "Sent\0AcknowledgePendingMessages\0"
    "QDBusPendingReply<>\0Tp::UIntList\0IDs\0"
    "timeout\0GetMessageTypes\0"
    "QDBusPendingReply<Tp::UIntList>\0"
    "ListPendingMessages\0"
    "QDBusPendingReply<Tp::PendingTextMessageList>\0"
    "clear\0Send"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeTextInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      12,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       4,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    0,   74,    2, 0x06 /* Public */,
       3,    6,   75,    2, 0x06 /* Public */,
      10,    4,   88,    2, 0x06 /* Public */,
      12,    3,   97,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      13,    2,  104,    2, 0x0a /* Public */,
      13,    1,  109,    2, 0x2a /* Public | MethodCloned */,
      18,    1,  112,    2, 0x0a /* Public */,
      18,    0,  115,    2, 0x2a /* Public | MethodCloned */,
      20,    2,  116,    2, 0x0a /* Public */,
      20,    1,  121,    2, 0x2a /* Public | MethodCloned */,
      23,    3,  124,    2, 0x0a /* Public */,
      23,    2,  131,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt, QMetaType::QString,    4,    5,    6,    7,    8,    9,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt, QMetaType::QString,   11,    5,    7,    9,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, QMetaType::QString,    5,    7,    9,

 // slots: parameters
    0x80000000 | 14, 0x80000000 | 15, QMetaType::Int,   16,   17,
    0x80000000 | 14, 0x80000000 | 15,   16,
    0x80000000 | 19, QMetaType::Int,   17,
    0x80000000 | 19,
    0x80000000 | 21, QMetaType::Bool, QMetaType::Int,   22,   17,
    0x80000000 | 21, QMetaType::Bool,   22,
    0x80000000 | 14, QMetaType::UInt, QMetaType::QString, QMetaType::Int,    7,    9,   17,
    0x80000000 | 14, QMetaType::UInt, QMetaType::QString,    7,    9,

       0        // eod
};

void Tp::Client::ChannelTypeTextInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeTextInterface *_t = static_cast<ChannelTypeTextInterface *>(_o);
        switch (_id) {
        case 0: _t->LostMessage(); break;
        case 1: _t->Received((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< uint(*)>(_a[4])),(*reinterpret_cast< uint(*)>(_a[5])),(*reinterpret_cast< const QString(*)>(_a[6]))); break;
        case 2: _t->SendError((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QString(*)>(_a[4]))); break;
        case 3: _t->Sent((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
        case 4: { QDBusPendingReply<> _r = _t->AcknowledgePendingMessages((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 5: { QDBusPendingReply<> _r = _t->AcknowledgePendingMessages((*reinterpret_cast< const Tp::UIntList(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<Tp::UIntList> _r = _t->GetMessageTypes((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<Tp::UIntList> _r = _t->GetMessageTypes();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<Tp::PendingTextMessageList> _r = _t->ListPendingMessages((*reinterpret_cast< bool(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::PendingTextMessageList>*>(_a[0]) = _r; }  break;
        case 9: { QDBusPendingReply<Tp::PendingTextMessageList> _r = _t->ListPendingMessages((*reinterpret_cast< bool(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::PendingTextMessageList>*>(_a[0]) = _r; }  break;
        case 10: { QDBusPendingReply<> _r = _t->Send((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 11: { QDBusPendingReply<> _r = _t->Send((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeTextInterface::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTextInterface::LostMessage)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeTextInterface::*_t)(uint , uint , uint , uint , uint , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTextInterface::Received)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelTypeTextInterface::*_t)(uint , uint , uint , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTextInterface::SendError)) {
                *result = 2;
            }
        }
        {
            typedef void (ChannelTypeTextInterface::*_t)(uint , uint , const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTextInterface::Sent)) {
                *result = 3;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeTextInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeTextInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeTextInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeTextInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeTextInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeTextInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeTextInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeTextInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 12)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 12;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 12)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 12;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeTextInterface::LostMessage()
{
    QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
}

// SIGNAL 1
void Tp::Client::ChannelTypeTextInterface::Received(uint _t1, uint _t2, uint _t3, uint _t4, uint _t5, const QString & _t6)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)), const_cast<void*>(reinterpret_cast<const void*>(&_t5)), const_cast<void*>(reinterpret_cast<const void*>(&_t6)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelTypeTextInterface::SendError(uint _t1, uint _t2, uint _t3, const QString & _t4)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void Tp::Client::ChannelTypeTextInterface::Sent(uint _t1, uint _t2, const QString & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}
struct qt_meta_stringdata_Tp__Client__ChannelTypeTubesInterface_t {
    QByteArrayData data[44];
    char stringdata[773];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Tp__Client__ChannelTypeTubesInterface_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Tp__Client__ChannelTypeTubesInterface_t qt_meta_stringdata_Tp__Client__ChannelTypeTubesInterface = {
    {
QT_MOC_LITERAL(0, 0, 37), // "Tp::Client::ChannelTypeTubesI..."
QT_MOC_LITERAL(1, 38, 7), // "NewTube"
QT_MOC_LITERAL(2, 46, 0), // ""
QT_MOC_LITERAL(3, 47, 2), // "ID"
QT_MOC_LITERAL(4, 50, 9), // "initiator"
QT_MOC_LITERAL(5, 60, 4), // "type"
QT_MOC_LITERAL(6, 65, 7), // "service"
QT_MOC_LITERAL(7, 73, 10), // "parameters"
QT_MOC_LITERAL(8, 84, 5), // "state"
QT_MOC_LITERAL(9, 90, 16), // "TubeStateChanged"
QT_MOC_LITERAL(10, 107, 10), // "TubeClosed"
QT_MOC_LITERAL(11, 118, 16), // "DBusNamesChanged"
QT_MOC_LITERAL(12, 135, 22), // "Tp::DBusTubeMemberList"
QT_MOC_LITERAL(13, 158, 5), // "added"
QT_MOC_LITERAL(14, 164, 12), // "Tp::UIntList"
QT_MOC_LITERAL(15, 177, 7), // "removed"
QT_MOC_LITERAL(16, 185, 23), // "StreamTubeNewConnection"
QT_MOC_LITERAL(17, 209, 6), // "handle"
QT_MOC_LITERAL(18, 216, 27), // "GetAvailableStreamTubeTypes"
QT_MOC_LITERAL(19, 244, 41), // "QDBusPendingReply<Tp::Support..."
QT_MOC_LITERAL(20, 286, 7), // "timeout"
QT_MOC_LITERAL(21, 294, 21), // "GetAvailableTubeTypes"
QT_MOC_LITERAL(22, 316, 31), // "QDBusPendingReply<Tp::UIntList>"
QT_MOC_LITERAL(23, 348, 9), // "ListTubes"
QT_MOC_LITERAL(24, 358, 35), // "QDBusPendingReply<Tp::TubeInf..."
QT_MOC_LITERAL(25, 394, 13), // "OfferDBusTube"
QT_MOC_LITERAL(26, 408, 23), // "QDBusPendingReply<uint>"
QT_MOC_LITERAL(27, 432, 15), // "OfferStreamTube"
QT_MOC_LITERAL(28, 448, 11), // "addressType"
QT_MOC_LITERAL(29, 460, 12), // "QDBusVariant"
QT_MOC_LITERAL(30, 473, 7), // "address"
QT_MOC_LITERAL(31, 481, 13), // "accessControl"
QT_MOC_LITERAL(32, 495, 18), // "accessControlParam"
QT_MOC_LITERAL(33, 514, 14), // "AcceptDBusTube"
QT_MOC_LITERAL(34, 529, 26), // "QDBusPendingReply<QString>"
QT_MOC_LITERAL(35, 556, 16), // "AcceptStreamTube"
QT_MOC_LITERAL(36, 573, 31), // "QDBusPendingReply<QDBusVariant>"
QT_MOC_LITERAL(37, 605, 9), // "CloseTube"
QT_MOC_LITERAL(38, 615, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(39, 635, 18), // "GetDBusTubeAddress"
QT_MOC_LITERAL(40, 654, 12), // "GetDBusNames"
QT_MOC_LITERAL(41, 667, 41), // "QDBusPendingReply<Tp::DBusTub..."
QT_MOC_LITERAL(42, 709, 26), // "GetStreamTubeSocketAddress"
QT_MOC_LITERAL(43, 736, 36) // "QDBusPendingReply<uint,QDBusV..."

    },
    "Tp::Client::ChannelTypeTubesInterface\0"
    "NewTube\0\0ID\0initiator\0type\0service\0"
    "parameters\0state\0TubeStateChanged\0"
    "TubeClosed\0DBusNamesChanged\0"
    "Tp::DBusTubeMemberList\0added\0Tp::UIntList\0"
    "removed\0StreamTubeNewConnection\0handle\0"
    "GetAvailableStreamTubeTypes\0"
    "QDBusPendingReply<Tp::SupportedSocketMap>\0"
    "timeout\0GetAvailableTubeTypes\0"
    "QDBusPendingReply<Tp::UIntList>\0"
    "ListTubes\0QDBusPendingReply<Tp::TubeInfoList>\0"
    "OfferDBusTube\0QDBusPendingReply<uint>\0"
    "OfferStreamTube\0addressType\0QDBusVariant\0"
    "address\0accessControl\0accessControlParam\0"
    "AcceptDBusTube\0QDBusPendingReply<QString>\0"
    "AcceptStreamTube\0QDBusPendingReply<QDBusVariant>\0"
    "CloseTube\0QDBusPendingReply<>\0"
    "GetDBusTubeAddress\0GetDBusNames\0"
    "QDBusPendingReply<Tp::DBusTubeMemberList>\0"
    "GetStreamTubeSocketAddress\0"
    "QDBusPendingReply<uint,QDBusVariant>"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Tp__Client__ChannelTypeTubesInterface[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      27,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       5,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    6,  149,    2, 0x06 /* Public */,
       9,    2,  162,    2, 0x06 /* Public */,
      10,    1,  167,    2, 0x06 /* Public */,
      11,    3,  170,    2, 0x06 /* Public */,
      16,    2,  177,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      18,    1,  182,    2, 0x0a /* Public */,
      18,    0,  185,    2, 0x2a /* Public | MethodCloned */,
      21,    1,  186,    2, 0x0a /* Public */,
      21,    0,  189,    2, 0x2a /* Public | MethodCloned */,
      23,    1,  190,    2, 0x0a /* Public */,
      23,    0,  193,    2, 0x2a /* Public | MethodCloned */,
      25,    3,  194,    2, 0x0a /* Public */,
      25,    2,  201,    2, 0x2a /* Public | MethodCloned */,
      27,    7,  206,    2, 0x0a /* Public */,
      27,    6,  221,    2, 0x2a /* Public | MethodCloned */,
      33,    2,  234,    2, 0x0a /* Public */,
      33,    1,  239,    2, 0x2a /* Public | MethodCloned */,
      35,    5,  242,    2, 0x0a /* Public */,
      35,    4,  253,    2, 0x2a /* Public | MethodCloned */,
      37,    2,  262,    2, 0x0a /* Public */,
      37,    1,  267,    2, 0x2a /* Public | MethodCloned */,
      39,    2,  270,    2, 0x0a /* Public */,
      39,    1,  275,    2, 0x2a /* Public | MethodCloned */,
      40,    2,  278,    2, 0x0a /* Public */,
      40,    1,  283,    2, 0x2a /* Public | MethodCloned */,
      42,    2,  286,    2, 0x0a /* Public */,
      42,    1,  291,    2, 0x2a /* Public | MethodCloned */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt, QMetaType::QString, QMetaType::QVariantMap, QMetaType::UInt,    3,    4,    5,    6,    7,    8,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    8,
    QMetaType::Void, QMetaType::UInt,    3,
    QMetaType::Void, QMetaType::UInt, 0x80000000 | 12, 0x80000000 | 14,    3,   13,   15,
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,   17,

 // slots: parameters
    0x80000000 | 19, QMetaType::Int,   20,
    0x80000000 | 19,
    0x80000000 | 22, QMetaType::Int,   20,
    0x80000000 | 22,
    0x80000000 | 24, QMetaType::Int,   20,
    0x80000000 | 24,
    0x80000000 | 26, QMetaType::QString, QMetaType::QVariantMap, QMetaType::Int,    6,    7,   20,
    0x80000000 | 26, QMetaType::QString, QMetaType::QVariantMap,    6,    7,
    0x80000000 | 26, QMetaType::QString, QMetaType::QVariantMap, QMetaType::UInt, 0x80000000 | 29, QMetaType::UInt, 0x80000000 | 29, QMetaType::Int,    6,    7,   28,   30,   31,   32,   20,
    0x80000000 | 26, QMetaType::QString, QMetaType::QVariantMap, QMetaType::UInt, 0x80000000 | 29, QMetaType::UInt, 0x80000000 | 29,    6,    7,   28,   30,   31,   32,
    0x80000000 | 34, QMetaType::UInt, QMetaType::Int,    3,   20,
    0x80000000 | 34, QMetaType::UInt,    3,
    0x80000000 | 36, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 29, QMetaType::Int,    3,   28,   31,   32,   20,
    0x80000000 | 36, QMetaType::UInt, QMetaType::UInt, QMetaType::UInt, 0x80000000 | 29,    3,   28,   31,   32,
    0x80000000 | 38, QMetaType::UInt, QMetaType::Int,    3,   20,
    0x80000000 | 38, QMetaType::UInt,    3,
    0x80000000 | 34, QMetaType::UInt, QMetaType::Int,    3,   20,
    0x80000000 | 34, QMetaType::UInt,    3,
    0x80000000 | 41, QMetaType::UInt, QMetaType::Int,    3,   20,
    0x80000000 | 41, QMetaType::UInt,    3,
    0x80000000 | 43, QMetaType::UInt, QMetaType::Int,    3,   20,
    0x80000000 | 43, QMetaType::UInt,    3,

       0        // eod
};

void Tp::Client::ChannelTypeTubesInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ChannelTypeTubesInterface *_t = static_cast<ChannelTypeTubesInterface *>(_o);
        switch (_id) {
        case 0: _t->NewTube((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QString(*)>(_a[4])),(*reinterpret_cast< const QVariantMap(*)>(_a[5])),(*reinterpret_cast< uint(*)>(_a[6]))); break;
        case 1: _t->TubeStateChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 2: _t->TubeClosed((*reinterpret_cast< uint(*)>(_a[1]))); break;
        case 3: _t->DBusNamesChanged((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const Tp::DBusTubeMemberList(*)>(_a[2])),(*reinterpret_cast< const Tp::UIntList(*)>(_a[3]))); break;
        case 4: _t->StreamTubeNewConnection((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 5: { QDBusPendingReply<Tp::SupportedSocketMap> _r = _t->GetAvailableStreamTubeTypes((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::SupportedSocketMap>*>(_a[0]) = _r; }  break;
        case 6: { QDBusPendingReply<Tp::SupportedSocketMap> _r = _t->GetAvailableStreamTubeTypes();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::SupportedSocketMap>*>(_a[0]) = _r; }  break;
        case 7: { QDBusPendingReply<Tp::UIntList> _r = _t->GetAvailableTubeTypes((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 8: { QDBusPendingReply<Tp::UIntList> _r = _t->GetAvailableTubeTypes();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::UIntList>*>(_a[0]) = _r; }  break;
        case 9: { QDBusPendingReply<Tp::TubeInfoList> _r = _t->ListTubes((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::TubeInfoList>*>(_a[0]) = _r; }  break;
        case 10: { QDBusPendingReply<Tp::TubeInfoList> _r = _t->ListTubes();
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::TubeInfoList>*>(_a[0]) = _r; }  break;
        case 11: { QDBusPendingReply<uint> _r = _t->OfferDBusTube((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 12: { QDBusPendingReply<uint> _r = _t->OfferDBusTube((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 13: { QDBusPendingReply<uint> _r = _t->OfferStreamTube((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QDBusVariant(*)>(_a[4])),(*reinterpret_cast< uint(*)>(_a[5])),(*reinterpret_cast< const QDBusVariant(*)>(_a[6])),(*reinterpret_cast< int(*)>(_a[7])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 14: { QDBusPendingReply<uint> _r = _t->OfferStreamTube((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QDBusVariant(*)>(_a[4])),(*reinterpret_cast< uint(*)>(_a[5])),(*reinterpret_cast< const QDBusVariant(*)>(_a[6])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint>*>(_a[0]) = _r; }  break;
        case 15: { QDBusPendingReply<QString> _r = _t->AcceptDBusTube((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 16: { QDBusPendingReply<QString> _r = _t->AcceptDBusTube((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 17: { QDBusPendingReply<QDBusVariant> _r = _t->AcceptStreamTube((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QDBusVariant(*)>(_a[4])),(*reinterpret_cast< int(*)>(_a[5])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        case 18: { QDBusPendingReply<QDBusVariant> _r = _t->AcceptStreamTube((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< uint(*)>(_a[3])),(*reinterpret_cast< const QDBusVariant(*)>(_a[4])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusVariant>*>(_a[0]) = _r; }  break;
        case 19: { QDBusPendingReply<> _r = _t->CloseTube((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 20: { QDBusPendingReply<> _r = _t->CloseTube((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = _r; }  break;
        case 21: { QDBusPendingReply<QString> _r = _t->GetDBusTubeAddress((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 22: { QDBusPendingReply<QString> _r = _t->GetDBusTubeAddress((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = _r; }  break;
        case 23: { QDBusPendingReply<Tp::DBusTubeMemberList> _r = _t->GetDBusNames((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::DBusTubeMemberList>*>(_a[0]) = _r; }  break;
        case 24: { QDBusPendingReply<Tp::DBusTubeMemberList> _r = _t->GetDBusNames((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<Tp::DBusTubeMemberList>*>(_a[0]) = _r; }  break;
        case 25: { QDBusPendingReply<uint,QDBusVariant> _r = _t->GetStreamTubeSocketAddress((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,QDBusVariant>*>(_a[0]) = _r; }  break;
        case 26: { QDBusPendingReply<uint,QDBusVariant> _r = _t->GetStreamTubeSocketAddress((*reinterpret_cast< uint(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uint,QDBusVariant>*>(_a[0]) = _r; }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 1:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::DBusTubeMemberList >(); break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Tp::UIntList >(); break;
            }
            break;
        case 13:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 5:
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 5:
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 17:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (ChannelTypeTubesInterface::*_t)(uint , uint , uint , const QString & , const QVariantMap & , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTubesInterface::NewTube)) {
                *result = 0;
            }
        }
        {
            typedef void (ChannelTypeTubesInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTubesInterface::TubeStateChanged)) {
                *result = 1;
            }
        }
        {
            typedef void (ChannelTypeTubesInterface::*_t)(uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTubesInterface::TubeClosed)) {
                *result = 2;
            }
        }
        {
            typedef void (ChannelTypeTubesInterface::*_t)(uint , const Tp::DBusTubeMemberList & , const Tp::UIntList & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTubesInterface::DBusNamesChanged)) {
                *result = 3;
            }
        }
        {
            typedef void (ChannelTypeTubesInterface::*_t)(uint , uint );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ChannelTypeTubesInterface::StreamTubeNewConnection)) {
                *result = 4;
            }
        }
    }
}

const QMetaObject Tp::Client::ChannelTypeTubesInterface::staticMetaObject = {
    { &Tp::AbstractInterface::staticMetaObject, qt_meta_stringdata_Tp__Client__ChannelTypeTubesInterface.data,
      qt_meta_data_Tp__Client__ChannelTypeTubesInterface,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Tp::Client::ChannelTypeTubesInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Tp::Client::ChannelTypeTubesInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__Client__ChannelTypeTubesInterface.stringdata))
        return static_cast<void*>(const_cast< ChannelTypeTubesInterface*>(this));
    return Tp::AbstractInterface::qt_metacast(_clname);
}

int Tp::Client::ChannelTypeTubesInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tp::AbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 27)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 27;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 27)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 27;
    }
    return _id;
}

// SIGNAL 0
void Tp::Client::ChannelTypeTubesInterface::NewTube(uint _t1, uint _t2, uint _t3, const QString & _t4, const QVariantMap & _t5, uint _t6)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)), const_cast<void*>(reinterpret_cast<const void*>(&_t4)), const_cast<void*>(reinterpret_cast<const void*>(&_t5)), const_cast<void*>(reinterpret_cast<const void*>(&_t6)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Tp::Client::ChannelTypeTubesInterface::TubeStateChanged(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Tp::Client::ChannelTypeTubesInterface::TubeClosed(uint _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void Tp::Client::ChannelTypeTubesInterface::DBusNamesChanged(uint _t1, const Tp::DBusTubeMemberList & _t2, const Tp::UIntList & _t3)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void Tp::Client::ChannelTypeTubesInterface::StreamTubeNewConnection(uint _t1, uint _t2)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}
QT_END_MOC_NAMESPACE
