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

#include "../../src/ksirk-17.12.3/ksirk/Jabber/privacymanager.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'privacymanager.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.9.4. 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
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_XMPP__PrivacyListListener_t {
    QByteArrayData data[1];
    char stringdata0[26];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_XMPP__PrivacyListListener_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_XMPP__PrivacyListListener_t qt_meta_stringdata_XMPP__PrivacyListListener = {
    {
QT_MOC_LITERAL(0, 0, 25) // "XMPP::PrivacyListListener"

    },
    "XMPP::PrivacyListListener"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_XMPP__PrivacyListListener[] = {

 // 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 XMPP::PrivacyListListener::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 XMPP::PrivacyListListener::staticMetaObject = {
    { &Task::staticMetaObject, qt_meta_stringdata_XMPP__PrivacyListListener.data,
      qt_meta_data_XMPP__PrivacyListListener,  qt_static_metacall, nullptr, nullptr}
};


const QMetaObject *XMPP::PrivacyListListener::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *XMPP::PrivacyListListener::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_XMPP__PrivacyListListener.stringdata0))
        return static_cast<void*>(this);
    return Task::qt_metacast(_clname);
}

int XMPP::PrivacyListListener::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Task::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_XMPP__GetPrivacyListsTask_t {
    QByteArrayData data[1];
    char stringdata0[26];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_XMPP__GetPrivacyListsTask_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_XMPP__GetPrivacyListsTask_t qt_meta_stringdata_XMPP__GetPrivacyListsTask = {
    {
QT_MOC_LITERAL(0, 0, 25) // "XMPP::GetPrivacyListsTask"

    },
    "XMPP::GetPrivacyListsTask"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_XMPP__GetPrivacyListsTask[] = {

 // 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 XMPP::GetPrivacyListsTask::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 XMPP::GetPrivacyListsTask::staticMetaObject = {
    { &Task::staticMetaObject, qt_meta_stringdata_XMPP__GetPrivacyListsTask.data,
      qt_meta_data_XMPP__GetPrivacyListsTask,  qt_static_metacall, nullptr, nullptr}
};


const QMetaObject *XMPP::GetPrivacyListsTask::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *XMPP::GetPrivacyListsTask::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_XMPP__GetPrivacyListsTask.stringdata0))
        return static_cast<void*>(this);
    return Task::qt_metacast(_clname);
}

int XMPP::GetPrivacyListsTask::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Task::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_XMPP__SetPrivacyListsTask_t {
    QByteArrayData data[1];
    char stringdata0[26];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_XMPP__SetPrivacyListsTask_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_XMPP__SetPrivacyListsTask_t qt_meta_stringdata_XMPP__SetPrivacyListsTask = {
    {
QT_MOC_LITERAL(0, 0, 25) // "XMPP::SetPrivacyListsTask"

    },
    "XMPP::SetPrivacyListsTask"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_XMPP__SetPrivacyListsTask[] = {

 // 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 XMPP::SetPrivacyListsTask::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 XMPP::SetPrivacyListsTask::staticMetaObject = {
    { &Task::staticMetaObject, qt_meta_stringdata_XMPP__SetPrivacyListsTask.data,
      qt_meta_data_XMPP__SetPrivacyListsTask,  qt_static_metacall, nullptr, nullptr}
};


const QMetaObject *XMPP::SetPrivacyListsTask::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *XMPP::SetPrivacyListsTask::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_XMPP__SetPrivacyListsTask.stringdata0))
        return static_cast<void*>(this);
    return Task::qt_metacast(_clname);
}

int XMPP::SetPrivacyListsTask::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Task::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_XMPP__GetPrivacyListTask_t {
    QByteArrayData data[1];
    char stringdata0[25];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_XMPP__GetPrivacyListTask_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_XMPP__GetPrivacyListTask_t qt_meta_stringdata_XMPP__GetPrivacyListTask = {
    {
QT_MOC_LITERAL(0, 0, 24) // "XMPP::GetPrivacyListTask"

    },
    "XMPP::GetPrivacyListTask"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_XMPP__GetPrivacyListTask[] = {

 // 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 XMPP::GetPrivacyListTask::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 XMPP::GetPrivacyListTask::staticMetaObject = {
    { &Task::staticMetaObject, qt_meta_stringdata_XMPP__GetPrivacyListTask.data,
      qt_meta_data_XMPP__GetPrivacyListTask,  qt_static_metacall, nullptr, nullptr}
};


const QMetaObject *XMPP::GetPrivacyListTask::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *XMPP::GetPrivacyListTask::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_XMPP__GetPrivacyListTask.stringdata0))
        return static_cast<void*>(this);
    return Task::qt_metacast(_clname);
}

int XMPP::GetPrivacyListTask::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Task::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_XMPP__PrivacyManager_t {
    QByteArrayData data[32];
    char stringdata0[565];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_XMPP__PrivacyManager_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_XMPP__PrivacyManager_t qt_meta_stringdata_XMPP__PrivacyManager = {
    {
QT_MOC_LITERAL(0, 0, 20), // "XMPP::PrivacyManager"
QT_MOC_LITERAL(1, 21, 25), // "changeDefaultList_success"
QT_MOC_LITERAL(2, 47, 0), // ""
QT_MOC_LITERAL(3, 48, 23), // "changeDefaultList_error"
QT_MOC_LITERAL(4, 72, 24), // "changeActiveList_success"
QT_MOC_LITERAL(5, 97, 22), // "changeActiveList_error"
QT_MOC_LITERAL(6, 120, 18), // "changeList_success"
QT_MOC_LITERAL(7, 139, 16), // "changeList_error"
QT_MOC_LITERAL(8, 156, 20), // "defaultListAvailable"
QT_MOC_LITERAL(9, 177, 11), // "PrivacyList"
QT_MOC_LITERAL(10, 189, 16), // "defaultListError"
QT_MOC_LITERAL(11, 206, 17), // "listChangeSuccess"
QT_MOC_LITERAL(12, 224, 15), // "listChangeError"
QT_MOC_LITERAL(13, 240, 12), // "listReceived"
QT_MOC_LITERAL(14, 253, 1), // "p"
QT_MOC_LITERAL(15, 255, 9), // "listError"
QT_MOC_LITERAL(16, 265, 13), // "listsReceived"
QT_MOC_LITERAL(17, 279, 11), // "defaultList"
QT_MOC_LITERAL(18, 291, 10), // "activeList"
QT_MOC_LITERAL(19, 302, 5), // "lists"
QT_MOC_LITERAL(20, 308, 10), // "listsError"
QT_MOC_LITERAL(21, 319, 12), // "receiveLists"
QT_MOC_LITERAL(22, 332, 11), // "receiveList"
QT_MOC_LITERAL(23, 344, 26), // "changeDefaultList_finished"
QT_MOC_LITERAL(24, 371, 25), // "changeActiveList_finished"
QT_MOC_LITERAL(25, 397, 19), // "changeList_finished"
QT_MOC_LITERAL(26, 417, 24), // "getDefault_listsReceived"
QT_MOC_LITERAL(27, 442, 21), // "getDefault_listsError"
QT_MOC_LITERAL(28, 464, 23), // "getDefault_listReceived"
QT_MOC_LITERAL(29, 488, 20), // "getDefault_listError"
QT_MOC_LITERAL(30, 509, 28), // "block_getDefaultList_success"
QT_MOC_LITERAL(31, 538, 26) // "block_getDefaultList_error"

    },
    "XMPP::PrivacyManager\0changeDefaultList_success\0"
    "\0changeDefaultList_error\0"
    "changeActiveList_success\0"
    "changeActiveList_error\0changeList_success\0"
    "changeList_error\0defaultListAvailable\0"
    "PrivacyList\0defaultListError\0"
    "listChangeSuccess\0listChangeError\0"
    "listReceived\0p\0listError\0listsReceived\0"
    "defaultList\0activeList\0lists\0listsError\0"
    "receiveLists\0receiveList\0"
    "changeDefaultList_finished\0"
    "changeActiveList_finished\0changeList_finished\0"
    "getDefault_listsReceived\0getDefault_listsError\0"
    "getDefault_listReceived\0getDefault_listError\0"
    "block_getDefaultList_success\0"
    "block_getDefaultList_error"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_XMPP__PrivacyManager[] = {

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

 // signals: name, argc, parameters, tag, flags
       1,    0,  139,    2, 0x06 /* Public */,
       3,    0,  140,    2, 0x06 /* Public */,
       4,    0,  141,    2, 0x06 /* Public */,
       5,    0,  142,    2, 0x06 /* Public */,
       6,    0,  143,    2, 0x06 /* Public */,
       7,    0,  144,    2, 0x06 /* Public */,
       8,    1,  145,    2, 0x06 /* Public */,
      10,    0,  148,    2, 0x06 /* Public */,
      11,    0,  149,    2, 0x06 /* Public */,
      12,    0,  150,    2, 0x06 /* Public */,
      13,    1,  151,    2, 0x06 /* Public */,
      15,    0,  154,    2, 0x06 /* Public */,
      16,    3,  155,    2, 0x06 /* Public */,
      20,    0,  162,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      21,    0,  163,    2, 0x08 /* Private */,
      22,    0,  164,    2, 0x08 /* Private */,
      23,    0,  165,    2, 0x08 /* Private */,
      24,    0,  166,    2, 0x08 /* Private */,
      25,    0,  167,    2, 0x08 /* Private */,
      26,    3,  168,    2, 0x08 /* Private */,
      27,    0,  175,    2, 0x08 /* Private */,
      28,    1,  176,    2, 0x08 /* Private */,
      29,    0,  179,    2, 0x08 /* Private */,
      30,    1,  180,    2, 0x08 /* Private */,
      31,    0,  183,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 9,    2,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 9,   14,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::QStringList,   17,   18,   19,
    QMetaType::Void,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, QMetaType::QString, QMetaType::QStringList,    2,    2,    2,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 9,    2,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 9,    2,
    QMetaType::Void,

       0        // eod
};

void XMPP::PrivacyManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrivacyManager *_t = static_cast<PrivacyManager *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->changeDefaultList_success(); break;
        case 1: _t->changeDefaultList_error(); break;
        case 2: _t->changeActiveList_success(); break;
        case 3: _t->changeActiveList_error(); break;
        case 4: _t->changeList_success(); break;
        case 5: _t->changeList_error(); break;
        case 6: _t->defaultListAvailable((*reinterpret_cast< const PrivacyList(*)>(_a[1]))); break;
        case 7: _t->defaultListError(); break;
        case 8: _t->listChangeSuccess(); break;
        case 9: _t->listChangeError(); break;
        case 10: _t->listReceived((*reinterpret_cast< const PrivacyList(*)>(_a[1]))); break;
        case 11: _t->listError(); break;
        case 12: _t->listsReceived((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QStringList(*)>(_a[3]))); break;
        case 13: _t->listsError(); break;
        case 14: _t->receiveLists(); break;
        case 15: _t->receiveList(); break;
        case 16: _t->changeDefaultList_finished(); break;
        case 17: _t->changeActiveList_finished(); break;
        case 18: _t->changeList_finished(); break;
        case 19: _t->getDefault_listsReceived((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QStringList(*)>(_a[3]))); break;
        case 20: _t->getDefault_listsError(); break;
        case 21: _t->getDefault_listReceived((*reinterpret_cast< const PrivacyList(*)>(_a[1]))); break;
        case 22: _t->getDefault_listError(); break;
        case 23: _t->block_getDefaultList_success((*reinterpret_cast< const PrivacyList(*)>(_a[1]))); break;
        case 24: _t->block_getDefaultList_error(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::changeDefaultList_success)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::changeDefaultList_error)) {
                *result = 1;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::changeActiveList_success)) {
                *result = 2;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::changeActiveList_error)) {
                *result = 3;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::changeList_success)) {
                *result = 4;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::changeList_error)) {
                *result = 5;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)(const PrivacyList & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::defaultListAvailable)) {
                *result = 6;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::defaultListError)) {
                *result = 7;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::listChangeSuccess)) {
                *result = 8;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::listChangeError)) {
                *result = 9;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)(const PrivacyList & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::listReceived)) {
                *result = 10;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::listError)) {
                *result = 11;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)(const QString & , const QString & , const QStringList & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::listsReceived)) {
                *result = 12;
                return;
            }
        }
        {
            typedef void (PrivacyManager::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrivacyManager::listsError)) {
                *result = 13;
                return;
            }
        }
    }
}

const QMetaObject XMPP::PrivacyManager::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_XMPP__PrivacyManager.data,
      qt_meta_data_XMPP__PrivacyManager,  qt_static_metacall, nullptr, nullptr}
};


const QMetaObject *XMPP::PrivacyManager::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *XMPP::PrivacyManager::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_XMPP__PrivacyManager.stringdata0))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

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

// SIGNAL 0
void XMPP::PrivacyManager::changeDefaultList_success()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void XMPP::PrivacyManager::changeDefaultList_error()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void XMPP::PrivacyManager::changeActiveList_success()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void XMPP::PrivacyManager::changeActiveList_error()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void XMPP::PrivacyManager::changeList_success()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void XMPP::PrivacyManager::changeList_error()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void XMPP::PrivacyManager::defaultListAvailable(const PrivacyList & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
}

// SIGNAL 7
void XMPP::PrivacyManager::defaultListError()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void XMPP::PrivacyManager::listChangeSuccess()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void XMPP::PrivacyManager::listChangeError()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void XMPP::PrivacyManager::listReceived(const PrivacyList & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 10, _a);
}

// SIGNAL 11
void XMPP::PrivacyManager::listError()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void XMPP::PrivacyManager::listsReceived(const QString & _t1, const QString & _t2, const QStringList & _t3)
{
    void *_a[] = { 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, 12, _a);
}

// SIGNAL 13
void XMPP::PrivacyManager::listsError()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
