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

#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'base-channel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 63
#error "This file was generated using the moc from 4.8.7. 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
static const uint qt_meta_data_Tp__BaseChannel[] = {

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

 // signals: signature, parameters, type, tag, flags
      17,   16,   16,   16, 0x05,

       0        // eod
};

static const char qt_meta_stringdata_Tp__BaseChannel[] = {
    "Tp::BaseChannel\0\0closed()\0"
};

void Tp::BaseChannel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        BaseChannel *_t = static_cast<BaseChannel *>(_o);
        switch (_id) {
        case 0: _t->closed(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObjectExtraData Tp::BaseChannel::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannel::staticMetaObject = {
    { &DBusService::staticMetaObject, qt_meta_stringdata_Tp__BaseChannel,
      qt_meta_data_Tp__BaseChannel, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannel::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannel::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannel))
        return static_cast<void*>(const_cast< BaseChannel*>(this));
    return DBusService::qt_metacast(_clname);
}

int Tp::BaseChannel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DBusService::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;
    }
    return _id;
}

// SIGNAL 0
void Tp::BaseChannel::closed()
{
    QMetaObject::activate(this, &staticMetaObject, 0, 0);
}
static const uint qt_meta_data_Tp__AbstractChannelInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__AbstractChannelInterface[] = {
    "Tp::AbstractChannelInterface\0"
};

void Tp::AbstractChannelInterface::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 QMetaObjectExtraData Tp::AbstractChannelInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::AbstractChannelInterface::staticMetaObject = {
    { &AbstractDBusServiceInterface::staticMetaObject, qt_meta_stringdata_Tp__AbstractChannelInterface,
      qt_meta_data_Tp__AbstractChannelInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::AbstractChannelInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::AbstractChannelInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__AbstractChannelInterface))
        return static_cast<void*>(const_cast< AbstractChannelInterface*>(this));
    return AbstractDBusServiceInterface::qt_metacast(_clname);
}

int Tp::AbstractChannelInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractDBusServiceInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelTextType[] = {

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

 // slots: signature, parameters, type, tag, flags
      45,   25,   24,   24, 0x08,

       0        // eod
};

static const char qt_meta_stringdata_Tp__BaseChannelTextType[] = {
    "Tp::BaseChannelTextType\0\0timestamp,type,text\0"
    "sent(uint,uint,QString)\0"
};

void Tp::BaseChannelTextType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        BaseChannelTextType *_t = static_cast<BaseChannelTextType *>(_o);
        switch (_id) {
        case 0: _t->sent((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2])),(*reinterpret_cast< QString(*)>(_a[3]))); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData Tp::BaseChannelTextType::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelTextType::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelTextType,
      qt_meta_data_Tp__BaseChannelTextType, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelTextType::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelTextType::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelTextType))
        return static_cast<void*>(const_cast< BaseChannelTextType*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelTextType::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::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;
    }
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelMessagesInterface[] = {

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

 // slots: signature, parameters, type, tag, flags
      45,   34,   33,   33, 0x08,
      90,   82,   33,   33, 0x08,

       0        // eod
};

static const char qt_meta_stringdata_Tp__BaseChannelMessagesInterface[] = {
    "Tp::BaseChannelMessagesInterface\0\0"
    "messageIDs\0pendingMessagesRemoved(Tp::UIntList)\0"
    "message\0messageReceived(Tp::MessagePartList)\0"
};

void Tp::BaseChannelMessagesInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        BaseChannelMessagesInterface *_t = static_cast<BaseChannelMessagesInterface *>(_o);
        switch (_id) {
        case 0: _t->pendingMessagesRemoved((*reinterpret_cast< const Tp::UIntList(*)>(_a[1]))); break;
        case 1: _t->messageReceived((*reinterpret_cast< const Tp::MessagePartList(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData Tp::BaseChannelMessagesInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelMessagesInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelMessagesInterface,
      qt_meta_data_Tp__BaseChannelMessagesInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelMessagesInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelMessagesInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelMessagesInterface))
        return static_cast<void*>(const_cast< BaseChannelMessagesInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelMessagesInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::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;
    }
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelRoomListType[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelRoomListType[] = {
    "Tp::BaseChannelRoomListType\0"
};

void Tp::BaseChannelRoomListType::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 QMetaObjectExtraData Tp::BaseChannelRoomListType::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelRoomListType::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelRoomListType,
      qt_meta_data_Tp__BaseChannelRoomListType, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelRoomListType::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelRoomListType::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelRoomListType))
        return static_cast<void*>(const_cast< BaseChannelRoomListType*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelRoomListType::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelServerAuthenticationType[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelServerAuthenticationType[] = {
    "Tp::BaseChannelServerAuthenticationType\0"
};

void Tp::BaseChannelServerAuthenticationType::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 QMetaObjectExtraData Tp::BaseChannelServerAuthenticationType::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelServerAuthenticationType::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelServerAuthenticationType,
      qt_meta_data_Tp__BaseChannelServerAuthenticationType, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelServerAuthenticationType::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelServerAuthenticationType::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelServerAuthenticationType))
        return static_cast<void*>(const_cast< BaseChannelServerAuthenticationType*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelServerAuthenticationType::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelCaptchaAuthenticationInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelCaptchaAuthenticationInterface[] = {
    "Tp::BaseChannelCaptchaAuthenticationInterface\0"
};

void Tp::BaseChannelCaptchaAuthenticationInterface::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 QMetaObjectExtraData Tp::BaseChannelCaptchaAuthenticationInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelCaptchaAuthenticationInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelCaptchaAuthenticationInterface,
      qt_meta_data_Tp__BaseChannelCaptchaAuthenticationInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelCaptchaAuthenticationInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelCaptchaAuthenticationInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelCaptchaAuthenticationInterface))
        return static_cast<void*>(const_cast< BaseChannelCaptchaAuthenticationInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelCaptchaAuthenticationInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelSASLAuthenticationInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelSASLAuthenticationInterface[] = {
    "Tp::BaseChannelSASLAuthenticationInterface\0"
};

void Tp::BaseChannelSASLAuthenticationInterface::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 QMetaObjectExtraData Tp::BaseChannelSASLAuthenticationInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelSASLAuthenticationInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelSASLAuthenticationInterface,
      qt_meta_data_Tp__BaseChannelSASLAuthenticationInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelSASLAuthenticationInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelSASLAuthenticationInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelSASLAuthenticationInterface))
        return static_cast<void*>(const_cast< BaseChannelSASLAuthenticationInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelSASLAuthenticationInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelSecurableInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelSecurableInterface[] = {
    "Tp::BaseChannelSecurableInterface\0"
};

void Tp::BaseChannelSecurableInterface::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 QMetaObjectExtraData Tp::BaseChannelSecurableInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelSecurableInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelSecurableInterface,
      qt_meta_data_Tp__BaseChannelSecurableInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelSecurableInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelSecurableInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelSecurableInterface))
        return static_cast<void*>(const_cast< BaseChannelSecurableInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelSecurableInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelChatStateInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelChatStateInterface[] = {
    "Tp::BaseChannelChatStateInterface\0"
};

void Tp::BaseChannelChatStateInterface::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 QMetaObjectExtraData Tp::BaseChannelChatStateInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelChatStateInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelChatStateInterface,
      qt_meta_data_Tp__BaseChannelChatStateInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelChatStateInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelChatStateInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelChatStateInterface))
        return static_cast<void*>(const_cast< BaseChannelChatStateInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelChatStateInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelGroupInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelGroupInterface[] = {
    "Tp::BaseChannelGroupInterface\0"
};

void Tp::BaseChannelGroupInterface::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 QMetaObjectExtraData Tp::BaseChannelGroupInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelGroupInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelGroupInterface,
      qt_meta_data_Tp__BaseChannelGroupInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelGroupInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelGroupInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelGroupInterface))
        return static_cast<void*>(const_cast< BaseChannelGroupInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelGroupInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelRoomInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelRoomInterface[] = {
    "Tp::BaseChannelRoomInterface\0"
};

void Tp::BaseChannelRoomInterface::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 QMetaObjectExtraData Tp::BaseChannelRoomInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelRoomInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelRoomInterface,
      qt_meta_data_Tp__BaseChannelRoomInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelRoomInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelRoomInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelRoomInterface))
        return static_cast<void*>(const_cast< BaseChannelRoomInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelRoomInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelRoomConfigInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelRoomConfigInterface[] = {
    "Tp::BaseChannelRoomConfigInterface\0"
};

void Tp::BaseChannelRoomConfigInterface::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 QMetaObjectExtraData Tp::BaseChannelRoomConfigInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelRoomConfigInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelRoomConfigInterface,
      qt_meta_data_Tp__BaseChannelRoomConfigInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelRoomConfigInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelRoomConfigInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelRoomConfigInterface))
        return static_cast<void*>(const_cast< BaseChannelRoomConfigInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelRoomConfigInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelCallType[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelCallType[] = {
    "Tp::BaseChannelCallType\0"
};

void Tp::BaseChannelCallType::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 QMetaObjectExtraData Tp::BaseChannelCallType::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelCallType::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelCallType,
      qt_meta_data_Tp__BaseChannelCallType, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelCallType::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelCallType::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelCallType))
        return static_cast<void*>(const_cast< BaseChannelCallType*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelCallType::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelHoldInterface[] = {

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

 // signals: signature, parameters, type, tag, flags
      43,   30,   29,   29, 0x05,

       0        // eod
};

static const char qt_meta_stringdata_Tp__BaseChannelHoldInterface[] = {
    "Tp::BaseChannelHoldInterface\0\0"
    "state,reason\0"
    "holdStateChanged(Tp::LocalHoldState,Tp::LocalHoldStateReason)\0"
};

void Tp::BaseChannelHoldInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        BaseChannelHoldInterface *_t = static_cast<BaseChannelHoldInterface *>(_o);
        switch (_id) {
        case 0: _t->holdStateChanged((*reinterpret_cast< const Tp::LocalHoldState(*)>(_a[1])),(*reinterpret_cast< const Tp::LocalHoldStateReason(*)>(_a[2]))); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData Tp::BaseChannelHoldInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelHoldInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelHoldInterface,
      qt_meta_data_Tp__BaseChannelHoldInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelHoldInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelHoldInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelHoldInterface))
        return static_cast<void*>(const_cast< BaseChannelHoldInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelHoldInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::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;
    }
    return _id;
}

// SIGNAL 0
void Tp::BaseChannelHoldInterface::holdStateChanged(const Tp::LocalHoldState & _t1, const Tp::LocalHoldStateReason & _t2)
{
    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
static const uint qt_meta_data_Tp__BaseChannelMergeableConferenceInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelMergeableConferenceInterface[] = {
    "Tp::BaseChannelMergeableConferenceInterface\0"
};

void Tp::BaseChannelMergeableConferenceInterface::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 QMetaObjectExtraData Tp::BaseChannelMergeableConferenceInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelMergeableConferenceInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelMergeableConferenceInterface,
      qt_meta_data_Tp__BaseChannelMergeableConferenceInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelMergeableConferenceInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelMergeableConferenceInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelMergeableConferenceInterface))
        return static_cast<void*>(const_cast< BaseChannelMergeableConferenceInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelMergeableConferenceInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelSplittableInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelSplittableInterface[] = {
    "Tp::BaseChannelSplittableInterface\0"
};

void Tp::BaseChannelSplittableInterface::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 QMetaObjectExtraData Tp::BaseChannelSplittableInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelSplittableInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelSplittableInterface,
      qt_meta_data_Tp__BaseChannelSplittableInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelSplittableInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelSplittableInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelSplittableInterface))
        return static_cast<void*>(const_cast< BaseChannelSplittableInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelSplittableInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelConferenceInterface[] = {

 // content:
       6,       // 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
};

static const char qt_meta_stringdata_Tp__BaseChannelConferenceInterface[] = {
    "Tp::BaseChannelConferenceInterface\0"
};

void Tp::BaseChannelConferenceInterface::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 QMetaObjectExtraData Tp::BaseChannelConferenceInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelConferenceInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelConferenceInterface,
      qt_meta_data_Tp__BaseChannelConferenceInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelConferenceInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelConferenceInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelConferenceInterface))
        return static_cast<void*>(const_cast< BaseChannelConferenceInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelConferenceInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
static const uint qt_meta_data_Tp__BaseChannelSMSInterface[] = {

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

 // signals: signature, parameters, type, tag, flags
      40,   29,   28,   28, 0x05,

       0        // eod
};

static const char qt_meta_stringdata_Tp__BaseChannelSMSInterface[] = {
    "Tp::BaseChannelSMSInterface\0\0smsChannel\0"
    "smsChannelChanged(bool)\0"
};

void Tp::BaseChannelSMSInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        BaseChannelSMSInterface *_t = static_cast<BaseChannelSMSInterface *>(_o);
        switch (_id) {
        case 0: _t->smsChannelChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObjectExtraData Tp::BaseChannelSMSInterface::staticMetaObjectExtraData = {
    0,  qt_static_metacall 
};

const QMetaObject Tp::BaseChannelSMSInterface::staticMetaObject = {
    { &AbstractChannelInterface::staticMetaObject, qt_meta_stringdata_Tp__BaseChannelSMSInterface,
      qt_meta_data_Tp__BaseChannelSMSInterface, &staticMetaObjectExtraData }
};

#ifdef Q_NO_DATA_RELOCATION
const QMetaObject &Tp::BaseChannelSMSInterface::getStaticMetaObject() { return staticMetaObject; }
#endif //Q_NO_DATA_RELOCATION

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

void *Tp::BaseChannelSMSInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return 0;
    if (!strcmp(_clname, qt_meta_stringdata_Tp__BaseChannelSMSInterface))
        return static_cast<void*>(const_cast< BaseChannelSMSInterface*>(this));
    return AbstractChannelInterface::qt_metacast(_clname);
}

int Tp::BaseChannelSMSInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AbstractChannelInterface::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;
    }
    return _id;
}

// SIGNAL 0
void Tp::BaseChannelSMSInterface::smsChannelChanged(bool _t1)
{
    void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
QT_END_MOC_NAMESPACE
