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

#include "../../../../kid3-3.10.1/src/app/cli/clicommand.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 'clicommand.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. 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_ZN10CliCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto CliCommand::qt_create_metaobjectdata<qt_meta_tag_ZN10CliCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CliCommand",
        "finished",
        "",
        "terminate"
    };

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

void CliCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CliCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->finished(); break;
        case 1: _t->terminate(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CliCommand::*)()>(_a, &CliCommand::finished, 0))
            return;
    }
}

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

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

int CliCommand::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 < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void CliCommand::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN11HelpCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int HelpCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN14TimeoutCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int TimeoutCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11QuitCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int QuitCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN9CdCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int CdCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN10PwdCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int PwdCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN9LsCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int LsCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11SaveCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int SaveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13SelectCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int SelectCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN10TagCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int TagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN10GetCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int GetCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN10SetCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int SetCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13RevertCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int RevertCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13ImportCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int ImportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18BatchImportCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto BatchImportCommand::qt_create_metaobjectdata<qt_meta_tag_ZN18BatchImportCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "BatchImportCommand",
        "onReportImportEvent",
        "",
        "type",
        "text"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onReportImportEvent'
        QtMocHelpers::SlotData<void(int, const QString &)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<BatchImportCommand, qt_meta_tag_ZN18BatchImportCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject BatchImportCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<CliCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18BatchImportCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18BatchImportCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18BatchImportCommandE_t>.metaTypes,
    nullptr
} };

void BatchImportCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<BatchImportCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onReportImportEvent((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        default: ;
        }
    }
}

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

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

int BatchImportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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_ZN15AlbumArtCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto AlbumArtCommand::qt_create_metaobjectdata<qt_meta_tag_ZN15AlbumArtCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AlbumArtCommand",
        "onDownloadFinished",
        "",
        "data",
        "mimeType",
        "url"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onDownloadFinished'
        QtMocHelpers::SlotData<void(const QByteArray &, const QString &, const QString &)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QByteArray, 3 }, { QMetaType::QString, 4 }, { QMetaType::QString, 5 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<AlbumArtCommand, qt_meta_tag_ZN15AlbumArtCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject AlbumArtCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<CliCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15AlbumArtCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15AlbumArtCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15AlbumArtCommandE_t>.metaTypes,
    nullptr
} };

void AlbumArtCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<AlbumArtCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onDownloadFinished((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        default: ;
        }
    }
}

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

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

int AlbumArtCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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_ZN13ExportCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int ExportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN15PlaylistCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int PlaylistCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN21FilenameFormatCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int FilenameFormatCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16TagFormatCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int TagFormatCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19TextEncodingCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int TextEncodingCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN22RenameDirectoryCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto RenameDirectoryCommand::qt_create_metaobjectdata<qt_meta_tag_ZN22RenameDirectoryCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RenameDirectoryCommand",
        "onActionScheduled",
        "",
        "actionStrs",
        "onRenameActionsScheduled"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onActionScheduled'
        QtMocHelpers::SlotData<void(const QStringList &)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QStringList, 3 },
        }}),
        // Slot 'onRenameActionsScheduled'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RenameDirectoryCommand, qt_meta_tag_ZN22RenameDirectoryCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject RenameDirectoryCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<CliCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22RenameDirectoryCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22RenameDirectoryCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22RenameDirectoryCommandE_t>.metaTypes,
    nullptr
} };

void RenameDirectoryCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<RenameDirectoryCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onActionScheduled((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 1: _t->onRenameActionsScheduled(); break;
        default: ;
        }
    }
}

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

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

int RenameDirectoryCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN19NumberTracksCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int NumberTracksCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13FilterCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto FilterCommand::qt_create_metaobjectdata<qt_meta_tag_ZN13FilterCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "FilterCommand",
        "onFileFiltered",
        "",
        "type",
        "fileName"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onFileFiltered'
        QtMocHelpers::SlotData<void(int, const QString &)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<FilterCommand, qt_meta_tag_ZN13FilterCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject FilterCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<CliCommand::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13FilterCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13FilterCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13FilterCommandE_t>.metaTypes,
    nullptr
} };

void FilterCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<FilterCommand *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onFileFiltered((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        default: ;
        }
    }
}

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

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

int FilterCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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_ZN15ToId3v24CommandE_t {};
} // unnamed namespace

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

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

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

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

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

int ToId3v24Command::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN15ToId3v23CommandE_t {};
} // unnamed namespace

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

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

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

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

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

int ToId3v23Command::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20TagToFilenameCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int TagToFilenameCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20FilenameToTagCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int FilenameToTagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20TagToOtherTagCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int TagToOtherTagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11CopyCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int CopyCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN12PasteCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int PasteCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13RemoveCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int RemoveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13ConfigCommandE_t {};
} // unnamed namespace

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

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

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

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

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

int ConfigCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN14ExecuteCommandE_t {};
} // unnamed namespace

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

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

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

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

void *ExecuteCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ExecuteCommandE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "ExternalProcess::IOutputViewer"))
        return static_cast< ExternalProcess::IOutputViewer*>(this);
    return CliCommand::qt_metacast(_clname);
}

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