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

#include "../../../../kmail-26.04.0/src/kmcommands.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN9KMCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMCommand::qt_create_metaobjectdata<qt_meta_tag_ZN9KMCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMCommand",
        "messagesTransfered",
        "",
        "KMCommand::Result",
        "result",
        "completed",
        "KMCommand*",
        "command",
        "start",
        "slotPostTransfer",
        "slotMsgTransfered",
        "Akonadi::Item::List",
        "msgs",
        "slotJobFinished",
        "slotTransferCancelled"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'messagesTransfered'
        QtMocHelpers::SignalData<void(KMCommand::Result)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'completed'
        QtMocHelpers::SignalData<void(KMCommand *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'start'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotPostTransfer'
        QtMocHelpers::SlotData<void(KMCommand::Result)>(9, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'slotMsgTransfered'
        QtMocHelpers::SlotData<void(const Akonadi::Item::List &)>(10, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Slot 'slotJobFinished'
        QtMocHelpers::SlotData<void()>(13, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotTransferCancelled'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMCommand, qt_meta_tag_ZN9KMCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9KMCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9KMCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9KMCommandE_t>.metaTypes,
    nullptr
} };

void KMCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->messagesTransfered((*reinterpret_cast<std::add_pointer_t<KMCommand::Result>>(_a[1]))); break;
        case 1: _t->completed((*reinterpret_cast<std::add_pointer_t<KMCommand*>>(_a[1]))); break;
        case 2: _t->start(); break;
        case 3: _t->slotPostTransfer((*reinterpret_cast<std::add_pointer_t<KMCommand::Result>>(_a[1]))); break;
        case 4: _t->slotMsgTransfered((*reinterpret_cast<std::add_pointer_t<Akonadi::Item::List>>(_a[1]))); break;
        case 5: _t->slotJobFinished(); break;
        case 6: _t->slotTransferCancelled(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KMCommand* >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Akonadi::Item::List >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (KMCommand::*)(KMCommand::Result )>(_a, &KMCommand::messagesTransfered, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (KMCommand::*)(KMCommand * )>(_a, &KMCommand::completed, 1))
            return;
    }
}

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

void *KMCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9KMCommandE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int KMCommand::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 < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
    return _id;
}

// SIGNAL 0
void KMCommand::messagesTransfered(KMCommand::Result _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void KMCommand::completed(KMCommand * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN22KMMailtoComposeCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMMailtoComposeCommand::qt_create_metaobjectdata<qt_meta_tag_ZN22KMMailtoComposeCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMMailtoComposeCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMMailtoComposeCommand, qt_meta_tag_ZN22KMMailtoComposeCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMMailtoComposeCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMMailtoComposeCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMMailtoComposeCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22KMMailtoComposeCommandE_t>.metaTypes,
    nullptr
} };

void KMMailtoComposeCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMMailtoComposeCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMMailtoComposeCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMMailtoComposeCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMMailtoComposeCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20KMMailtoReplyCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMMailtoReplyCommand::qt_create_metaobjectdata<qt_meta_tag_ZN20KMMailtoReplyCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMMailtoReplyCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMMailtoReplyCommand, qt_meta_tag_ZN20KMMailtoReplyCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMMailtoReplyCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMMailtoReplyCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMMailtoReplyCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20KMMailtoReplyCommandE_t>.metaTypes,
    nullptr
} };

void KMMailtoReplyCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMMailtoReplyCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMMailtoReplyCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMMailtoReplyCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMMailtoReplyCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN22KMMailtoForwardCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMMailtoForwardCommand::qt_create_metaobjectdata<qt_meta_tag_ZN22KMMailtoForwardCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMMailtoForwardCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMMailtoForwardCommand, qt_meta_tag_ZN22KMMailtoForwardCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMMailtoForwardCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMMailtoForwardCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMMailtoForwardCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22KMMailtoForwardCommandE_t>.metaTypes,
    nullptr
} };

void KMMailtoForwardCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMMailtoForwardCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMMailtoForwardCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMMailtoForwardCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMMailtoForwardCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN21KMAddBookmarksCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMAddBookmarksCommand::qt_create_metaobjectdata<qt_meta_tag_ZN21KMAddBookmarksCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMAddBookmarksCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMAddBookmarksCommand, qt_meta_tag_ZN21KMAddBookmarksCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMAddBookmarksCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMAddBookmarksCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMAddBookmarksCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21KMAddBookmarksCommandE_t>.metaTypes,
    nullptr
} };

void KMAddBookmarksCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMAddBookmarksCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMAddBookmarksCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMAddBookmarksCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMAddBookmarksCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16KMUrlSaveCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMUrlSaveCommand::qt_create_metaobjectdata<qt_meta_tag_ZN16KMUrlSaveCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMUrlSaveCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMUrlSaveCommand, qt_meta_tag_ZN16KMUrlSaveCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMUrlSaveCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMUrlSaveCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMUrlSaveCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16KMUrlSaveCommandE_t>.metaTypes,
    nullptr
} };

void KMUrlSaveCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMUrlSaveCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMUrlSaveCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMUrlSaveCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMUrlSaveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17KMEditItemCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMEditItemCommand::qt_create_metaobjectdata<qt_meta_tag_ZN17KMEditItemCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMEditItemCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMEditItemCommand, qt_meta_tag_ZN17KMEditItemCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMEditItemCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMEditItemCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMEditItemCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17KMEditItemCommandE_t>.metaTypes,
    nullptr
} };

void KMEditItemCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMEditItemCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMEditItemCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMEditItemCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMEditItemCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20KMEditMessageCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMEditMessageCommand::qt_create_metaobjectdata<qt_meta_tag_ZN20KMEditMessageCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMEditMessageCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMEditMessageCommand, qt_meta_tag_ZN20KMEditMessageCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMEditMessageCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMEditMessageCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMEditMessageCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20KMEditMessageCommandE_t>.metaTypes,
    nullptr
} };

void KMEditMessageCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMEditMessageCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMEditMessageCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMEditMessageCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMEditMessageCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20KMUseTemplateCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMUseTemplateCommand::qt_create_metaobjectdata<qt_meta_tag_ZN20KMUseTemplateCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMUseTemplateCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMUseTemplateCommand, qt_meta_tag_ZN20KMUseTemplateCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMUseTemplateCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMUseTemplateCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMUseTemplateCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20KMUseTemplateCommandE_t>.metaTypes,
    nullptr
} };

void KMUseTemplateCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMUseTemplateCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMUseTemplateCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20KMUseTemplateCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMUseTemplateCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16KMSaveMsgCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMSaveMsgCommand::qt_create_metaobjectdata<qt_meta_tag_ZN16KMSaveMsgCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMSaveMsgCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMSaveMsgCommand, qt_meta_tag_ZN16KMSaveMsgCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMSaveMsgCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMSaveMsgCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMSaveMsgCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16KMSaveMsgCommandE_t>.metaTypes,
    nullptr
} };

void KMSaveMsgCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMSaveMsgCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMSaveMsgCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMSaveMsgCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMSaveMsgCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16KMOpenMsgCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMOpenMsgCommand::qt_create_metaobjectdata<qt_meta_tag_ZN16KMOpenMsgCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMOpenMsgCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMOpenMsgCommand, qt_meta_tag_ZN16KMOpenMsgCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMOpenMsgCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMOpenMsgCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMOpenMsgCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16KMOpenMsgCommandE_t>.metaTypes,
    nullptr
} };

void KMOpenMsgCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMOpenMsgCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMOpenMsgCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMOpenMsgCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMOpenMsgCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN24KMSaveAttachmentsCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMSaveAttachmentsCommand::qt_create_metaobjectdata<qt_meta_tag_ZN24KMSaveAttachmentsCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMSaveAttachmentsCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMSaveAttachmentsCommand, qt_meta_tag_ZN24KMSaveAttachmentsCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMSaveAttachmentsCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24KMSaveAttachmentsCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24KMSaveAttachmentsCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24KMSaveAttachmentsCommandE_t>.metaTypes,
    nullptr
} };

void KMSaveAttachmentsCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMSaveAttachmentsCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMSaveAttachmentsCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24KMSaveAttachmentsCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMSaveAttachmentsCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN26KMDeleteAttachmentsCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMDeleteAttachmentsCommand::qt_create_metaobjectdata<qt_meta_tag_ZN26KMDeleteAttachmentsCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMDeleteAttachmentsCommand",
        "slotUpdateResult",
        "",
        "KJob*",
        "job",
        "slotCanceled"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'slotUpdateResult'
        QtMocHelpers::SlotData<void(KJob *)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'slotCanceled'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMDeleteAttachmentsCommand, qt_meta_tag_ZN26KMDeleteAttachmentsCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMDeleteAttachmentsCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26KMDeleteAttachmentsCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26KMDeleteAttachmentsCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26KMDeleteAttachmentsCommandE_t>.metaTypes,
    nullptr
} };

void KMDeleteAttachmentsCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMDeleteAttachmentsCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->slotUpdateResult((*reinterpret_cast<std::add_pointer_t<KJob*>>(_a[1]))); break;
        case 1: _t->slotCanceled(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KJob* >(); break;
            }
            break;
        }
    }
}

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

void *KMDeleteAttachmentsCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26KMDeleteAttachmentsCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMDeleteAttachmentsCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN14KMReplyCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMReplyCommand::qt_create_metaobjectdata<qt_meta_tag_ZN14KMReplyCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMReplyCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMReplyCommand, qt_meta_tag_ZN14KMReplyCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMReplyCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14KMReplyCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14KMReplyCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14KMReplyCommandE_t>.metaTypes,
    nullptr
} };

void KMReplyCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMReplyCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMReplyCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14KMReplyCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMReplyCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16KMForwardCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMForwardCommand::qt_create_metaobjectdata<qt_meta_tag_ZN16KMForwardCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMForwardCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMForwardCommand, qt_meta_tag_ZN16KMForwardCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMForwardCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMForwardCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMForwardCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16KMForwardCommandE_t>.metaTypes,
    nullptr
} };

void KMForwardCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMForwardCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMForwardCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16KMForwardCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMForwardCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN24KMForwardAttachedCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMForwardAttachedCommand::qt_create_metaobjectdata<qt_meta_tag_ZN24KMForwardAttachedCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMForwardAttachedCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMForwardAttachedCommand, qt_meta_tag_ZN24KMForwardAttachedCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMForwardAttachedCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24KMForwardAttachedCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24KMForwardAttachedCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24KMForwardAttachedCommandE_t>.metaTypes,
    nullptr
} };

void KMForwardAttachedCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMForwardAttachedCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMForwardAttachedCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24KMForwardAttachedCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMForwardAttachedCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17KMRedirectCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMRedirectCommand::qt_create_metaobjectdata<qt_meta_tag_ZN17KMRedirectCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMRedirectCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMRedirectCommand, qt_meta_tag_ZN17KMRedirectCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMRedirectCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMRedirectCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMRedirectCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17KMRedirectCommandE_t>.metaTypes,
    nullptr
} };

void KMRedirectCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMRedirectCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMRedirectCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMRedirectCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMRedirectCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN14KMPrintCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMPrintCommand::qt_create_metaobjectdata<qt_meta_tag_ZN14KMPrintCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMPrintCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMPrintCommand, qt_meta_tag_ZN14KMPrintCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMPrintCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14KMPrintCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14KMPrintCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14KMPrintCommandE_t>.metaTypes,
    nullptr
} };

void KMPrintCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMPrintCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMPrintCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14KMPrintCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMPrintCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18KMSetStatusCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMSetStatusCommand::qt_create_metaobjectdata<qt_meta_tag_ZN18KMSetStatusCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMSetStatusCommand",
        "slotModifyItemDone",
        "",
        "KJob*",
        "job"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'slotModifyItemDone'
        QtMocHelpers::SlotData<void(KJob *)>(1, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMSetStatusCommand, qt_meta_tag_ZN18KMSetStatusCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMSetStatusCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18KMSetStatusCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18KMSetStatusCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18KMSetStatusCommandE_t>.metaTypes,
    nullptr
} };

void KMSetStatusCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMSetStatusCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->slotModifyItemDone((*reinterpret_cast<std::add_pointer_t<KJob*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KJob* >(); break;
            }
            break;
        }
    }
}

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

void *KMSetStatusCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18KMSetStatusCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMSetStatusCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN15KMSetTagCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMSetTagCommand::qt_create_metaobjectdata<qt_meta_tag_ZN15KMSetTagCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMSetTagCommand",
        "slotModifyItemDone",
        "",
        "KJob*",
        "job"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'slotModifyItemDone'
        QtMocHelpers::SlotData<void(KJob *)>(1, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMSetTagCommand, qt_meta_tag_ZN15KMSetTagCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMSetTagCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15KMSetTagCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15KMSetTagCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15KMSetTagCommandE_t>.metaTypes,
    nullptr
} };

void KMSetTagCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMSetTagCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->slotModifyItemDone((*reinterpret_cast<std::add_pointer_t<KJob*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KJob* >(); break;
            }
            break;
        }
    }
}

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

void *KMSetTagCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15KMSetTagCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMSetTagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN21KMFilterActionCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMFilterActionCommand::qt_create_metaobjectdata<qt_meta_tag_ZN21KMFilterActionCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMFilterActionCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMFilterActionCommand, qt_meta_tag_ZN21KMFilterActionCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMFilterActionCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMFilterActionCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMFilterActionCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21KMFilterActionCommandE_t>.metaTypes,
    nullptr
} };

void KMFilterActionCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMFilterActionCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMFilterActionCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMFilterActionCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMFilterActionCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN25KMMetaFilterActionCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMMetaFilterActionCommand::qt_create_metaobjectdata<qt_meta_tag_ZN25KMMetaFilterActionCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMMetaFilterActionCommand",
        "start",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'start'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMMetaFilterActionCommand, qt_meta_tag_ZN25KMMetaFilterActionCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMMetaFilterActionCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25KMMetaFilterActionCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25KMMetaFilterActionCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25KMMetaFilterActionCommandE_t>.metaTypes,
    nullptr
} };

void KMMetaFilterActionCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMMetaFilterActionCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->start(); break;
        default: ;
        }
    }
    (void)_a;
}

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

void *KMMetaFilterActionCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25KMMetaFilterActionCommandE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int KMMetaFilterActionCommand::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 < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN26KMMailingListFilterCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMMailingListFilterCommand::qt_create_metaobjectdata<qt_meta_tag_ZN26KMMailingListFilterCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMMailingListFilterCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMMailingListFilterCommand, qt_meta_tag_ZN26KMMailingListFilterCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMMailingListFilterCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26KMMailingListFilterCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26KMMailingListFilterCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26KMMailingListFilterCommandE_t>.metaTypes,
    nullptr
} };

void KMMailingListFilterCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMMailingListFilterCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMMailingListFilterCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26KMMailingListFilterCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMMailingListFilterCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13KMCopyCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMCopyCommand::qt_create_metaobjectdata<qt_meta_tag_ZN13KMCopyCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMCopyCommand",
        "slotCopyResult",
        "",
        "KJob*",
        "job"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'slotCopyResult'
        QtMocHelpers::SlotData<void(KJob *)>(1, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMCopyCommand, qt_meta_tag_ZN13KMCopyCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMCopyCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13KMCopyCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13KMCopyCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13KMCopyCommandE_t>.metaTypes,
    nullptr
} };

void KMCopyCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMCopyCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->slotCopyResult((*reinterpret_cast<std::add_pointer_t<KJob*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KJob* >(); break;
            }
            break;
        }
    }
}

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

void *KMCopyCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13KMCopyCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMCopyCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN22KMCopyDecryptedCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMCopyDecryptedCommand::qt_create_metaobjectdata<qt_meta_tag_ZN22KMCopyDecryptedCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMCopyDecryptedCommand",
        "slotAppendResult",
        "",
        "KJob*",
        "job"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'slotAppendResult'
        QtMocHelpers::SlotData<void(KJob *)>(1, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMCopyDecryptedCommand, qt_meta_tag_ZN22KMCopyDecryptedCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMCopyDecryptedCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMCopyDecryptedCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMCopyDecryptedCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22KMCopyDecryptedCommandE_t>.metaTypes,
    nullptr
} };

void KMCopyDecryptedCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMCopyDecryptedCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->slotAppendResult((*reinterpret_cast<std::add_pointer_t<KJob*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KJob* >(); break;
            }
            break;
        }
    }
}

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

void *KMCopyDecryptedCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMCopyDecryptedCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMCopyDecryptedCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN13KMMoveCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMMoveCommand::qt_create_metaobjectdata<qt_meta_tag_ZN13KMMoveCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMMoveCommand",
        "moveDone",
        "",
        "KMMoveCommand*",
        "slotMoveCanceled",
        "slotMoveResult",
        "KJob*",
        "job"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'moveDone'
        QtMocHelpers::SignalData<void(KMMoveCommand *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Slot 'slotMoveCanceled'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotMoveResult'
        QtMocHelpers::SlotData<void(KJob *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMMoveCommand, qt_meta_tag_ZN13KMMoveCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMMoveCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13KMMoveCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13KMMoveCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13KMMoveCommandE_t>.metaTypes,
    nullptr
} };

void KMMoveCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMMoveCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->moveDone((*reinterpret_cast<std::add_pointer_t<KMMoveCommand*>>(_a[1]))); break;
        case 1: _t->slotMoveCanceled(); break;
        case 2: _t->slotMoveResult((*reinterpret_cast<std::add_pointer_t<KJob*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KMMoveCommand* >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KJob* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (KMMoveCommand::*)(KMMoveCommand * )>(_a, &KMMoveCommand::moveDone, 0))
            return;
    }
}

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

void *KMMoveCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13KMMoveCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMMoveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void KMMoveCommand::moveDone(KMMoveCommand * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN17KMTrashMsgCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMTrashMsgCommand::qt_create_metaobjectdata<qt_meta_tag_ZN17KMTrashMsgCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMTrashMsgCommand",
        "moveDone",
        "",
        "KMTrashMsgCommand*",
        "slotMoveCanceled"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'moveDone'
        QtMocHelpers::SignalData<void(KMTrashMsgCommand *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Slot 'slotMoveCanceled'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMTrashMsgCommand, qt_meta_tag_ZN17KMTrashMsgCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMTrashMsgCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMTrashMsgCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMTrashMsgCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17KMTrashMsgCommandE_t>.metaTypes,
    nullptr
} };

void KMTrashMsgCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMTrashMsgCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->moveDone((*reinterpret_cast<std::add_pointer_t<KMTrashMsgCommand*>>(_a[1]))); break;
        case 1: _t->slotMoveCanceled(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< KMTrashMsgCommand* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (KMTrashMsgCommand::*)(KMTrashMsgCommand * )>(_a, &KMTrashMsgCommand::moveDone, 0))
            return;
    }
}

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

void *KMTrashMsgCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17KMTrashMsgCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMTrashMsgCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void KMTrashMsgCommand::moveDone(KMTrashMsgCommand * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN22KMResendMessageCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMResendMessageCommand::qt_create_metaobjectdata<qt_meta_tag_ZN22KMResendMessageCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMResendMessageCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMResendMessageCommand, qt_meta_tag_ZN22KMResendMessageCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMResendMessageCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMResendMessageCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMResendMessageCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22KMResendMessageCommandE_t>.metaTypes,
    nullptr
} };

void KMResendMessageCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMResendMessageCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMResendMessageCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22KMResendMessageCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMResendMessageCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19KMShareImageCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMShareImageCommand::qt_create_metaobjectdata<qt_meta_tag_ZN19KMShareImageCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMShareImageCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMShareImageCommand, qt_meta_tag_ZN19KMShareImageCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMShareImageCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19KMShareImageCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19KMShareImageCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19KMShareImageCommandE_t>.metaTypes,
    nullptr
} };

void KMShareImageCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMShareImageCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMShareImageCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19KMShareImageCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMShareImageCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN21KMFetchMessageCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto KMFetchMessageCommand::qt_create_metaobjectdata<qt_meta_tag_ZN21KMFetchMessageCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KMFetchMessageCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KMFetchMessageCommand, qt_meta_tag_ZN21KMFetchMessageCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject KMFetchMessageCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<KMCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMFetchMessageCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMFetchMessageCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21KMFetchMessageCommandE_t>.metaTypes,
    nullptr
} };

void KMFetchMessageCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KMFetchMessageCommand *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *KMFetchMessageCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21KMFetchMessageCommandE_t>.strings))
        return static_cast<void*>(this);
    return KMCommand::qt_metacast(_clname);
}

int KMFetchMessageCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KMCommand::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
