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

#include "../../../../neovim-qt/src/auto/neovimapi0.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 'neovimapi0.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.2. 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_ZN8NeovimQt10NeovimApi0E_t {};
} // unnamed namespace

template <> constexpr inline auto NeovimQt::NeovimApi0::qt_create_metaobjectdata<qt_meta_tag_ZN8NeovimQt10NeovimApi0E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "NeovimQt::NeovimApi0",
        "error",
        "",
        "errmsg",
        "QVariant",
        "errObj",
        "neovimNotification",
        "name",
        "QVariantList",
        "args",
        "on_buffer_line_count",
        "int64_t",
        "err_buffer_line_count",
        "on_buffer_get_line",
        "err_buffer_get_line",
        "on_buffer_set_line",
        "err_buffer_set_line",
        "on_buffer_del_line",
        "err_buffer_del_line",
        "on_buffer_get_line_slice",
        "QList<QByteArray>",
        "err_buffer_get_line_slice",
        "on_buffer_get_lines",
        "err_buffer_get_lines",
        "on_buffer_set_line_slice",
        "err_buffer_set_line_slice",
        "on_buffer_set_lines",
        "err_buffer_set_lines",
        "on_buffer_get_var",
        "err_buffer_get_var",
        "on_buffer_set_var",
        "err_buffer_set_var",
        "on_buffer_del_var",
        "err_buffer_del_var",
        "on_buffer_get_option",
        "err_buffer_get_option",
        "on_buffer_set_option",
        "err_buffer_set_option",
        "on_buffer_get_number",
        "err_buffer_get_number",
        "on_buffer_get_name",
        "err_buffer_get_name",
        "on_buffer_set_name",
        "err_buffer_set_name",
        "on_buffer_is_valid",
        "err_buffer_is_valid",
        "on_buffer_insert",
        "err_buffer_insert",
        "on_buffer_get_mark",
        "QPoint",
        "err_buffer_get_mark",
        "on_buffer_add_highlight",
        "err_buffer_add_highlight",
        "on_buffer_clear_highlight",
        "err_buffer_clear_highlight",
        "on_tabpage_get_windows",
        "QList<int64_t>",
        "err_tabpage_get_windows",
        "on_tabpage_get_var",
        "err_tabpage_get_var",
        "on_tabpage_set_var",
        "err_tabpage_set_var",
        "on_tabpage_del_var",
        "err_tabpage_del_var",
        "on_tabpage_get_window",
        "err_tabpage_get_window",
        "on_tabpage_is_valid",
        "err_tabpage_is_valid",
        "on_ui_attach",
        "err_ui_attach",
        "on_ui_detach",
        "err_ui_detach",
        "on_ui_try_resize",
        "err_ui_try_resize",
        "on_vim_command",
        "err_vim_command",
        "on_vim_feedkeys",
        "err_vim_feedkeys",
        "on_vim_input",
        "err_vim_input",
        "on_vim_replace_termcodes",
        "err_vim_replace_termcodes",
        "on_vim_command_output",
        "err_vim_command_output",
        "on_vim_eval",
        "err_vim_eval",
        "on_vim_call_function",
        "err_vim_call_function",
        "on_vim_strwidth",
        "err_vim_strwidth",
        "on_vim_list_runtime_paths",
        "err_vim_list_runtime_paths",
        "on_vim_change_directory",
        "err_vim_change_directory",
        "on_vim_get_current_line",
        "err_vim_get_current_line",
        "on_vim_set_current_line",
        "err_vim_set_current_line",
        "on_vim_del_current_line",
        "err_vim_del_current_line",
        "on_vim_get_var",
        "err_vim_get_var",
        "on_vim_set_var",
        "err_vim_set_var",
        "on_vim_del_var",
        "err_vim_del_var",
        "on_vim_get_vvar",
        "err_vim_get_vvar",
        "on_vim_get_option",
        "err_vim_get_option",
        "on_vim_set_option",
        "err_vim_set_option",
        "on_vim_out_write",
        "err_vim_out_write",
        "on_vim_err_write",
        "err_vim_err_write",
        "on_vim_report_error",
        "err_vim_report_error",
        "on_vim_get_buffers",
        "err_vim_get_buffers",
        "on_vim_get_current_buffer",
        "err_vim_get_current_buffer",
        "on_vim_set_current_buffer",
        "err_vim_set_current_buffer",
        "on_vim_get_windows",
        "err_vim_get_windows",
        "on_vim_get_current_window",
        "err_vim_get_current_window",
        "on_vim_set_current_window",
        "err_vim_set_current_window",
        "on_vim_get_tabpages",
        "err_vim_get_tabpages",
        "on_vim_get_current_tabpage",
        "err_vim_get_current_tabpage",
        "on_vim_set_current_tabpage",
        "err_vim_set_current_tabpage",
        "on_vim_subscribe",
        "err_vim_subscribe",
        "on_vim_unsubscribe",
        "err_vim_unsubscribe",
        "on_vim_name_to_color",
        "err_vim_name_to_color",
        "on_vim_get_color_map",
        "QVariantMap",
        "err_vim_get_color_map",
        "on_window_get_buffer",
        "err_window_get_buffer",
        "on_window_get_cursor",
        "err_window_get_cursor",
        "on_window_set_cursor",
        "err_window_set_cursor",
        "on_window_get_height",
        "err_window_get_height",
        "on_window_set_height",
        "err_window_set_height",
        "on_window_get_width",
        "err_window_get_width",
        "on_window_set_width",
        "err_window_set_width",
        "on_window_get_var",
        "err_window_get_var",
        "on_window_set_var",
        "err_window_set_var",
        "on_window_del_var",
        "err_window_del_var",
        "on_window_get_option",
        "err_window_get_option",
        "on_window_set_option",
        "err_window_set_option",
        "on_window_get_position",
        "err_window_get_position",
        "on_window_get_tabpage",
        "err_window_get_tabpage",
        "on_window_is_valid",
        "err_window_is_valid",
        "handleResponse",
        "id",
        "fun",
        "handleResponseError",
        "buffer_line_count",
        "NeovimQt::MsgpackRequest*",
        "buffer",
        "buffer_get_line",
        "index",
        "buffer_set_line",
        "line",
        "buffer_del_line",
        "buffer_get_line_slice",
        "start",
        "end",
        "include_start",
        "include_end",
        "buffer_get_lines",
        "strict_indexing",
        "buffer_set_line_slice",
        "replacement",
        "buffer_set_lines",
        "buffer_get_var",
        "buffer_set_var",
        "value",
        "buffer_del_var",
        "buffer_get_option",
        "buffer_set_option",
        "buffer_get_number",
        "buffer_get_name",
        "buffer_set_name",
        "buffer_is_valid",
        "buffer_insert",
        "lnum",
        "lines",
        "buffer_get_mark",
        "buffer_add_highlight",
        "src_id",
        "hl_group",
        "col_start",
        "col_end",
        "buffer_clear_highlight",
        "line_start",
        "line_end",
        "tabpage_get_windows",
        "tabpage",
        "tabpage_get_var",
        "tabpage_set_var",
        "tabpage_del_var",
        "tabpage_get_window",
        "tabpage_is_valid",
        "ui_attach",
        "width",
        "height",
        "enable_rgb",
        "ui_detach",
        "ui_try_resize",
        "vim_command",
        "str",
        "vim_feedkeys",
        "keys",
        "mode",
        "escape_csi",
        "vim_input",
        "vim_replace_termcodes",
        "from_part",
        "do_lt",
        "special",
        "vim_command_output",
        "vim_eval",
        "vim_call_function",
        "fname",
        "vim_strwidth",
        "vim_list_runtime_paths",
        "vim_change_directory",
        "dir",
        "vim_get_current_line",
        "vim_set_current_line",
        "vim_del_current_line",
        "vim_get_var",
        "vim_set_var",
        "vim_del_var",
        "vim_get_vvar",
        "vim_get_option",
        "vim_set_option",
        "vim_out_write",
        "vim_err_write",
        "vim_report_error",
        "vim_get_buffers",
        "vim_get_current_buffer",
        "vim_set_current_buffer",
        "vim_get_windows",
        "vim_get_current_window",
        "vim_set_current_window",
        "window",
        "vim_get_tabpages",
        "vim_get_current_tabpage",
        "vim_set_current_tabpage",
        "vim_subscribe",
        "event",
        "vim_unsubscribe",
        "vim_name_to_color",
        "vim_get_color_map",
        "window_get_buffer",
        "window_get_cursor",
        "window_set_cursor",
        "pos",
        "window_get_height",
        "window_set_height",
        "window_get_width",
        "window_set_width",
        "window_get_var",
        "window_set_var",
        "window_del_var",
        "window_get_option",
        "window_set_option",
        "window_get_position",
        "window_get_tabpage",
        "window_is_valid",
        "FunctionId",
        "NEOVIM_FN_NULL",
        "NEOVIM_FN_BUFFER_LINE_COUNT",
        "NEOVIM_FN_BUFFER_GET_LINE",
        "NEOVIM_FN_BUFFER_SET_LINE",
        "NEOVIM_FN_BUFFER_DEL_LINE",
        "NEOVIM_FN_BUFFER_GET_LINE_SLICE",
        "NEOVIM_FN_BUFFER_GET_LINES",
        "NEOVIM_FN_BUFFER_SET_LINE_SLICE",
        "NEOVIM_FN_BUFFER_SET_LINES",
        "NEOVIM_FN_BUFFER_GET_VAR",
        "NEOVIM_FN_BUFFER_SET_VAR",
        "NEOVIM_FN_BUFFER_DEL_VAR",
        "NEOVIM_FN_BUFFER_GET_OPTION",
        "NEOVIM_FN_BUFFER_SET_OPTION",
        "NEOVIM_FN_BUFFER_GET_NUMBER",
        "NEOVIM_FN_BUFFER_GET_NAME",
        "NEOVIM_FN_BUFFER_SET_NAME",
        "NEOVIM_FN_BUFFER_IS_VALID",
        "NEOVIM_FN_BUFFER_INSERT",
        "NEOVIM_FN_BUFFER_GET_MARK",
        "NEOVIM_FN_BUFFER_ADD_HIGHLIGHT",
        "NEOVIM_FN_BUFFER_CLEAR_HIGHLIGHT",
        "NEOVIM_FN_TABPAGE_GET_WINDOWS",
        "NEOVIM_FN_TABPAGE_GET_VAR",
        "NEOVIM_FN_TABPAGE_SET_VAR",
        "NEOVIM_FN_TABPAGE_DEL_VAR",
        "NEOVIM_FN_TABPAGE_GET_WINDOW",
        "NEOVIM_FN_TABPAGE_IS_VALID",
        "NEOVIM_FN_UI_ATTACH",
        "NEOVIM_FN_UI_DETACH",
        "NEOVIM_FN_UI_TRY_RESIZE",
        "NEOVIM_FN_VIM_COMMAND",
        "NEOVIM_FN_VIM_FEEDKEYS",
        "NEOVIM_FN_VIM_INPUT",
        "NEOVIM_FN_VIM_REPLACE_TERMCODES",
        "NEOVIM_FN_VIM_COMMAND_OUTPUT",
        "NEOVIM_FN_VIM_EVAL",
        "NEOVIM_FN_VIM_CALL_FUNCTION",
        "NEOVIM_FN_VIM_STRWIDTH",
        "NEOVIM_FN_VIM_LIST_RUNTIME_PATHS",
        "NEOVIM_FN_VIM_CHANGE_DIRECTORY",
        "NEOVIM_FN_VIM_GET_CURRENT_LINE",
        "NEOVIM_FN_VIM_SET_CURRENT_LINE",
        "NEOVIM_FN_VIM_DEL_CURRENT_LINE",
        "NEOVIM_FN_VIM_GET_VAR",
        "NEOVIM_FN_VIM_SET_VAR",
        "NEOVIM_FN_VIM_DEL_VAR",
        "NEOVIM_FN_VIM_GET_VVAR",
        "NEOVIM_FN_VIM_GET_OPTION",
        "NEOVIM_FN_VIM_SET_OPTION",
        "NEOVIM_FN_VIM_OUT_WRITE",
        "NEOVIM_FN_VIM_ERR_WRITE",
        "NEOVIM_FN_VIM_REPORT_ERROR",
        "NEOVIM_FN_VIM_GET_BUFFERS",
        "NEOVIM_FN_VIM_GET_CURRENT_BUFFER",
        "NEOVIM_FN_VIM_SET_CURRENT_BUFFER",
        "NEOVIM_FN_VIM_GET_WINDOWS",
        "NEOVIM_FN_VIM_GET_CURRENT_WINDOW",
        "NEOVIM_FN_VIM_SET_CURRENT_WINDOW",
        "NEOVIM_FN_VIM_GET_TABPAGES",
        "NEOVIM_FN_VIM_GET_CURRENT_TABPAGE",
        "NEOVIM_FN_VIM_SET_CURRENT_TABPAGE",
        "NEOVIM_FN_VIM_SUBSCRIBE",
        "NEOVIM_FN_VIM_UNSUBSCRIBE",
        "NEOVIM_FN_VIM_NAME_TO_COLOR",
        "NEOVIM_FN_VIM_GET_COLOR_MAP",
        "NEOVIM_FN_WINDOW_GET_BUFFER",
        "NEOVIM_FN_WINDOW_GET_CURSOR",
        "NEOVIM_FN_WINDOW_SET_CURSOR",
        "NEOVIM_FN_WINDOW_GET_HEIGHT",
        "NEOVIM_FN_WINDOW_SET_HEIGHT",
        "NEOVIM_FN_WINDOW_GET_WIDTH",
        "NEOVIM_FN_WINDOW_SET_WIDTH",
        "NEOVIM_FN_WINDOW_GET_VAR",
        "NEOVIM_FN_WINDOW_SET_VAR",
        "NEOVIM_FN_WINDOW_DEL_VAR",
        "NEOVIM_FN_WINDOW_GET_OPTION",
        "NEOVIM_FN_WINDOW_SET_OPTION",
        "NEOVIM_FN_WINDOW_GET_POSITION",
        "NEOVIM_FN_WINDOW_GET_TABPAGE",
        "NEOVIM_FN_WINDOW_IS_VALID"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'error'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { 0x80000000 | 4, 5 },
        }}),
        // Signal 'neovimNotification'
        QtMocHelpers::SignalData<void(const QByteArray &, const QVariantList &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 7 }, { 0x80000000 | 8, 9 },
        }}),
        // Signal 'on_buffer_line_count'
        QtMocHelpers::SignalData<void(int64_t)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_buffer_line_count'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_line'
        QtMocHelpers::SignalData<void(QByteArray)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 2 },
        }}),
        // Signal 'err_buffer_get_line'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_set_line'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_set_line'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_del_line'
        QtMocHelpers::SignalData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_del_line'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_line_slice'
        QtMocHelpers::SignalData<void(QList<QByteArray>)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 2 },
        }}),
        // Signal 'err_buffer_get_line_slice'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_lines'
        QtMocHelpers::SignalData<void(QList<QByteArray>)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 2 },
        }}),
        // Signal 'err_buffer_get_lines'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_set_line_slice'
        QtMocHelpers::SignalData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_set_line_slice'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_set_lines'
        QtMocHelpers::SignalData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_set_lines'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_var'
        QtMocHelpers::SignalData<void(QVariant)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_buffer_get_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_set_var'
        QtMocHelpers::SignalData<void(QVariant)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_buffer_set_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_del_var'
        QtMocHelpers::SignalData<void(QVariant)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_buffer_del_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_option'
        QtMocHelpers::SignalData<void(QVariant)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_buffer_get_option'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_set_option'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_set_option'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_number'
        QtMocHelpers::SignalData<void(int64_t)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_buffer_get_number'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_name'
        QtMocHelpers::SignalData<void(QByteArray)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 2 },
        }}),
        // Signal 'err_buffer_get_name'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_set_name'
        QtMocHelpers::SignalData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_set_name'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_is_valid'
        QtMocHelpers::SignalData<void(bool)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'err_buffer_is_valid'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_insert'
        QtMocHelpers::SignalData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_insert'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_get_mark'
        QtMocHelpers::SignalData<void(QPoint)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 49, 2 },
        }}),
        // Signal 'err_buffer_get_mark'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_add_highlight'
        QtMocHelpers::SignalData<void(int64_t)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_buffer_add_highlight'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_buffer_clear_highlight'
        QtMocHelpers::SignalData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_buffer_clear_highlight'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_tabpage_get_windows'
        QtMocHelpers::SignalData<void(QList<int64_t>)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 56, 2 },
        }}),
        // Signal 'err_tabpage_get_windows'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_tabpage_get_var'
        QtMocHelpers::SignalData<void(QVariant)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_tabpage_get_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_tabpage_set_var'
        QtMocHelpers::SignalData<void(QVariant)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_tabpage_set_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_tabpage_del_var'
        QtMocHelpers::SignalData<void(QVariant)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_tabpage_del_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_tabpage_get_window'
        QtMocHelpers::SignalData<void(int64_t)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_tabpage_get_window'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_tabpage_is_valid'
        QtMocHelpers::SignalData<void(bool)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'err_tabpage_is_valid'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_ui_attach'
        QtMocHelpers::SignalData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_ui_attach'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_ui_detach'
        QtMocHelpers::SignalData<void()>(70, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_ui_detach'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_ui_try_resize'
        QtMocHelpers::SignalData<void(QVariant)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_ui_try_resize'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_command'
        QtMocHelpers::SignalData<void()>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_command'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_feedkeys'
        QtMocHelpers::SignalData<void()>(76, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_feedkeys'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_input'
        QtMocHelpers::SignalData<void(int64_t)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_vim_input'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_replace_termcodes'
        QtMocHelpers::SignalData<void(QByteArray)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 2 },
        }}),
        // Signal 'err_vim_replace_termcodes'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_command_output'
        QtMocHelpers::SignalData<void(QByteArray)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 2 },
        }}),
        // Signal 'err_vim_command_output'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_eval'
        QtMocHelpers::SignalData<void(QVariant)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_vim_eval'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_call_function'
        QtMocHelpers::SignalData<void(QVariant)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_vim_call_function'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_strwidth'
        QtMocHelpers::SignalData<void(int64_t)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_vim_strwidth'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_list_runtime_paths'
        QtMocHelpers::SignalData<void(QList<QByteArray>)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 2 },
        }}),
        // Signal 'err_vim_list_runtime_paths'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_change_directory'
        QtMocHelpers::SignalData<void()>(92, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_change_directory'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_current_line'
        QtMocHelpers::SignalData<void(QByteArray)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 2 },
        }}),
        // Signal 'err_vim_get_current_line'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(95, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_set_current_line'
        QtMocHelpers::SignalData<void()>(96, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_set_current_line'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(97, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_del_current_line'
        QtMocHelpers::SignalData<void()>(98, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_del_current_line'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_var'
        QtMocHelpers::SignalData<void(QVariant)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_vim_get_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_set_var'
        QtMocHelpers::SignalData<void(QVariant)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_vim_set_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_del_var'
        QtMocHelpers::SignalData<void(QVariant)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_vim_del_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_vvar'
        QtMocHelpers::SignalData<void(QVariant)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_vim_get_vvar'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_option'
        QtMocHelpers::SignalData<void(QVariant)>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_vim_get_option'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_set_option'
        QtMocHelpers::SignalData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_set_option'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_out_write'
        QtMocHelpers::SignalData<void()>(112, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_out_write'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_err_write'
        QtMocHelpers::SignalData<void()>(114, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_err_write'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(115, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_report_error'
        QtMocHelpers::SignalData<void()>(116, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_report_error'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_buffers'
        QtMocHelpers::SignalData<void(QList<int64_t>)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 56, 2 },
        }}),
        // Signal 'err_vim_get_buffers'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_current_buffer'
        QtMocHelpers::SignalData<void(int64_t)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_vim_get_current_buffer'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_set_current_buffer'
        QtMocHelpers::SignalData<void()>(122, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_set_current_buffer'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(123, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_windows'
        QtMocHelpers::SignalData<void(QList<int64_t>)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 56, 2 },
        }}),
        // Signal 'err_vim_get_windows'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(125, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_current_window'
        QtMocHelpers::SignalData<void(int64_t)>(126, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_vim_get_current_window'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(127, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_set_current_window'
        QtMocHelpers::SignalData<void()>(128, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_set_current_window'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(129, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_tabpages'
        QtMocHelpers::SignalData<void(QList<int64_t>)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 56, 2 },
        }}),
        // Signal 'err_vim_get_tabpages'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(131, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_current_tabpage'
        QtMocHelpers::SignalData<void(int64_t)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_vim_get_current_tabpage'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(133, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_set_current_tabpage'
        QtMocHelpers::SignalData<void()>(134, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_set_current_tabpage'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(135, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_subscribe'
        QtMocHelpers::SignalData<void()>(136, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_subscribe'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(137, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_unsubscribe'
        QtMocHelpers::SignalData<void()>(138, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_vim_unsubscribe'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(139, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_name_to_color'
        QtMocHelpers::SignalData<void(int64_t)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_vim_name_to_color'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(141, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_vim_get_color_map'
        QtMocHelpers::SignalData<void(QVariantMap)>(142, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 143, 2 },
        }}),
        // Signal 'err_vim_get_color_map'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(144, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_buffer'
        QtMocHelpers::SignalData<void(int64_t)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_window_get_buffer'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(146, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_cursor'
        QtMocHelpers::SignalData<void(QPoint)>(147, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 49, 2 },
        }}),
        // Signal 'err_window_get_cursor'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_set_cursor'
        QtMocHelpers::SignalData<void()>(149, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_window_set_cursor'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(150, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_height'
        QtMocHelpers::SignalData<void(int64_t)>(151, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_window_get_height'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(152, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_set_height'
        QtMocHelpers::SignalData<void()>(153, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_window_set_height'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(154, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_width'
        QtMocHelpers::SignalData<void(int64_t)>(155, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_window_get_width'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(156, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_set_width'
        QtMocHelpers::SignalData<void()>(157, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_window_set_width'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(158, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_var'
        QtMocHelpers::SignalData<void(QVariant)>(159, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_window_get_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(160, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_set_var'
        QtMocHelpers::SignalData<void(QVariant)>(161, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_window_set_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(162, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_del_var'
        QtMocHelpers::SignalData<void(QVariant)>(163, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_window_del_var'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(164, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_option'
        QtMocHelpers::SignalData<void(QVariant)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 2 },
        }}),
        // Signal 'err_window_get_option'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(166, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_set_option'
        QtMocHelpers::SignalData<void()>(167, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'err_window_set_option'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(168, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_position'
        QtMocHelpers::SignalData<void(QPoint)>(169, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 49, 2 },
        }}),
        // Signal 'err_window_get_position'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(170, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_get_tabpage'
        QtMocHelpers::SignalData<void(int64_t)>(171, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 2 },
        }}),
        // Signal 'err_window_get_tabpage'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(172, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Signal 'on_window_is_valid'
        QtMocHelpers::SignalData<void(bool)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'err_window_is_valid'
        QtMocHelpers::SignalData<void(const QString &, const QVariant &)>(174, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 }, { 0x80000000 | 4, 2 },
        }}),
        // Slot 'handleResponse'
        QtMocHelpers::SlotData<void(quint32, quint64, const QVariant &)>(175, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::UInt, 176 }, { QMetaType::ULongLong, 177 }, { 0x80000000 | 4, 2 },
        }}),
        // Slot 'handleResponseError'
        QtMocHelpers::SlotData<void(quint32, quint64, const QVariant &)>(178, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::UInt, 176 }, { QMetaType::ULongLong, 177 }, { 0x80000000 | 4, 2 },
        }}),
        // Slot 'buffer_line_count'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(179, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 },
        }}),
        // Slot 'buffer_get_line'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t)>(182, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 183 },
        }}),
        // Slot 'buffer_set_line'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, QByteArray)>(184, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 183 }, { QMetaType::QByteArray, 185 },
        }}),
        // Slot 'buffer_del_line'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t)>(186, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 183 },
        }}),
        // Slot 'buffer_get_line_slice'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, int64_t, bool, bool)>(187, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 188 }, { 0x80000000 | 11, 189 }, { QMetaType::Bool, 190 },
            { QMetaType::Bool, 191 },
        }}),
        // Slot 'buffer_get_lines'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, int64_t, bool)>(192, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 188 }, { 0x80000000 | 11, 189 }, { QMetaType::Bool, 193 },
        }}),
        // Slot 'buffer_set_line_slice'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, int64_t, bool, bool, QList<QByteArray>)>(194, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 188 }, { 0x80000000 | 11, 189 }, { QMetaType::Bool, 190 },
            { QMetaType::Bool, 191 }, { 0x80000000 | 20, 195 },
        }}),
        // Slot 'buffer_set_lines'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, int64_t, bool, QList<QByteArray>)>(196, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 188 }, { 0x80000000 | 11, 189 }, { QMetaType::Bool, 193 },
            { 0x80000000 | 20, 195 },
        }}),
        // Slot 'buffer_get_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(197, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'buffer_set_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray, QVariant)>(198, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { QMetaType::QByteArray, 7 }, { 0x80000000 | 4, 199 },
        }}),
        // Slot 'buffer_del_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(200, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'buffer_get_option'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(201, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'buffer_set_option'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray, QVariant)>(202, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { QMetaType::QByteArray, 7 }, { 0x80000000 | 4, 199 },
        }}),
        // Slot 'buffer_get_number'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(203, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 },
        }}),
        // Slot 'buffer_get_name'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(204, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 },
        }}),
        // Slot 'buffer_set_name'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(205, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'buffer_is_valid'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(206, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 },
        }}),
        // Slot 'buffer_insert'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, QList<QByteArray>)>(207, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 208 }, { 0x80000000 | 20, 209 },
        }}),
        // Slot 'buffer_get_mark'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(210, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'buffer_add_highlight'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, QByteArray, int64_t, int64_t, int64_t)>(211, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 212 }, { QMetaType::QByteArray, 213 }, { 0x80000000 | 11, 185 },
            { 0x80000000 | 11, 214 }, { 0x80000000 | 11, 215 },
        }}),
        // Slot 'buffer_clear_highlight'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, int64_t, int64_t)>(216, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 }, { 0x80000000 | 11, 212 }, { 0x80000000 | 11, 217 }, { 0x80000000 | 11, 218 },
        }}),
        // Slot 'tabpage_get_windows'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(219, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 220 },
        }}),
        // Slot 'tabpage_get_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(221, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 220 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'tabpage_set_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray, QVariant)>(222, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 220 }, { QMetaType::QByteArray, 7 }, { 0x80000000 | 4, 199 },
        }}),
        // Slot 'tabpage_del_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(223, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 220 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'tabpage_get_window'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(224, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 220 },
        }}),
        // Slot 'tabpage_is_valid'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(225, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 220 },
        }}),
        // Slot 'ui_attach'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t, bool)>(226, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 227 }, { 0x80000000 | 11, 228 }, { QMetaType::Bool, 229 },
        }}),
        // Slot 'ui_detach'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(230, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'ui_try_resize'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t)>(231, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 227 }, { 0x80000000 | 11, 228 },
        }}),
        // Slot 'vim_command'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(232, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 },
        }}),
        // Slot 'vim_feedkeys'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray, QByteArray, bool)>(234, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 235 }, { QMetaType::QByteArray, 236 }, { QMetaType::Bool, 237 },
        }}),
        // Slot 'vim_input'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(238, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 235 },
        }}),
        // Slot 'vim_replace_termcodes'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray, bool, bool, bool)>(239, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 }, { QMetaType::Bool, 240 }, { QMetaType::Bool, 241 }, { QMetaType::Bool, 242 },
        }}),
        // Slot 'vim_command_output'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(243, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 },
        }}),
        // Slot 'vim_eval'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(244, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 },
        }}),
        // Slot 'vim_call_function'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray, QVariantList)>(245, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 246 }, { 0x80000000 | 8, 9 },
        }}),
        // Slot 'vim_strwidth'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(247, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 },
        }}),
        // Slot 'vim_list_runtime_paths'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(248, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_change_directory'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(249, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 250 },
        }}),
        // Slot 'vim_get_current_line'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(251, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_set_current_line'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(252, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 185 },
        }}),
        // Slot 'vim_del_current_line'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(253, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_get_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(254, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'vim_set_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray, QVariant)>(255, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 7 }, { 0x80000000 | 4, 199 },
        }}),
        // Slot 'vim_del_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(256, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'vim_get_vvar'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(257, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'vim_get_option'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(258, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'vim_set_option'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray, QVariant)>(259, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 7 }, { 0x80000000 | 4, 199 },
        }}),
        // Slot 'vim_out_write'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(260, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 },
        }}),
        // Slot 'vim_err_write'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(261, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 },
        }}),
        // Slot 'vim_report_error'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(262, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 233 },
        }}),
        // Slot 'vim_get_buffers'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(263, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_get_current_buffer'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(264, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_set_current_buffer'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(265, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 181 },
        }}),
        // Slot 'vim_get_windows'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(266, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_get_current_window'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(267, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_set_current_window'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(268, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
        // Slot 'vim_get_tabpages'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(270, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_get_current_tabpage'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(271, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'vim_set_current_tabpage'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(272, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 220 },
        }}),
        // Slot 'vim_subscribe'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(273, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 274 },
        }}),
        // Slot 'vim_unsubscribe'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(275, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 274 },
        }}),
        // Slot 'vim_name_to_color'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(QByteArray)>(276, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'vim_get_color_map'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *()>(277, 2, QMC::AccessPublic, 0x80000000 | 180),
        // Slot 'window_get_buffer'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(278, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
        // Slot 'window_get_cursor'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(279, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
        // Slot 'window_set_cursor'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QPoint)>(280, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { 0x80000000 | 49, 281 },
        }}),
        // Slot 'window_get_height'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(282, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
        // Slot 'window_set_height'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t)>(283, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { 0x80000000 | 11, 228 },
        }}),
        // Slot 'window_get_width'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(284, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
        // Slot 'window_set_width'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, int64_t)>(285, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { 0x80000000 | 11, 227 },
        }}),
        // Slot 'window_get_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(286, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'window_set_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray, QVariant)>(287, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { QMetaType::QByteArray, 7 }, { 0x80000000 | 4, 199 },
        }}),
        // Slot 'window_del_var'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(288, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'window_get_option'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray)>(289, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { QMetaType::QByteArray, 7 },
        }}),
        // Slot 'window_set_option'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t, QByteArray, QVariant)>(290, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 }, { QMetaType::QByteArray, 7 }, { 0x80000000 | 4, 199 },
        }}),
        // Slot 'window_get_position'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(291, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
        // Slot 'window_get_tabpage'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(292, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
        // Slot 'window_is_valid'
        QtMocHelpers::SlotData<NeovimQt::MsgpackRequest *(int64_t)>(293, 2, QMC::AccessPublic, 0x80000000 | 180, {{
            { 0x80000000 | 11, 269 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'FunctionId'
        QtMocHelpers::EnumData<enum FunctionId>(294, 294, QMC::EnumFlags{}).add({
            {  295, FunctionId::NEOVIM_FN_NULL },
            {  296, FunctionId::NEOVIM_FN_BUFFER_LINE_COUNT },
            {  297, FunctionId::NEOVIM_FN_BUFFER_GET_LINE },
            {  298, FunctionId::NEOVIM_FN_BUFFER_SET_LINE },
            {  299, FunctionId::NEOVIM_FN_BUFFER_DEL_LINE },
            {  300, FunctionId::NEOVIM_FN_BUFFER_GET_LINE_SLICE },
            {  301, FunctionId::NEOVIM_FN_BUFFER_GET_LINES },
            {  302, FunctionId::NEOVIM_FN_BUFFER_SET_LINE_SLICE },
            {  303, FunctionId::NEOVIM_FN_BUFFER_SET_LINES },
            {  304, FunctionId::NEOVIM_FN_BUFFER_GET_VAR },
            {  305, FunctionId::NEOVIM_FN_BUFFER_SET_VAR },
            {  306, FunctionId::NEOVIM_FN_BUFFER_DEL_VAR },
            {  307, FunctionId::NEOVIM_FN_BUFFER_GET_OPTION },
            {  308, FunctionId::NEOVIM_FN_BUFFER_SET_OPTION },
            {  309, FunctionId::NEOVIM_FN_BUFFER_GET_NUMBER },
            {  310, FunctionId::NEOVIM_FN_BUFFER_GET_NAME },
            {  311, FunctionId::NEOVIM_FN_BUFFER_SET_NAME },
            {  312, FunctionId::NEOVIM_FN_BUFFER_IS_VALID },
            {  313, FunctionId::NEOVIM_FN_BUFFER_INSERT },
            {  314, FunctionId::NEOVIM_FN_BUFFER_GET_MARK },
            {  315, FunctionId::NEOVIM_FN_BUFFER_ADD_HIGHLIGHT },
            {  316, FunctionId::NEOVIM_FN_BUFFER_CLEAR_HIGHLIGHT },
            {  317, FunctionId::NEOVIM_FN_TABPAGE_GET_WINDOWS },
            {  318, FunctionId::NEOVIM_FN_TABPAGE_GET_VAR },
            {  319, FunctionId::NEOVIM_FN_TABPAGE_SET_VAR },
            {  320, FunctionId::NEOVIM_FN_TABPAGE_DEL_VAR },
            {  321, FunctionId::NEOVIM_FN_TABPAGE_GET_WINDOW },
            {  322, FunctionId::NEOVIM_FN_TABPAGE_IS_VALID },
            {  323, FunctionId::NEOVIM_FN_UI_ATTACH },
            {  324, FunctionId::NEOVIM_FN_UI_DETACH },
            {  325, FunctionId::NEOVIM_FN_UI_TRY_RESIZE },
            {  326, FunctionId::NEOVIM_FN_VIM_COMMAND },
            {  327, FunctionId::NEOVIM_FN_VIM_FEEDKEYS },
            {  328, FunctionId::NEOVIM_FN_VIM_INPUT },
            {  329, FunctionId::NEOVIM_FN_VIM_REPLACE_TERMCODES },
            {  330, FunctionId::NEOVIM_FN_VIM_COMMAND_OUTPUT },
            {  331, FunctionId::NEOVIM_FN_VIM_EVAL },
            {  332, FunctionId::NEOVIM_FN_VIM_CALL_FUNCTION },
            {  333, FunctionId::NEOVIM_FN_VIM_STRWIDTH },
            {  334, FunctionId::NEOVIM_FN_VIM_LIST_RUNTIME_PATHS },
            {  335, FunctionId::NEOVIM_FN_VIM_CHANGE_DIRECTORY },
            {  336, FunctionId::NEOVIM_FN_VIM_GET_CURRENT_LINE },
            {  337, FunctionId::NEOVIM_FN_VIM_SET_CURRENT_LINE },
            {  338, FunctionId::NEOVIM_FN_VIM_DEL_CURRENT_LINE },
            {  339, FunctionId::NEOVIM_FN_VIM_GET_VAR },
            {  340, FunctionId::NEOVIM_FN_VIM_SET_VAR },
            {  341, FunctionId::NEOVIM_FN_VIM_DEL_VAR },
            {  342, FunctionId::NEOVIM_FN_VIM_GET_VVAR },
            {  343, FunctionId::NEOVIM_FN_VIM_GET_OPTION },
            {  344, FunctionId::NEOVIM_FN_VIM_SET_OPTION },
            {  345, FunctionId::NEOVIM_FN_VIM_OUT_WRITE },
            {  346, FunctionId::NEOVIM_FN_VIM_ERR_WRITE },
            {  347, FunctionId::NEOVIM_FN_VIM_REPORT_ERROR },
            {  348, FunctionId::NEOVIM_FN_VIM_GET_BUFFERS },
            {  349, FunctionId::NEOVIM_FN_VIM_GET_CURRENT_BUFFER },
            {  350, FunctionId::NEOVIM_FN_VIM_SET_CURRENT_BUFFER },
            {  351, FunctionId::NEOVIM_FN_VIM_GET_WINDOWS },
            {  352, FunctionId::NEOVIM_FN_VIM_GET_CURRENT_WINDOW },
            {  353, FunctionId::NEOVIM_FN_VIM_SET_CURRENT_WINDOW },
            {  354, FunctionId::NEOVIM_FN_VIM_GET_TABPAGES },
            {  355, FunctionId::NEOVIM_FN_VIM_GET_CURRENT_TABPAGE },
            {  356, FunctionId::NEOVIM_FN_VIM_SET_CURRENT_TABPAGE },
            {  357, FunctionId::NEOVIM_FN_VIM_SUBSCRIBE },
            {  358, FunctionId::NEOVIM_FN_VIM_UNSUBSCRIBE },
            {  359, FunctionId::NEOVIM_FN_VIM_NAME_TO_COLOR },
            {  360, FunctionId::NEOVIM_FN_VIM_GET_COLOR_MAP },
            {  361, FunctionId::NEOVIM_FN_WINDOW_GET_BUFFER },
            {  362, FunctionId::NEOVIM_FN_WINDOW_GET_CURSOR },
            {  363, FunctionId::NEOVIM_FN_WINDOW_SET_CURSOR },
            {  364, FunctionId::NEOVIM_FN_WINDOW_GET_HEIGHT },
            {  365, FunctionId::NEOVIM_FN_WINDOW_SET_HEIGHT },
            {  366, FunctionId::NEOVIM_FN_WINDOW_GET_WIDTH },
            {  367, FunctionId::NEOVIM_FN_WINDOW_SET_WIDTH },
            {  368, FunctionId::NEOVIM_FN_WINDOW_GET_VAR },
            {  369, FunctionId::NEOVIM_FN_WINDOW_SET_VAR },
            {  370, FunctionId::NEOVIM_FN_WINDOW_DEL_VAR },
            {  371, FunctionId::NEOVIM_FN_WINDOW_GET_OPTION },
            {  372, FunctionId::NEOVIM_FN_WINDOW_SET_OPTION },
            {  373, FunctionId::NEOVIM_FN_WINDOW_GET_POSITION },
            {  374, FunctionId::NEOVIM_FN_WINDOW_GET_TABPAGE },
            {  375, FunctionId::NEOVIM_FN_WINDOW_IS_VALID },
        }),
    };
    return QtMocHelpers::metaObjectData<NeovimApi0, qt_meta_tag_ZN8NeovimQt10NeovimApi0E_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject NeovimQt::NeovimApi0::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8NeovimQt10NeovimApi0E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8NeovimQt10NeovimApi0E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8NeovimQt10NeovimApi0E_t>.metaTypes,
    nullptr
} };

void NeovimQt::NeovimApi0::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<NeovimApi0 *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->error((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 1: _t->neovimNotification((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantList>>(_a[2]))); break;
        case 2: _t->on_buffer_line_count((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 3: _t->err_buffer_line_count((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 4: _t->on_buffer_get_line((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 5: _t->err_buffer_get_line((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 6: _t->on_buffer_set_line(); break;
        case 7: _t->err_buffer_set_line((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 8: _t->on_buffer_del_line(); break;
        case 9: _t->err_buffer_del_line((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 10: _t->on_buffer_get_line_slice((*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[1]))); break;
        case 11: _t->err_buffer_get_line_slice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 12: _t->on_buffer_get_lines((*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[1]))); break;
        case 13: _t->err_buffer_get_lines((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 14: _t->on_buffer_set_line_slice(); break;
        case 15: _t->err_buffer_set_line_slice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 16: _t->on_buffer_set_lines(); break;
        case 17: _t->err_buffer_set_lines((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 18: _t->on_buffer_get_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 19: _t->err_buffer_get_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 20: _t->on_buffer_set_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 21: _t->err_buffer_set_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 22: _t->on_buffer_del_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 23: _t->err_buffer_del_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 24: _t->on_buffer_get_option((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 25: _t->err_buffer_get_option((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 26: _t->on_buffer_set_option(); break;
        case 27: _t->err_buffer_set_option((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 28: _t->on_buffer_get_number((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 29: _t->err_buffer_get_number((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 30: _t->on_buffer_get_name((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 31: _t->err_buffer_get_name((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 32: _t->on_buffer_set_name(); break;
        case 33: _t->err_buffer_set_name((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 34: _t->on_buffer_is_valid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->err_buffer_is_valid((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 36: _t->on_buffer_insert(); break;
        case 37: _t->err_buffer_insert((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 38: _t->on_buffer_get_mark((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 39: _t->err_buffer_get_mark((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 40: _t->on_buffer_add_highlight((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 41: _t->err_buffer_add_highlight((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 42: _t->on_buffer_clear_highlight(); break;
        case 43: _t->err_buffer_clear_highlight((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 44: _t->on_tabpage_get_windows((*reinterpret_cast<std::add_pointer_t<QList<int64_t>>>(_a[1]))); break;
        case 45: _t->err_tabpage_get_windows((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 46: _t->on_tabpage_get_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 47: _t->err_tabpage_get_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 48: _t->on_tabpage_set_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 49: _t->err_tabpage_set_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 50: _t->on_tabpage_del_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 51: _t->err_tabpage_del_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 52: _t->on_tabpage_get_window((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 53: _t->err_tabpage_get_window((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 54: _t->on_tabpage_is_valid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 55: _t->err_tabpage_is_valid((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 56: _t->on_ui_attach(); break;
        case 57: _t->err_ui_attach((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 58: _t->on_ui_detach(); break;
        case 59: _t->err_ui_detach((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 60: _t->on_ui_try_resize((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 61: _t->err_ui_try_resize((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 62: _t->on_vim_command(); break;
        case 63: _t->err_vim_command((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 64: _t->on_vim_feedkeys(); break;
        case 65: _t->err_vim_feedkeys((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 66: _t->on_vim_input((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 67: _t->err_vim_input((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 68: _t->on_vim_replace_termcodes((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 69: _t->err_vim_replace_termcodes((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 70: _t->on_vim_command_output((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 71: _t->err_vim_command_output((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 72: _t->on_vim_eval((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 73: _t->err_vim_eval((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 74: _t->on_vim_call_function((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 75: _t->err_vim_call_function((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 76: _t->on_vim_strwidth((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 77: _t->err_vim_strwidth((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 78: _t->on_vim_list_runtime_paths((*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[1]))); break;
        case 79: _t->err_vim_list_runtime_paths((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 80: _t->on_vim_change_directory(); break;
        case 81: _t->err_vim_change_directory((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 82: _t->on_vim_get_current_line((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 83: _t->err_vim_get_current_line((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 84: _t->on_vim_set_current_line(); break;
        case 85: _t->err_vim_set_current_line((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 86: _t->on_vim_del_current_line(); break;
        case 87: _t->err_vim_del_current_line((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 88: _t->on_vim_get_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 89: _t->err_vim_get_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 90: _t->on_vim_set_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 91: _t->err_vim_set_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 92: _t->on_vim_del_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 93: _t->err_vim_del_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 94: _t->on_vim_get_vvar((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 95: _t->err_vim_get_vvar((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 96: _t->on_vim_get_option((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 97: _t->err_vim_get_option((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 98: _t->on_vim_set_option(); break;
        case 99: _t->err_vim_set_option((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 100: _t->on_vim_out_write(); break;
        case 101: _t->err_vim_out_write((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 102: _t->on_vim_err_write(); break;
        case 103: _t->err_vim_err_write((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 104: _t->on_vim_report_error(); break;
        case 105: _t->err_vim_report_error((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 106: _t->on_vim_get_buffers((*reinterpret_cast<std::add_pointer_t<QList<int64_t>>>(_a[1]))); break;
        case 107: _t->err_vim_get_buffers((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 108: _t->on_vim_get_current_buffer((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 109: _t->err_vim_get_current_buffer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 110: _t->on_vim_set_current_buffer(); break;
        case 111: _t->err_vim_set_current_buffer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 112: _t->on_vim_get_windows((*reinterpret_cast<std::add_pointer_t<QList<int64_t>>>(_a[1]))); break;
        case 113: _t->err_vim_get_windows((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 114: _t->on_vim_get_current_window((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 115: _t->err_vim_get_current_window((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 116: _t->on_vim_set_current_window(); break;
        case 117: _t->err_vim_set_current_window((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 118: _t->on_vim_get_tabpages((*reinterpret_cast<std::add_pointer_t<QList<int64_t>>>(_a[1]))); break;
        case 119: _t->err_vim_get_tabpages((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 120: _t->on_vim_get_current_tabpage((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 121: _t->err_vim_get_current_tabpage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 122: _t->on_vim_set_current_tabpage(); break;
        case 123: _t->err_vim_set_current_tabpage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 124: _t->on_vim_subscribe(); break;
        case 125: _t->err_vim_subscribe((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 126: _t->on_vim_unsubscribe(); break;
        case 127: _t->err_vim_unsubscribe((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 128: _t->on_vim_name_to_color((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 129: _t->err_vim_name_to_color((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 130: _t->on_vim_get_color_map((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); break;
        case 131: _t->err_vim_get_color_map((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 132: _t->on_window_get_buffer((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 133: _t->err_window_get_buffer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 134: _t->on_window_get_cursor((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 135: _t->err_window_get_cursor((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 136: _t->on_window_set_cursor(); break;
        case 137: _t->err_window_set_cursor((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 138: _t->on_window_get_height((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 139: _t->err_window_get_height((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 140: _t->on_window_set_height(); break;
        case 141: _t->err_window_set_height((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 142: _t->on_window_get_width((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 143: _t->err_window_get_width((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 144: _t->on_window_set_width(); break;
        case 145: _t->err_window_set_width((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 146: _t->on_window_get_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 147: _t->err_window_get_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 148: _t->on_window_set_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 149: _t->err_window_set_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 150: _t->on_window_del_var((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 151: _t->err_window_del_var((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 152: _t->on_window_get_option((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 153: _t->err_window_get_option((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 154: _t->on_window_set_option(); break;
        case 155: _t->err_window_set_option((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 156: _t->on_window_get_position((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 157: _t->err_window_get_position((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 158: _t->on_window_get_tabpage((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1]))); break;
        case 159: _t->err_window_get_tabpage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 160: _t->on_window_is_valid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 161: _t->err_window_is_valid((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 162: _t->handleResponse((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3]))); break;
        case 163: _t->handleResponseError((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3]))); break;
        case 164: { NeovimQt::MsgpackRequest* _r = _t->buffer_line_count((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 165: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_line((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 166: { NeovimQt::MsgpackRequest* _r = _t->buffer_set_line((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 167: { NeovimQt::MsgpackRequest* _r = _t->buffer_del_line((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 168: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_line_slice((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 169: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_lines((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 170: { NeovimQt::MsgpackRequest* _r = _t->buffer_set_line_slice((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[6])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 171: { NeovimQt::MsgpackRequest* _r = _t->buffer_set_lines((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[5])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 172: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 173: { NeovimQt::MsgpackRequest* _r = _t->buffer_set_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 174: { NeovimQt::MsgpackRequest* _r = _t->buffer_del_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 175: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_option((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 176: { NeovimQt::MsgpackRequest* _r = _t->buffer_set_option((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 177: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_number((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 178: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_name((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 179: { NeovimQt::MsgpackRequest* _r = _t->buffer_set_name((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 180: { NeovimQt::MsgpackRequest* _r = _t->buffer_is_valid((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 181: { NeovimQt::MsgpackRequest* _r = _t->buffer_insert((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<QByteArray>>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 182: { NeovimQt::MsgpackRequest* _r = _t->buffer_get_mark((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 183: { NeovimQt::MsgpackRequest* _r = _t->buffer_add_highlight((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[6])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 184: { NeovimQt::MsgpackRequest* _r = _t->buffer_clear_highlight((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[4])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 185: { NeovimQt::MsgpackRequest* _r = _t->tabpage_get_windows((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 186: { NeovimQt::MsgpackRequest* _r = _t->tabpage_get_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 187: { NeovimQt::MsgpackRequest* _r = _t->tabpage_set_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 188: { NeovimQt::MsgpackRequest* _r = _t->tabpage_del_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 189: { NeovimQt::MsgpackRequest* _r = _t->tabpage_get_window((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 190: { NeovimQt::MsgpackRequest* _r = _t->tabpage_is_valid((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 191: { NeovimQt::MsgpackRequest* _r = _t->ui_attach((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 192: { NeovimQt::MsgpackRequest* _r = _t->ui_detach();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 193: { NeovimQt::MsgpackRequest* _r = _t->ui_try_resize((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 194: { NeovimQt::MsgpackRequest* _r = _t->vim_command((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 195: { NeovimQt::MsgpackRequest* _r = _t->vim_feedkeys((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 196: { NeovimQt::MsgpackRequest* _r = _t->vim_input((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 197: { NeovimQt::MsgpackRequest* _r = _t->vim_replace_termcodes((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 198: { NeovimQt::MsgpackRequest* _r = _t->vim_command_output((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 199: { NeovimQt::MsgpackRequest* _r = _t->vim_eval((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 200: { NeovimQt::MsgpackRequest* _r = _t->vim_call_function((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariantList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 201: { NeovimQt::MsgpackRequest* _r = _t->vim_strwidth((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 202: { NeovimQt::MsgpackRequest* _r = _t->vim_list_runtime_paths();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 203: { NeovimQt::MsgpackRequest* _r = _t->vim_change_directory((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 204: { NeovimQt::MsgpackRequest* _r = _t->vim_get_current_line();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 205: { NeovimQt::MsgpackRequest* _r = _t->vim_set_current_line((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 206: { NeovimQt::MsgpackRequest* _r = _t->vim_del_current_line();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 207: { NeovimQt::MsgpackRequest* _r = _t->vim_get_var((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 208: { NeovimQt::MsgpackRequest* _r = _t->vim_set_var((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 209: { NeovimQt::MsgpackRequest* _r = _t->vim_del_var((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 210: { NeovimQt::MsgpackRequest* _r = _t->vim_get_vvar((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 211: { NeovimQt::MsgpackRequest* _r = _t->vim_get_option((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 212: { NeovimQt::MsgpackRequest* _r = _t->vim_set_option((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 213: { NeovimQt::MsgpackRequest* _r = _t->vim_out_write((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 214: { NeovimQt::MsgpackRequest* _r = _t->vim_err_write((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 215: { NeovimQt::MsgpackRequest* _r = _t->vim_report_error((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 216: { NeovimQt::MsgpackRequest* _r = _t->vim_get_buffers();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 217: { NeovimQt::MsgpackRequest* _r = _t->vim_get_current_buffer();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 218: { NeovimQt::MsgpackRequest* _r = _t->vim_set_current_buffer((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 219: { NeovimQt::MsgpackRequest* _r = _t->vim_get_windows();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 220: { NeovimQt::MsgpackRequest* _r = _t->vim_get_current_window();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 221: { NeovimQt::MsgpackRequest* _r = _t->vim_set_current_window((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 222: { NeovimQt::MsgpackRequest* _r = _t->vim_get_tabpages();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 223: { NeovimQt::MsgpackRequest* _r = _t->vim_get_current_tabpage();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 224: { NeovimQt::MsgpackRequest* _r = _t->vim_set_current_tabpage((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 225: { NeovimQt::MsgpackRequest* _r = _t->vim_subscribe((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 226: { NeovimQt::MsgpackRequest* _r = _t->vim_unsubscribe((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 227: { NeovimQt::MsgpackRequest* _r = _t->vim_name_to_color((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 228: { NeovimQt::MsgpackRequest* _r = _t->vim_get_color_map();
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 229: { NeovimQt::MsgpackRequest* _r = _t->window_get_buffer((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 230: { NeovimQt::MsgpackRequest* _r = _t->window_get_cursor((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 231: { NeovimQt::MsgpackRequest* _r = _t->window_set_cursor((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 232: { NeovimQt::MsgpackRequest* _r = _t->window_get_height((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 233: { NeovimQt::MsgpackRequest* _r = _t->window_set_height((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 234: { NeovimQt::MsgpackRequest* _r = _t->window_get_width((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 235: { NeovimQt::MsgpackRequest* _r = _t->window_set_width((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 236: { NeovimQt::MsgpackRequest* _r = _t->window_get_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 237: { NeovimQt::MsgpackRequest* _r = _t->window_set_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 238: { NeovimQt::MsgpackRequest* _r = _t->window_del_var((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 239: { NeovimQt::MsgpackRequest* _r = _t->window_get_option((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 240: { NeovimQt::MsgpackRequest* _r = _t->window_set_option((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[3])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 241: { NeovimQt::MsgpackRequest* _r = _t->window_get_position((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 242: { NeovimQt::MsgpackRequest* _r = _t->window_get_tabpage((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        case 243: { NeovimQt::MsgpackRequest* _r = _t->window_is_valid((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeovimQt::MsgpackRequest**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 10:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        case 78:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        case 170:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 5:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        case 171:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 4:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        case 181:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QByteArray> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::error, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QByteArray & , const QVariantList & )>(_a, &NeovimApi0::neovimNotification, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_buffer_line_count, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_line_count, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QByteArray )>(_a, &NeovimApi0::on_buffer_get_line, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_line, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_set_line, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_set_line, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_del_line, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_del_line, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QList<QByteArray> )>(_a, &NeovimApi0::on_buffer_get_line_slice, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_line_slice, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QList<QByteArray> )>(_a, &NeovimApi0::on_buffer_get_lines, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_lines, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_set_line_slice, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_set_line_slice, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_set_lines, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_set_lines, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_buffer_get_var, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_var, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_buffer_set_var, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_set_var, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_buffer_del_var, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_del_var, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_buffer_get_option, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_option, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_set_option, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_set_option, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_buffer_get_number, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_number, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QByteArray )>(_a, &NeovimApi0::on_buffer_get_name, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_name, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_set_name, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_set_name, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(bool )>(_a, &NeovimApi0::on_buffer_is_valid, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_is_valid, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_insert, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_insert, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QPoint )>(_a, &NeovimApi0::on_buffer_get_mark, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_get_mark, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_buffer_add_highlight, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_add_highlight, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_buffer_clear_highlight, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_buffer_clear_highlight, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QList<int64_t> )>(_a, &NeovimApi0::on_tabpage_get_windows, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_tabpage_get_windows, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_tabpage_get_var, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_tabpage_get_var, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_tabpage_set_var, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_tabpage_set_var, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_tabpage_del_var, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_tabpage_del_var, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_tabpage_get_window, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_tabpage_get_window, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(bool )>(_a, &NeovimApi0::on_tabpage_is_valid, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_tabpage_is_valid, 55))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_ui_attach, 56))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_ui_attach, 57))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_ui_detach, 58))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_ui_detach, 59))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_ui_try_resize, 60))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_ui_try_resize, 61))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_command, 62))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_command, 63))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_feedkeys, 64))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_feedkeys, 65))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_vim_input, 66))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_input, 67))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QByteArray )>(_a, &NeovimApi0::on_vim_replace_termcodes, 68))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_replace_termcodes, 69))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QByteArray )>(_a, &NeovimApi0::on_vim_command_output, 70))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_command_output, 71))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_vim_eval, 72))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_eval, 73))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_vim_call_function, 74))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_call_function, 75))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_vim_strwidth, 76))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_strwidth, 77))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QList<QByteArray> )>(_a, &NeovimApi0::on_vim_list_runtime_paths, 78))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_list_runtime_paths, 79))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_change_directory, 80))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_change_directory, 81))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QByteArray )>(_a, &NeovimApi0::on_vim_get_current_line, 82))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_current_line, 83))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_set_current_line, 84))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_set_current_line, 85))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_del_current_line, 86))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_del_current_line, 87))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_vim_get_var, 88))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_var, 89))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_vim_set_var, 90))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_set_var, 91))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_vim_del_var, 92))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_del_var, 93))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_vim_get_vvar, 94))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_vvar, 95))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_vim_get_option, 96))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_option, 97))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_set_option, 98))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_set_option, 99))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_out_write, 100))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_out_write, 101))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_err_write, 102))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_err_write, 103))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_report_error, 104))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_report_error, 105))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QList<int64_t> )>(_a, &NeovimApi0::on_vim_get_buffers, 106))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_buffers, 107))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_vim_get_current_buffer, 108))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_current_buffer, 109))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_set_current_buffer, 110))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_set_current_buffer, 111))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QList<int64_t> )>(_a, &NeovimApi0::on_vim_get_windows, 112))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_windows, 113))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_vim_get_current_window, 114))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_current_window, 115))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_set_current_window, 116))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_set_current_window, 117))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QList<int64_t> )>(_a, &NeovimApi0::on_vim_get_tabpages, 118))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_tabpages, 119))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_vim_get_current_tabpage, 120))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_current_tabpage, 121))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_set_current_tabpage, 122))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_set_current_tabpage, 123))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_subscribe, 124))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_subscribe, 125))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_vim_unsubscribe, 126))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_unsubscribe, 127))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_vim_name_to_color, 128))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_name_to_color, 129))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariantMap )>(_a, &NeovimApi0::on_vim_get_color_map, 130))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_vim_get_color_map, 131))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_window_get_buffer, 132))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_buffer, 133))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QPoint )>(_a, &NeovimApi0::on_window_get_cursor, 134))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_cursor, 135))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_window_set_cursor, 136))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_set_cursor, 137))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_window_get_height, 138))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_height, 139))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_window_set_height, 140))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_set_height, 141))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_window_get_width, 142))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_width, 143))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_window_set_width, 144))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_set_width, 145))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_window_get_var, 146))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_var, 147))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_window_set_var, 148))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_set_var, 149))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_window_del_var, 150))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_del_var, 151))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QVariant )>(_a, &NeovimApi0::on_window_get_option, 152))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_option, 153))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)()>(_a, &NeovimApi0::on_window_set_option, 154))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_set_option, 155))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(QPoint )>(_a, &NeovimApi0::on_window_get_position, 156))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_position, 157))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(int64_t )>(_a, &NeovimApi0::on_window_get_tabpage, 158))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_get_tabpage, 159))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(bool )>(_a, &NeovimApi0::on_window_is_valid, 160))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeovimApi0::*)(const QString & , const QVariant & )>(_a, &NeovimApi0::err_window_is_valid, 161))
            return;
    }
}

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

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

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

// SIGNAL 0
void NeovimQt::NeovimApi0::error(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void NeovimQt::NeovimApi0::neovimNotification(const QByteArray & _t1, const QVariantList & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void NeovimQt::NeovimApi0::on_buffer_line_count(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void NeovimQt::NeovimApi0::err_buffer_line_count(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2);
}

// SIGNAL 4
void NeovimQt::NeovimApi0::on_buffer_get_line(QByteArray _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void NeovimQt::NeovimApi0::err_buffer_get_line(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2);
}

// SIGNAL 6
void NeovimQt::NeovimApi0::on_buffer_set_line()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void NeovimQt::NeovimApi0::err_buffer_set_line(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2);
}

// SIGNAL 8
void NeovimQt::NeovimApi0::on_buffer_del_line()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void NeovimQt::NeovimApi0::err_buffer_del_line(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1, _t2);
}

// SIGNAL 10
void NeovimQt::NeovimApi0::on_buffer_get_line_slice(QList<QByteArray> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void NeovimQt::NeovimApi0::err_buffer_get_line_slice(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2);
}

// SIGNAL 12
void NeovimQt::NeovimApi0::on_buffer_get_lines(QList<QByteArray> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void NeovimQt::NeovimApi0::err_buffer_get_lines(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1, _t2);
}

// SIGNAL 14
void NeovimQt::NeovimApi0::on_buffer_set_line_slice()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void NeovimQt::NeovimApi0::err_buffer_set_line_slice(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
}

// SIGNAL 16
void NeovimQt::NeovimApi0::on_buffer_set_lines()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void NeovimQt::NeovimApi0::err_buffer_set_lines(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1, _t2);
}

// SIGNAL 18
void NeovimQt::NeovimApi0::on_buffer_get_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void NeovimQt::NeovimApi0::err_buffer_get_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2);
}

// SIGNAL 20
void NeovimQt::NeovimApi0::on_buffer_set_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void NeovimQt::NeovimApi0::err_buffer_set_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1, _t2);
}

// SIGNAL 22
void NeovimQt::NeovimApi0::on_buffer_del_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void NeovimQt::NeovimApi0::err_buffer_del_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1, _t2);
}

// SIGNAL 24
void NeovimQt::NeovimApi0::on_buffer_get_option(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void NeovimQt::NeovimApi0::err_buffer_get_option(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1, _t2);
}

// SIGNAL 26
void NeovimQt::NeovimApi0::on_buffer_set_option()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void NeovimQt::NeovimApi0::err_buffer_set_option(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1, _t2);
}

// SIGNAL 28
void NeovimQt::NeovimApi0::on_buffer_get_number(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void NeovimQt::NeovimApi0::err_buffer_get_number(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1, _t2);
}

// SIGNAL 30
void NeovimQt::NeovimApi0::on_buffer_get_name(QByteArray _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void NeovimQt::NeovimApi0::err_buffer_get_name(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1, _t2);
}

// SIGNAL 32
void NeovimQt::NeovimApi0::on_buffer_set_name()
{
    QMetaObject::activate(this, &staticMetaObject, 32, nullptr);
}

// SIGNAL 33
void NeovimQt::NeovimApi0::err_buffer_set_name(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1, _t2);
}

// SIGNAL 34
void NeovimQt::NeovimApi0::on_buffer_is_valid(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void NeovimQt::NeovimApi0::err_buffer_is_valid(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1, _t2);
}

// SIGNAL 36
void NeovimQt::NeovimApi0::on_buffer_insert()
{
    QMetaObject::activate(this, &staticMetaObject, 36, nullptr);
}

// SIGNAL 37
void NeovimQt::NeovimApi0::err_buffer_insert(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1, _t2);
}

// SIGNAL 38
void NeovimQt::NeovimApi0::on_buffer_get_mark(QPoint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void NeovimQt::NeovimApi0::err_buffer_get_mark(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1, _t2);
}

// SIGNAL 40
void NeovimQt::NeovimApi0::on_buffer_add_highlight(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void NeovimQt::NeovimApi0::err_buffer_add_highlight(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1, _t2);
}

// SIGNAL 42
void NeovimQt::NeovimApi0::on_buffer_clear_highlight()
{
    QMetaObject::activate(this, &staticMetaObject, 42, nullptr);
}

// SIGNAL 43
void NeovimQt::NeovimApi0::err_buffer_clear_highlight(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 43, nullptr, _t1, _t2);
}

// SIGNAL 44
void NeovimQt::NeovimApi0::on_tabpage_get_windows(QList<int64_t> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 44, nullptr, _t1);
}

// SIGNAL 45
void NeovimQt::NeovimApi0::err_tabpage_get_windows(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 45, nullptr, _t1, _t2);
}

// SIGNAL 46
void NeovimQt::NeovimApi0::on_tabpage_get_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void NeovimQt::NeovimApi0::err_tabpage_get_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 47, nullptr, _t1, _t2);
}

// SIGNAL 48
void NeovimQt::NeovimApi0::on_tabpage_set_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 48, nullptr, _t1);
}

// SIGNAL 49
void NeovimQt::NeovimApi0::err_tabpage_set_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 49, nullptr, _t1, _t2);
}

// SIGNAL 50
void NeovimQt::NeovimApi0::on_tabpage_del_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 50, nullptr, _t1);
}

// SIGNAL 51
void NeovimQt::NeovimApi0::err_tabpage_del_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 51, nullptr, _t1, _t2);
}

// SIGNAL 52
void NeovimQt::NeovimApi0::on_tabpage_get_window(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 52, nullptr, _t1);
}

// SIGNAL 53
void NeovimQt::NeovimApi0::err_tabpage_get_window(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 53, nullptr, _t1, _t2);
}

// SIGNAL 54
void NeovimQt::NeovimApi0::on_tabpage_is_valid(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 54, nullptr, _t1);
}

// SIGNAL 55
void NeovimQt::NeovimApi0::err_tabpage_is_valid(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 55, nullptr, _t1, _t2);
}

// SIGNAL 56
void NeovimQt::NeovimApi0::on_ui_attach()
{
    QMetaObject::activate(this, &staticMetaObject, 56, nullptr);
}

// SIGNAL 57
void NeovimQt::NeovimApi0::err_ui_attach(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 57, nullptr, _t1, _t2);
}

// SIGNAL 58
void NeovimQt::NeovimApi0::on_ui_detach()
{
    QMetaObject::activate(this, &staticMetaObject, 58, nullptr);
}

// SIGNAL 59
void NeovimQt::NeovimApi0::err_ui_detach(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 59, nullptr, _t1, _t2);
}

// SIGNAL 60
void NeovimQt::NeovimApi0::on_ui_try_resize(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 60, nullptr, _t1);
}

// SIGNAL 61
void NeovimQt::NeovimApi0::err_ui_try_resize(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 61, nullptr, _t1, _t2);
}

// SIGNAL 62
void NeovimQt::NeovimApi0::on_vim_command()
{
    QMetaObject::activate(this, &staticMetaObject, 62, nullptr);
}

// SIGNAL 63
void NeovimQt::NeovimApi0::err_vim_command(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 63, nullptr, _t1, _t2);
}

// SIGNAL 64
void NeovimQt::NeovimApi0::on_vim_feedkeys()
{
    QMetaObject::activate(this, &staticMetaObject, 64, nullptr);
}

// SIGNAL 65
void NeovimQt::NeovimApi0::err_vim_feedkeys(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 65, nullptr, _t1, _t2);
}

// SIGNAL 66
void NeovimQt::NeovimApi0::on_vim_input(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 66, nullptr, _t1);
}

// SIGNAL 67
void NeovimQt::NeovimApi0::err_vim_input(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 67, nullptr, _t1, _t2);
}

// SIGNAL 68
void NeovimQt::NeovimApi0::on_vim_replace_termcodes(QByteArray _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 68, nullptr, _t1);
}

// SIGNAL 69
void NeovimQt::NeovimApi0::err_vim_replace_termcodes(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 69, nullptr, _t1, _t2);
}

// SIGNAL 70
void NeovimQt::NeovimApi0::on_vim_command_output(QByteArray _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 70, nullptr, _t1);
}

// SIGNAL 71
void NeovimQt::NeovimApi0::err_vim_command_output(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 71, nullptr, _t1, _t2);
}

// SIGNAL 72
void NeovimQt::NeovimApi0::on_vim_eval(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 72, nullptr, _t1);
}

// SIGNAL 73
void NeovimQt::NeovimApi0::err_vim_eval(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 73, nullptr, _t1, _t2);
}

// SIGNAL 74
void NeovimQt::NeovimApi0::on_vim_call_function(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 74, nullptr, _t1);
}

// SIGNAL 75
void NeovimQt::NeovimApi0::err_vim_call_function(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 75, nullptr, _t1, _t2);
}

// SIGNAL 76
void NeovimQt::NeovimApi0::on_vim_strwidth(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 76, nullptr, _t1);
}

// SIGNAL 77
void NeovimQt::NeovimApi0::err_vim_strwidth(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 77, nullptr, _t1, _t2);
}

// SIGNAL 78
void NeovimQt::NeovimApi0::on_vim_list_runtime_paths(QList<QByteArray> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 78, nullptr, _t1);
}

// SIGNAL 79
void NeovimQt::NeovimApi0::err_vim_list_runtime_paths(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 79, nullptr, _t1, _t2);
}

// SIGNAL 80
void NeovimQt::NeovimApi0::on_vim_change_directory()
{
    QMetaObject::activate(this, &staticMetaObject, 80, nullptr);
}

// SIGNAL 81
void NeovimQt::NeovimApi0::err_vim_change_directory(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 81, nullptr, _t1, _t2);
}

// SIGNAL 82
void NeovimQt::NeovimApi0::on_vim_get_current_line(QByteArray _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 82, nullptr, _t1);
}

// SIGNAL 83
void NeovimQt::NeovimApi0::err_vim_get_current_line(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 83, nullptr, _t1, _t2);
}

// SIGNAL 84
void NeovimQt::NeovimApi0::on_vim_set_current_line()
{
    QMetaObject::activate(this, &staticMetaObject, 84, nullptr);
}

// SIGNAL 85
void NeovimQt::NeovimApi0::err_vim_set_current_line(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 85, nullptr, _t1, _t2);
}

// SIGNAL 86
void NeovimQt::NeovimApi0::on_vim_del_current_line()
{
    QMetaObject::activate(this, &staticMetaObject, 86, nullptr);
}

// SIGNAL 87
void NeovimQt::NeovimApi0::err_vim_del_current_line(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 87, nullptr, _t1, _t2);
}

// SIGNAL 88
void NeovimQt::NeovimApi0::on_vim_get_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 88, nullptr, _t1);
}

// SIGNAL 89
void NeovimQt::NeovimApi0::err_vim_get_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 89, nullptr, _t1, _t2);
}

// SIGNAL 90
void NeovimQt::NeovimApi0::on_vim_set_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 90, nullptr, _t1);
}

// SIGNAL 91
void NeovimQt::NeovimApi0::err_vim_set_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 91, nullptr, _t1, _t2);
}

// SIGNAL 92
void NeovimQt::NeovimApi0::on_vim_del_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 92, nullptr, _t1);
}

// SIGNAL 93
void NeovimQt::NeovimApi0::err_vim_del_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 93, nullptr, _t1, _t2);
}

// SIGNAL 94
void NeovimQt::NeovimApi0::on_vim_get_vvar(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 94, nullptr, _t1);
}

// SIGNAL 95
void NeovimQt::NeovimApi0::err_vim_get_vvar(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 95, nullptr, _t1, _t2);
}

// SIGNAL 96
void NeovimQt::NeovimApi0::on_vim_get_option(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 96, nullptr, _t1);
}

// SIGNAL 97
void NeovimQt::NeovimApi0::err_vim_get_option(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 97, nullptr, _t1, _t2);
}

// SIGNAL 98
void NeovimQt::NeovimApi0::on_vim_set_option()
{
    QMetaObject::activate(this, &staticMetaObject, 98, nullptr);
}

// SIGNAL 99
void NeovimQt::NeovimApi0::err_vim_set_option(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 99, nullptr, _t1, _t2);
}

// SIGNAL 100
void NeovimQt::NeovimApi0::on_vim_out_write()
{
    QMetaObject::activate(this, &staticMetaObject, 100, nullptr);
}

// SIGNAL 101
void NeovimQt::NeovimApi0::err_vim_out_write(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 101, nullptr, _t1, _t2);
}

// SIGNAL 102
void NeovimQt::NeovimApi0::on_vim_err_write()
{
    QMetaObject::activate(this, &staticMetaObject, 102, nullptr);
}

// SIGNAL 103
void NeovimQt::NeovimApi0::err_vim_err_write(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 103, nullptr, _t1, _t2);
}

// SIGNAL 104
void NeovimQt::NeovimApi0::on_vim_report_error()
{
    QMetaObject::activate(this, &staticMetaObject, 104, nullptr);
}

// SIGNAL 105
void NeovimQt::NeovimApi0::err_vim_report_error(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 105, nullptr, _t1, _t2);
}

// SIGNAL 106
void NeovimQt::NeovimApi0::on_vim_get_buffers(QList<int64_t> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 106, nullptr, _t1);
}

// SIGNAL 107
void NeovimQt::NeovimApi0::err_vim_get_buffers(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 107, nullptr, _t1, _t2);
}

// SIGNAL 108
void NeovimQt::NeovimApi0::on_vim_get_current_buffer(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 108, nullptr, _t1);
}

// SIGNAL 109
void NeovimQt::NeovimApi0::err_vim_get_current_buffer(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 109, nullptr, _t1, _t2);
}

// SIGNAL 110
void NeovimQt::NeovimApi0::on_vim_set_current_buffer()
{
    QMetaObject::activate(this, &staticMetaObject, 110, nullptr);
}

// SIGNAL 111
void NeovimQt::NeovimApi0::err_vim_set_current_buffer(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 111, nullptr, _t1, _t2);
}

// SIGNAL 112
void NeovimQt::NeovimApi0::on_vim_get_windows(QList<int64_t> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 112, nullptr, _t1);
}

// SIGNAL 113
void NeovimQt::NeovimApi0::err_vim_get_windows(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 113, nullptr, _t1, _t2);
}

// SIGNAL 114
void NeovimQt::NeovimApi0::on_vim_get_current_window(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 114, nullptr, _t1);
}

// SIGNAL 115
void NeovimQt::NeovimApi0::err_vim_get_current_window(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 115, nullptr, _t1, _t2);
}

// SIGNAL 116
void NeovimQt::NeovimApi0::on_vim_set_current_window()
{
    QMetaObject::activate(this, &staticMetaObject, 116, nullptr);
}

// SIGNAL 117
void NeovimQt::NeovimApi0::err_vim_set_current_window(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 117, nullptr, _t1, _t2);
}

// SIGNAL 118
void NeovimQt::NeovimApi0::on_vim_get_tabpages(QList<int64_t> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 118, nullptr, _t1);
}

// SIGNAL 119
void NeovimQt::NeovimApi0::err_vim_get_tabpages(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 119, nullptr, _t1, _t2);
}

// SIGNAL 120
void NeovimQt::NeovimApi0::on_vim_get_current_tabpage(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 120, nullptr, _t1);
}

// SIGNAL 121
void NeovimQt::NeovimApi0::err_vim_get_current_tabpage(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 121, nullptr, _t1, _t2);
}

// SIGNAL 122
void NeovimQt::NeovimApi0::on_vim_set_current_tabpage()
{
    QMetaObject::activate(this, &staticMetaObject, 122, nullptr);
}

// SIGNAL 123
void NeovimQt::NeovimApi0::err_vim_set_current_tabpage(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 123, nullptr, _t1, _t2);
}

// SIGNAL 124
void NeovimQt::NeovimApi0::on_vim_subscribe()
{
    QMetaObject::activate(this, &staticMetaObject, 124, nullptr);
}

// SIGNAL 125
void NeovimQt::NeovimApi0::err_vim_subscribe(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 125, nullptr, _t1, _t2);
}

// SIGNAL 126
void NeovimQt::NeovimApi0::on_vim_unsubscribe()
{
    QMetaObject::activate(this, &staticMetaObject, 126, nullptr);
}

// SIGNAL 127
void NeovimQt::NeovimApi0::err_vim_unsubscribe(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 127, nullptr, _t1, _t2);
}

// SIGNAL 128
void NeovimQt::NeovimApi0::on_vim_name_to_color(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 128, nullptr, _t1);
}

// SIGNAL 129
void NeovimQt::NeovimApi0::err_vim_name_to_color(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 129, nullptr, _t1, _t2);
}

// SIGNAL 130
void NeovimQt::NeovimApi0::on_vim_get_color_map(QVariantMap _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 130, nullptr, _t1);
}

// SIGNAL 131
void NeovimQt::NeovimApi0::err_vim_get_color_map(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 131, nullptr, _t1, _t2);
}

// SIGNAL 132
void NeovimQt::NeovimApi0::on_window_get_buffer(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 132, nullptr, _t1);
}

// SIGNAL 133
void NeovimQt::NeovimApi0::err_window_get_buffer(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 133, nullptr, _t1, _t2);
}

// SIGNAL 134
void NeovimQt::NeovimApi0::on_window_get_cursor(QPoint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 134, nullptr, _t1);
}

// SIGNAL 135
void NeovimQt::NeovimApi0::err_window_get_cursor(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 135, nullptr, _t1, _t2);
}

// SIGNAL 136
void NeovimQt::NeovimApi0::on_window_set_cursor()
{
    QMetaObject::activate(this, &staticMetaObject, 136, nullptr);
}

// SIGNAL 137
void NeovimQt::NeovimApi0::err_window_set_cursor(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 137, nullptr, _t1, _t2);
}

// SIGNAL 138
void NeovimQt::NeovimApi0::on_window_get_height(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 138, nullptr, _t1);
}

// SIGNAL 139
void NeovimQt::NeovimApi0::err_window_get_height(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 139, nullptr, _t1, _t2);
}

// SIGNAL 140
void NeovimQt::NeovimApi0::on_window_set_height()
{
    QMetaObject::activate(this, &staticMetaObject, 140, nullptr);
}

// SIGNAL 141
void NeovimQt::NeovimApi0::err_window_set_height(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 141, nullptr, _t1, _t2);
}

// SIGNAL 142
void NeovimQt::NeovimApi0::on_window_get_width(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 142, nullptr, _t1);
}

// SIGNAL 143
void NeovimQt::NeovimApi0::err_window_get_width(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 143, nullptr, _t1, _t2);
}

// SIGNAL 144
void NeovimQt::NeovimApi0::on_window_set_width()
{
    QMetaObject::activate(this, &staticMetaObject, 144, nullptr);
}

// SIGNAL 145
void NeovimQt::NeovimApi0::err_window_set_width(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 145, nullptr, _t1, _t2);
}

// SIGNAL 146
void NeovimQt::NeovimApi0::on_window_get_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 146, nullptr, _t1);
}

// SIGNAL 147
void NeovimQt::NeovimApi0::err_window_get_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 147, nullptr, _t1, _t2);
}

// SIGNAL 148
void NeovimQt::NeovimApi0::on_window_set_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 148, nullptr, _t1);
}

// SIGNAL 149
void NeovimQt::NeovimApi0::err_window_set_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 149, nullptr, _t1, _t2);
}

// SIGNAL 150
void NeovimQt::NeovimApi0::on_window_del_var(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 150, nullptr, _t1);
}

// SIGNAL 151
void NeovimQt::NeovimApi0::err_window_del_var(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 151, nullptr, _t1, _t2);
}

// SIGNAL 152
void NeovimQt::NeovimApi0::on_window_get_option(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 152, nullptr, _t1);
}

// SIGNAL 153
void NeovimQt::NeovimApi0::err_window_get_option(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 153, nullptr, _t1, _t2);
}

// SIGNAL 154
void NeovimQt::NeovimApi0::on_window_set_option()
{
    QMetaObject::activate(this, &staticMetaObject, 154, nullptr);
}

// SIGNAL 155
void NeovimQt::NeovimApi0::err_window_set_option(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 155, nullptr, _t1, _t2);
}

// SIGNAL 156
void NeovimQt::NeovimApi0::on_window_get_position(QPoint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 156, nullptr, _t1);
}

// SIGNAL 157
void NeovimQt::NeovimApi0::err_window_get_position(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 157, nullptr, _t1, _t2);
}

// SIGNAL 158
void NeovimQt::NeovimApi0::on_window_get_tabpage(int64_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 158, nullptr, _t1);
}

// SIGNAL 159
void NeovimQt::NeovimApi0::err_window_get_tabpage(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 159, nullptr, _t1, _t2);
}

// SIGNAL 160
void NeovimQt::NeovimApi0::on_window_is_valid(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 160, nullptr, _t1);
}

// SIGNAL 161
void NeovimQt::NeovimApi0::err_window_is_valid(const QString & _t1, const QVariant & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 161, nullptr, _t1, _t2);
}
QT_WARNING_POP
