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

#include "../../../../../kate-26.07.80/addons/gdbplugin/dap/client.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'client.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.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_ZN3dap6ClientE_t {};
} // unnamed namespace

template <> constexpr inline auto dap::Client::qt_create_metaobjectdata<qt_meta_tag_ZN3dap6ClientE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "dap::Client",
        "finished",
        "",
        "initialized",
        "launched",
        "configured",
        "failed",
        "capabilitiesReceived",
        "Capabilities",
        "capabilities",
        "debuggeeRunning",
        "debuggeeTerminated",
        "success",
        "debuggeeExited",
        "exitCode",
        "debuggeeStopped",
        "StoppedEvent",
        "debuggeeContinued",
        "ContinuedEvent",
        "outputProduced",
        "Output",
        "debuggingProcess",
        "ProcessInfo",
        "errorResponse",
        "summary",
        "std::optional<Message>",
        "message",
        "threadChanged",
        "ThreadEvent",
        "moduleChanged",
        "ModuleEvent",
        "threads",
        "QList<Thread>",
        "isError",
        "errorString",
        "stackTrace",
        "threadId",
        "StackTraceInfo",
        "scopes",
        "frameId",
        "QList<Scope>",
        "variables",
        "variablesReference",
        "QList<Variable>",
        "modules",
        "ModulesInfo",
        "serverDisconnected",
        "sourceContent",
        "QUrl",
        "path",
        "reference",
        "SourceContent",
        "content",
        "sourceBreakpoints",
        "std::optional<QList<Breakpoint>>",
        "breakpoints",
        "breakpointChanged",
        "BreakpointEvent",
        "expressionEvaluated",
        "expression",
        "std::optional<EvaluateInfo>",
        "gotoTargets",
        "Source",
        "source",
        "line",
        "QList<GotoTarget>",
        "targets",
        "debuggeeRequiresTerminal",
        "RunInTerminalRequestArguments",
        "args",
        "ProcessInTerminal",
        "processCreated",
        "functionBreakpointsSet",
        "QList<dap::FunctionBreakpoint>",
        "requestedBreakpoints",
        "QList<dap::Breakpoint>",
        "response",
        "State",
        "None",
        "Initializing",
        "Initialized",
        "Running",
        "Failed"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'finished'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'initialized'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'launched'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'configured'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'failed'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'capabilitiesReceived'
        QtMocHelpers::SignalData<void(const Capabilities &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'debuggeeRunning'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'debuggeeTerminated'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'debuggeeExited'
        QtMocHelpers::SignalData<void(int)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'debuggeeStopped'
        QtMocHelpers::SignalData<void(const StoppedEvent &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 2 },
        }}),
        // Signal 'debuggeeContinued'
        QtMocHelpers::SignalData<void(const ContinuedEvent &)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 2 },
        }}),
        // Signal 'outputProduced'
        QtMocHelpers::SignalData<void(const Output &)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 2 },
        }}),
        // Signal 'debuggingProcess'
        QtMocHelpers::SignalData<void(const ProcessInfo &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 2 },
        }}),
        // Signal 'errorResponse'
        QtMocHelpers::SignalData<void(const QString &, const std::optional<Message> &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 24 }, { 0x80000000 | 25, 26 },
        }}),
        // Signal 'threadChanged'
        QtMocHelpers::SignalData<void(const ThreadEvent &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 2 },
        }}),
        // Signal 'moduleChanged'
        QtMocHelpers::SignalData<void(const ModuleEvent &)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 30, 2 },
        }}),
        // Signal 'threads'
        QtMocHelpers::SignalData<void(const QList<Thread> &, bool, const QString &)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 2 }, { QMetaType::Bool, 33 }, { QMetaType::QString, 34 },
        }}),
        // Signal 'stackTrace'
        QtMocHelpers::SignalData<void(int, const StackTraceInfo &)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 }, { 0x80000000 | 37, 2 },
        }}),
        // Signal 'scopes'
        QtMocHelpers::SignalData<void(int, const QList<Scope> &)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { 0x80000000 | 40, 2 },
        }}),
        // Signal 'variables'
        QtMocHelpers::SignalData<void(int, const QList<Variable> &)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 42 }, { 0x80000000 | 43, 2 },
        }}),
        // Signal 'modules'
        QtMocHelpers::SignalData<void(const ModulesInfo &)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 45, 2 },
        }}),
        // Signal 'serverDisconnected'
        QtMocHelpers::SignalData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sourceContent'
        QtMocHelpers::SignalData<void(const QUrl &, int, const SourceContent &)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 }, { QMetaType::Int, 50 }, { 0x80000000 | 51, 52 },
        }}),
        // Signal 'sourceBreakpoints'
        QtMocHelpers::SignalData<void(const QUrl &, int, const std::optional<QList<Breakpoint>> &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 }, { QMetaType::Int, 50 }, { 0x80000000 | 54, 55 },
        }}),
        // Signal 'breakpointChanged'
        QtMocHelpers::SignalData<void(const BreakpointEvent &)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 2 },
        }}),
        // Signal 'expressionEvaluated'
        QtMocHelpers::SignalData<void(const QString &, const std::optional<EvaluateInfo> &)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 59 }, { 0x80000000 | 60, 2 },
        }}),
        // Signal 'gotoTargets'
        QtMocHelpers::SignalData<void(const Source &, int, const QList<GotoTarget> &)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 }, { QMetaType::Int, 64 }, { 0x80000000 | 65, 66 },
        }}),
        // Signal 'debuggeeRequiresTerminal'
        QtMocHelpers::SignalData<void(const RunInTerminalRequestArguments &, const ProcessInTerminal &)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 69 }, { 0x80000000 | 70, 71 },
        }}),
        // Signal 'functionBreakpointsSet'
        QtMocHelpers::SignalData<void(const QList<dap::FunctionBreakpoint> &, const QList<dap::Breakpoint> &)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 73, 74 }, { 0x80000000 | 75, 76 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'State'
        QtMocHelpers::EnumData<enum State>(77, 77, QMC::EnumIsScoped).add({
            {   78, State::None },
            {   79, State::Initializing },
            {   80, State::Initialized },
            {   81, State::Running },
            {   82, State::Failed },
        }),
    };
    return QtMocHelpers::metaObjectData<Client, qt_meta_tag_ZN3dap6ClientE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject dap::Client::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3dap6ClientE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3dap6ClientE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3dap6ClientE_t>.metaTypes,
    nullptr
} };

void dap::Client::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Client *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->finished(); break;
        case 1: _t->initialized(); break;
        case 2: _t->launched(); break;
        case 3: _t->configured(); break;
        case 4: _t->failed(); break;
        case 5: _t->capabilitiesReceived((*reinterpret_cast<std::add_pointer_t<Capabilities>>(_a[1]))); break;
        case 6: _t->debuggeeRunning(); break;
        case 7: _t->debuggeeTerminated((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->debuggeeExited((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->debuggeeStopped((*reinterpret_cast<std::add_pointer_t<StoppedEvent>>(_a[1]))); break;
        case 10: _t->debuggeeContinued((*reinterpret_cast<std::add_pointer_t<ContinuedEvent>>(_a[1]))); break;
        case 11: _t->outputProduced((*reinterpret_cast<std::add_pointer_t<Output>>(_a[1]))); break;
        case 12: _t->debuggingProcess((*reinterpret_cast<std::add_pointer_t<ProcessInfo>>(_a[1]))); break;
        case 13: _t->errorResponse((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::optional<Message>>>(_a[2]))); break;
        case 14: _t->threadChanged((*reinterpret_cast<std::add_pointer_t<ThreadEvent>>(_a[1]))); break;
        case 15: _t->moduleChanged((*reinterpret_cast<std::add_pointer_t<ModuleEvent>>(_a[1]))); break;
        case 16: _t->threads((*reinterpret_cast<std::add_pointer_t<QList<Thread>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 17: _t->stackTrace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<StackTraceInfo>>(_a[2]))); break;
        case 18: _t->scopes((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<Scope>>>(_a[2]))); break;
        case 19: _t->variables((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<Variable>>>(_a[2]))); break;
        case 20: _t->modules((*reinterpret_cast<std::add_pointer_t<ModulesInfo>>(_a[1]))); break;
        case 21: _t->serverDisconnected(); break;
        case 22: _t->sourceContent((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<SourceContent>>(_a[3]))); break;
        case 23: _t->sourceBreakpoints((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<std::optional<QList<Breakpoint>>>>(_a[3]))); break;
        case 24: _t->breakpointChanged((*reinterpret_cast<std::add_pointer_t<BreakpointEvent>>(_a[1]))); break;
        case 25: _t->expressionEvaluated((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::optional<EvaluateInfo>>>(_a[2]))); break;
        case 26: _t->gotoTargets((*reinterpret_cast<std::add_pointer_t<Source>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<GotoTarget>>>(_a[3]))); break;
        case 27: _t->debuggeeRequiresTerminal((*reinterpret_cast<std::add_pointer_t<RunInTerminalRequestArguments>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<ProcessInTerminal>>(_a[2]))); break;
        case 28: _t->functionBreakpointsSet((*reinterpret_cast<std::add_pointer_t<QList<dap::FunctionBreakpoint>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<dap::Breakpoint>>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Client::*)()>(_a, &Client::finished, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)()>(_a, &Client::initialized, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)()>(_a, &Client::launched, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)()>(_a, &Client::configured, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)()>(_a, &Client::failed, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const Capabilities & )>(_a, &Client::capabilitiesReceived, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)()>(_a, &Client::debuggeeRunning, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(bool )>(_a, &Client::debuggeeTerminated, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(int )>(_a, &Client::debuggeeExited, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const StoppedEvent & )>(_a, &Client::debuggeeStopped, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const ContinuedEvent & )>(_a, &Client::debuggeeContinued, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const Output & )>(_a, &Client::outputProduced, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const ProcessInfo & )>(_a, &Client::debuggingProcess, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const QString & , const std::optional<Message> & )>(_a, &Client::errorResponse, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const ThreadEvent & )>(_a, &Client::threadChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const ModuleEvent & )>(_a, &Client::moduleChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const QList<Thread> & , bool , const QString & )>(_a, &Client::threads, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(int , const StackTraceInfo & )>(_a, &Client::stackTrace, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(int , const QList<Scope> & )>(_a, &Client::scopes, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(int , const QList<Variable> & )>(_a, &Client::variables, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const ModulesInfo & )>(_a, &Client::modules, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)()>(_a, &Client::serverDisconnected, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const QUrl & , int , const SourceContent & )>(_a, &Client::sourceContent, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const QUrl & , int , const std::optional<QList<Breakpoint>> & )>(_a, &Client::sourceBreakpoints, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const BreakpointEvent & )>(_a, &Client::breakpointChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const QString & , const std::optional<EvaluateInfo> & )>(_a, &Client::expressionEvaluated, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const Source & , int , const QList<GotoTarget> & )>(_a, &Client::gotoTargets, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const RunInTerminalRequestArguments & , const ProcessInTerminal & )>(_a, &Client::debuggeeRequiresTerminal, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Client::*)(const QList<dap::FunctionBreakpoint> & , const QList<dap::Breakpoint> & )>(_a, &Client::functionBreakpointsSet, 28))
            return;
    }
}

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

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

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

// SIGNAL 0
void dap::Client::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void dap::Client::initialized()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void dap::Client::launched()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void dap::Client::configured()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void dap::Client::failed()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void dap::Client::capabilitiesReceived(const Capabilities & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void dap::Client::debuggeeRunning()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void dap::Client::debuggeeTerminated(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void dap::Client::debuggeeExited(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void dap::Client::debuggeeStopped(const StoppedEvent & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void dap::Client::debuggeeContinued(const ContinuedEvent & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void dap::Client::outputProduced(const Output & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void dap::Client::debuggingProcess(const ProcessInfo & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void dap::Client::errorResponse(const QString & _t1, const std::optional<Message> & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1, _t2);
}

// SIGNAL 14
void dap::Client::threadChanged(const ThreadEvent & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void dap::Client::moduleChanged(const ModuleEvent & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void dap::Client::threads(const QList<Thread> & _t1, bool _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2, _t3);
}

// SIGNAL 17
void dap::Client::stackTrace(int _t1, const StackTraceInfo & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1, _t2);
}

// SIGNAL 18
void dap::Client::scopes(int _t1, const QList<Scope> & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2);
}

// SIGNAL 19
void dap::Client::variables(int _t1, const QList<Variable> & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2);
}

// SIGNAL 20
void dap::Client::modules(const ModulesInfo & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void dap::Client::serverDisconnected()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void dap::Client::sourceContent(const QUrl & _t1, int _t2, const SourceContent & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1, _t2, _t3);
}

// SIGNAL 23
void dap::Client::sourceBreakpoints(const QUrl & _t1, int _t2, const std::optional<QList<Breakpoint>> & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1, _t2, _t3);
}

// SIGNAL 24
void dap::Client::breakpointChanged(const BreakpointEvent & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void dap::Client::expressionEvaluated(const QString & _t1, const std::optional<EvaluateInfo> & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1, _t2);
}

// SIGNAL 26
void dap::Client::gotoTargets(const Source & _t1, int _t2, const QList<GotoTarget> & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1, _t2, _t3);
}

// SIGNAL 27
void dap::Client::debuggeeRequiresTerminal(const RunInTerminalRequestArguments & _t1, const ProcessInTerminal & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1, _t2);
}

// SIGNAL 28
void dap::Client::functionBreakpointsSet(const QList<dap::FunctionBreakpoint> & _t1, const QList<dap::Breakpoint> & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1, _t2);
}
QT_WARNING_POP
