/****************************************************************************
** Meta object code from reading C++ file 'neovimapi0.h'
**
** Created by: The Qt Meta Object Compiler version 68 (Qt 6.8.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 != 68
#error "This file was generated using the moc from 6.8.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


#ifdef QT_MOC_HAS_STRINGDATA
static constexpr auto qt_meta_stringdata_ZN8NeovimQt10NeovimApi0E = QtMocHelpers::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",
    "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",
    "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"
);
#else  // !QT_MOC_HAS_STRINGDATA
#error "qtmochelpers.h not found or too old."
#endif // !QT_MOC_HAS_STRINGDATA

Q_CONSTINIT static const uint qt_meta_data_ZN8NeovimQt10NeovimApi0E[] = {

 // content:
      12,       // revision
       0,       // classname
       0,    0, // classinfo
     244,   14, // methods
       0,    0, // properties
       1, 2432, // enums/sets
       0,    0, // constructors
       0,       // flags
     162,       // signalCount

 // signals: name, argc, parameters, tag, flags, initial metatype offsets
       1,    2, 1478,    2, 0x06,    2 /* Public */,
       6,    2, 1483,    2, 0x06,    5 /* Public */,
      10,    1, 1488,    2, 0x06,    8 /* Public */,
      12,    2, 1491,    2, 0x06,   10 /* Public */,
      13,    1, 1496,    2, 0x06,   13 /* Public */,
      14,    2, 1499,    2, 0x06,   15 /* Public */,
      15,    0, 1504,    2, 0x06,   18 /* Public */,
      16,    2, 1505,    2, 0x06,   19 /* Public */,
      17,    0, 1510,    2, 0x06,   22 /* Public */,
      18,    2, 1511,    2, 0x06,   23 /* Public */,
      19,    1, 1516,    2, 0x06,   26 /* Public */,
      20,    2, 1519,    2, 0x06,   28 /* Public */,
      21,    1, 1524,    2, 0x06,   31 /* Public */,
      22,    2, 1527,    2, 0x06,   33 /* Public */,
      23,    0, 1532,    2, 0x06,   36 /* Public */,
      24,    2, 1533,    2, 0x06,   37 /* Public */,
      25,    0, 1538,    2, 0x06,   40 /* Public */,
      26,    2, 1539,    2, 0x06,   41 /* Public */,
      27,    1, 1544,    2, 0x06,   44 /* Public */,
      28,    2, 1547,    2, 0x06,   46 /* Public */,
      29,    1, 1552,    2, 0x06,   49 /* Public */,
      30,    2, 1555,    2, 0x06,   51 /* Public */,
      31,    1, 1560,    2, 0x06,   54 /* Public */,
      32,    2, 1563,    2, 0x06,   56 /* Public */,
      33,    1, 1568,    2, 0x06,   59 /* Public */,
      34,    2, 1571,    2, 0x06,   61 /* Public */,
      35,    0, 1576,    2, 0x06,   64 /* Public */,
      36,    2, 1577,    2, 0x06,   65 /* Public */,
      37,    1, 1582,    2, 0x06,   68 /* Public */,
      38,    2, 1585,    2, 0x06,   70 /* Public */,
      39,    1, 1590,    2, 0x06,   73 /* Public */,
      40,    2, 1593,    2, 0x06,   75 /* Public */,
      41,    0, 1598,    2, 0x06,   78 /* Public */,
      42,    2, 1599,    2, 0x06,   79 /* Public */,
      43,    1, 1604,    2, 0x06,   82 /* Public */,
      44,    2, 1607,    2, 0x06,   84 /* Public */,
      45,    0, 1612,    2, 0x06,   87 /* Public */,
      46,    2, 1613,    2, 0x06,   88 /* Public */,
      47,    1, 1618,    2, 0x06,   91 /* Public */,
      48,    2, 1621,    2, 0x06,   93 /* Public */,
      49,    1, 1626,    2, 0x06,   96 /* Public */,
      50,    2, 1629,    2, 0x06,   98 /* Public */,
      51,    0, 1634,    2, 0x06,  101 /* Public */,
      52,    2, 1635,    2, 0x06,  102 /* Public */,
      53,    1, 1640,    2, 0x06,  105 /* Public */,
      55,    2, 1643,    2, 0x06,  107 /* Public */,
      56,    1, 1648,    2, 0x06,  110 /* Public */,
      57,    2, 1651,    2, 0x06,  112 /* Public */,
      58,    1, 1656,    2, 0x06,  115 /* Public */,
      59,    2, 1659,    2, 0x06,  117 /* Public */,
      60,    1, 1664,    2, 0x06,  120 /* Public */,
      61,    2, 1667,    2, 0x06,  122 /* Public */,
      62,    1, 1672,    2, 0x06,  125 /* Public */,
      63,    2, 1675,    2, 0x06,  127 /* Public */,
      64,    1, 1680,    2, 0x06,  130 /* Public */,
      65,    2, 1683,    2, 0x06,  132 /* Public */,
      66,    0, 1688,    2, 0x06,  135 /* Public */,
      67,    2, 1689,    2, 0x06,  136 /* Public */,
      68,    0, 1694,    2, 0x06,  139 /* Public */,
      69,    2, 1695,    2, 0x06,  140 /* Public */,
      70,    1, 1700,    2, 0x06,  143 /* Public */,
      71,    2, 1703,    2, 0x06,  145 /* Public */,
      72,    0, 1708,    2, 0x06,  148 /* Public */,
      73,    2, 1709,    2, 0x06,  149 /* Public */,
      74,    0, 1714,    2, 0x06,  152 /* Public */,
      75,    2, 1715,    2, 0x06,  153 /* Public */,
      76,    1, 1720,    2, 0x06,  156 /* Public */,
      77,    2, 1723,    2, 0x06,  158 /* Public */,
      78,    1, 1728,    2, 0x06,  161 /* Public */,
      79,    2, 1731,    2, 0x06,  163 /* Public */,
      80,    1, 1736,    2, 0x06,  166 /* Public */,
      81,    2, 1739,    2, 0x06,  168 /* Public */,
      82,    1, 1744,    2, 0x06,  171 /* Public */,
      83,    2, 1747,    2, 0x06,  173 /* Public */,
      84,    1, 1752,    2, 0x06,  176 /* Public */,
      85,    2, 1755,    2, 0x06,  178 /* Public */,
      86,    1, 1760,    2, 0x06,  181 /* Public */,
      87,    2, 1763,    2, 0x06,  183 /* Public */,
      88,    1, 1768,    2, 0x06,  186 /* Public */,
      89,    2, 1771,    2, 0x06,  188 /* Public */,
      90,    0, 1776,    2, 0x06,  191 /* Public */,
      91,    2, 1777,    2, 0x06,  192 /* Public */,
      92,    1, 1782,    2, 0x06,  195 /* Public */,
      93,    2, 1785,    2, 0x06,  197 /* Public */,
      94,    0, 1790,    2, 0x06,  200 /* Public */,
      95,    2, 1791,    2, 0x06,  201 /* Public */,
      96,    0, 1796,    2, 0x06,  204 /* Public */,
      97,    2, 1797,    2, 0x06,  205 /* Public */,
      98,    1, 1802,    2, 0x06,  208 /* Public */,
      99,    2, 1805,    2, 0x06,  210 /* Public */,
     100,    1, 1810,    2, 0x06,  213 /* Public */,
     101,    2, 1813,    2, 0x06,  215 /* Public */,
     102,    1, 1818,    2, 0x06,  218 /* Public */,
     103,    2, 1821,    2, 0x06,  220 /* Public */,
     104,    1, 1826,    2, 0x06,  223 /* Public */,
     105,    2, 1829,    2, 0x06,  225 /* Public */,
     106,    1, 1834,    2, 0x06,  228 /* Public */,
     107,    2, 1837,    2, 0x06,  230 /* Public */,
     108,    0, 1842,    2, 0x06,  233 /* Public */,
     109,    2, 1843,    2, 0x06,  234 /* Public */,
     110,    0, 1848,    2, 0x06,  237 /* Public */,
     111,    2, 1849,    2, 0x06,  238 /* Public */,
     112,    0, 1854,    2, 0x06,  241 /* Public */,
     113,    2, 1855,    2, 0x06,  242 /* Public */,
     114,    0, 1860,    2, 0x06,  245 /* Public */,
     115,    2, 1861,    2, 0x06,  246 /* Public */,
     116,    1, 1866,    2, 0x06,  249 /* Public */,
     117,    2, 1869,    2, 0x06,  251 /* Public */,
     118,    1, 1874,    2, 0x06,  254 /* Public */,
     119,    2, 1877,    2, 0x06,  256 /* Public */,
     120,    0, 1882,    2, 0x06,  259 /* Public */,
     121,    2, 1883,    2, 0x06,  260 /* Public */,
     122,    1, 1888,    2, 0x06,  263 /* Public */,
     123,    2, 1891,    2, 0x06,  265 /* Public */,
     124,    1, 1896,    2, 0x06,  268 /* Public */,
     125,    2, 1899,    2, 0x06,  270 /* Public */,
     126,    0, 1904,    2, 0x06,  273 /* Public */,
     127,    2, 1905,    2, 0x06,  274 /* Public */,
     128,    1, 1910,    2, 0x06,  277 /* Public */,
     129,    2, 1913,    2, 0x06,  279 /* Public */,
     130,    1, 1918,    2, 0x06,  282 /* Public */,
     131,    2, 1921,    2, 0x06,  284 /* Public */,
     132,    0, 1926,    2, 0x06,  287 /* Public */,
     133,    2, 1927,    2, 0x06,  288 /* Public */,
     134,    0, 1932,    2, 0x06,  291 /* Public */,
     135,    2, 1933,    2, 0x06,  292 /* Public */,
     136,    0, 1938,    2, 0x06,  295 /* Public */,
     137,    2, 1939,    2, 0x06,  296 /* Public */,
     138,    1, 1944,    2, 0x06,  299 /* Public */,
     139,    2, 1947,    2, 0x06,  301 /* Public */,
     140,    1, 1952,    2, 0x06,  304 /* Public */,
     142,    2, 1955,    2, 0x06,  306 /* Public */,
     143,    1, 1960,    2, 0x06,  309 /* Public */,
     144,    2, 1963,    2, 0x06,  311 /* Public */,
     145,    1, 1968,    2, 0x06,  314 /* Public */,
     146,    2, 1971,    2, 0x06,  316 /* Public */,
     147,    0, 1976,    2, 0x06,  319 /* Public */,
     148,    2, 1977,    2, 0x06,  320 /* Public */,
     149,    1, 1982,    2, 0x06,  323 /* Public */,
     150,    2, 1985,    2, 0x06,  325 /* Public */,
     151,    0, 1990,    2, 0x06,  328 /* Public */,
     152,    2, 1991,    2, 0x06,  329 /* Public */,
     153,    1, 1996,    2, 0x06,  332 /* Public */,
     154,    2, 1999,    2, 0x06,  334 /* Public */,
     155,    0, 2004,    2, 0x06,  337 /* Public */,
     156,    2, 2005,    2, 0x06,  338 /* Public */,
     157,    1, 2010,    2, 0x06,  341 /* Public */,
     158,    2, 2013,    2, 0x06,  343 /* Public */,
     159,    1, 2018,    2, 0x06,  346 /* Public */,
     160,    2, 2021,    2, 0x06,  348 /* Public */,
     161,    1, 2026,    2, 0x06,  351 /* Public */,
     162,    2, 2029,    2, 0x06,  353 /* Public */,
     163,    1, 2034,    2, 0x06,  356 /* Public */,
     164,    2, 2037,    2, 0x06,  358 /* Public */,
     165,    0, 2042,    2, 0x06,  361 /* Public */,
     166,    2, 2043,    2, 0x06,  362 /* Public */,
     167,    1, 2048,    2, 0x06,  365 /* Public */,
     168,    2, 2051,    2, 0x06,  367 /* Public */,
     169,    1, 2056,    2, 0x06,  370 /* Public */,
     170,    2, 2059,    2, 0x06,  372 /* Public */,
     171,    1, 2064,    2, 0x06,  375 /* Public */,
     172,    2, 2067,    2, 0x06,  377 /* Public */,

 // slots: name, argc, parameters, tag, flags, initial metatype offsets
     173,    3, 2072,    2, 0x09,  380 /* Protected */,
     176,    3, 2079,    2, 0x09,  384 /* Protected */,
     177,    1, 2086,    2, 0x0a,  388 /* Public */,
     180,    2, 2089,    2, 0x0a,  390 /* Public */,
     182,    3, 2094,    2, 0x0a,  393 /* Public */,
     184,    2, 2101,    2, 0x0a,  397 /* Public */,
     185,    5, 2106,    2, 0x0a,  400 /* Public */,
     190,    4, 2117,    2, 0x0a,  406 /* Public */,
     192,    6, 2126,    2, 0x0a,  411 /* Public */,
     194,    5, 2139,    2, 0x0a,  418 /* Public */,
     195,    2, 2150,    2, 0x0a,  424 /* Public */,
     196,    3, 2155,    2, 0x0a,  427 /* Public */,
     198,    2, 2162,    2, 0x0a,  431 /* Public */,
     199,    2, 2167,    2, 0x0a,  434 /* Public */,
     200,    3, 2172,    2, 0x0a,  437 /* Public */,
     201,    1, 2179,    2, 0x0a,  441 /* Public */,
     202,    1, 2182,    2, 0x0a,  443 /* Public */,
     203,    2, 2185,    2, 0x0a,  445 /* Public */,
     204,    1, 2190,    2, 0x0a,  448 /* Public */,
     205,    3, 2193,    2, 0x0a,  450 /* Public */,
     208,    2, 2200,    2, 0x0a,  454 /* Public */,
     209,    6, 2205,    2, 0x0a,  457 /* Public */,
     214,    4, 2218,    2, 0x0a,  464 /* Public */,
     217,    1, 2227,    2, 0x0a,  469 /* Public */,
     219,    2, 2230,    2, 0x0a,  471 /* Public */,
     220,    3, 2235,    2, 0x0a,  474 /* Public */,
     221,    2, 2242,    2, 0x0a,  478 /* Public */,
     222,    1, 2247,    2, 0x0a,  481 /* Public */,
     223,    1, 2250,    2, 0x0a,  483 /* Public */,
     224,    3, 2253,    2, 0x0a,  485 /* Public */,
     228,    0, 2260,    2, 0x0a,  489 /* Public */,
     229,    2, 2261,    2, 0x0a,  490 /* Public */,
     230,    1, 2266,    2, 0x0a,  493 /* Public */,
     232,    3, 2269,    2, 0x0a,  495 /* Public */,
     236,    1, 2276,    2, 0x0a,  499 /* Public */,
     237,    4, 2279,    2, 0x0a,  501 /* Public */,
     241,    1, 2288,    2, 0x0a,  506 /* Public */,
     242,    1, 2291,    2, 0x0a,  508 /* Public */,
     243,    2, 2294,    2, 0x0a,  510 /* Public */,
     245,    1, 2299,    2, 0x0a,  513 /* Public */,
     246,    0, 2302,    2, 0x0a,  515 /* Public */,
     247,    1, 2303,    2, 0x0a,  516 /* Public */,
     249,    0, 2306,    2, 0x0a,  518 /* Public */,
     250,    1, 2307,    2, 0x0a,  519 /* Public */,
     251,    0, 2310,    2, 0x0a,  521 /* Public */,
     252,    1, 2311,    2, 0x0a,  522 /* Public */,
     253,    2, 2314,    2, 0x0a,  524 /* Public */,
     254,    1, 2319,    2, 0x0a,  527 /* Public */,
     255,    1, 2322,    2, 0x0a,  529 /* Public */,
     256,    1, 2325,    2, 0x0a,  531 /* Public */,
     257,    2, 2328,    2, 0x0a,  533 /* Public */,
     258,    1, 2333,    2, 0x0a,  536 /* Public */,
     259,    1, 2336,    2, 0x0a,  538 /* Public */,
     260,    1, 2339,    2, 0x0a,  540 /* Public */,
     261,    0, 2342,    2, 0x0a,  542 /* Public */,
     262,    0, 2343,    2, 0x0a,  543 /* Public */,
     263,    1, 2344,    2, 0x0a,  544 /* Public */,
     264,    0, 2347,    2, 0x0a,  546 /* Public */,
     265,    0, 2348,    2, 0x0a,  547 /* Public */,
     266,    1, 2349,    2, 0x0a,  548 /* Public */,
     268,    0, 2352,    2, 0x0a,  550 /* Public */,
     269,    0, 2353,    2, 0x0a,  551 /* Public */,
     270,    1, 2354,    2, 0x0a,  552 /* Public */,
     271,    1, 2357,    2, 0x0a,  554 /* Public */,
     273,    1, 2360,    2, 0x0a,  556 /* Public */,
     274,    1, 2363,    2, 0x0a,  558 /* Public */,
     275,    0, 2366,    2, 0x0a,  560 /* Public */,
     276,    1, 2367,    2, 0x0a,  561 /* Public */,
     277,    1, 2370,    2, 0x0a,  563 /* Public */,
     278,    2, 2373,    2, 0x0a,  565 /* Public */,
     280,    1, 2378,    2, 0x0a,  568 /* Public */,
     281,    2, 2381,    2, 0x0a,  570 /* Public */,
     282,    1, 2386,    2, 0x0a,  573 /* Public */,
     283,    2, 2389,    2, 0x0a,  575 /* Public */,
     284,    2, 2394,    2, 0x0a,  578 /* Public */,
     285,    3, 2399,    2, 0x0a,  581 /* Public */,
     286,    2, 2406,    2, 0x0a,  585 /* Public */,
     287,    2, 2411,    2, 0x0a,  588 /* Public */,
     288,    3, 2416,    2, 0x0a,  591 /* Public */,
     289,    1, 2423,    2, 0x0a,  595 /* Public */,
     290,    1, 2426,    2, 0x0a,  597 /* Public */,
     291,    1, 2429,    2, 0x0a,  599 /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    3,    5,
    QMetaType::Void, QMetaType::QByteArray, 0x80000000 | 8,    7,    9,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArray,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArrayList,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArrayList,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArray,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QPoint,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 54,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArray,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArray,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArrayList,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QByteArray,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 54,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 54,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 54,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 141,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QPoint,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 4,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::QPoint,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, 0x80000000 | 11,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 4,    2,    2,

 // slots: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::ULongLong, 0x80000000 | 4,  174,  175,    2,
    QMetaType::Void, QMetaType::UInt, QMetaType::ULongLong, 0x80000000 | 4,  174,  175,    2,
    0x80000000 | 178, 0x80000000 | 11,  179,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11,  179,  181,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, QMetaType::QByteArray,  179,  181,  183,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11,  179,  181,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, 0x80000000 | 11, QMetaType::Bool, QMetaType::Bool,  179,  186,  187,  188,  189,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, 0x80000000 | 11, QMetaType::Bool,  179,  186,  187,  191,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, 0x80000000 | 11, QMetaType::Bool, QMetaType::Bool, QMetaType::QByteArrayList,  179,  186,  187,  188,  189,  193,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, 0x80000000 | 11, QMetaType::Bool, QMetaType::QByteArrayList,  179,  186,  187,  191,  193,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  179,    7,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray, 0x80000000 | 4,  179,    7,  197,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  179,    7,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  179,    7,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray, 0x80000000 | 4,  179,    7,  197,
    0x80000000 | 178, 0x80000000 | 11,  179,
    0x80000000 | 178, 0x80000000 | 11,  179,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  179,    7,
    0x80000000 | 178, 0x80000000 | 11,  179,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, QMetaType::QByteArrayList,  179,  206,  207,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  179,    7,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, QMetaType::QByteArray, 0x80000000 | 11, 0x80000000 | 11, 0x80000000 | 11,  179,  210,  211,  183,  212,  213,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, 0x80000000 | 11, 0x80000000 | 11,  179,  210,  215,  216,
    0x80000000 | 178, 0x80000000 | 11,  218,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  218,    7,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray, 0x80000000 | 4,  218,    7,  197,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  218,    7,
    0x80000000 | 178, 0x80000000 | 11,  218,
    0x80000000 | 178, 0x80000000 | 11,  218,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11, QMetaType::Bool,  225,  226,  227,
    0x80000000 | 178,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11,  225,  226,
    0x80000000 | 178, QMetaType::QByteArray,  231,
    0x80000000 | 178, QMetaType::QByteArray, QMetaType::QByteArray, QMetaType::Bool,  233,  234,  235,
    0x80000000 | 178, QMetaType::QByteArray,  233,
    0x80000000 | 178, QMetaType::QByteArray, QMetaType::Bool, QMetaType::Bool, QMetaType::Bool,  231,  238,  239,  240,
    0x80000000 | 178, QMetaType::QByteArray,  231,
    0x80000000 | 178, QMetaType::QByteArray,  231,
    0x80000000 | 178, QMetaType::QByteArray, 0x80000000 | 8,  244,    9,
    0x80000000 | 178, QMetaType::QByteArray,  231,
    0x80000000 | 178,
    0x80000000 | 178, QMetaType::QByteArray,  248,
    0x80000000 | 178,
    0x80000000 | 178, QMetaType::QByteArray,  183,
    0x80000000 | 178,
    0x80000000 | 178, QMetaType::QByteArray,    7,
    0x80000000 | 178, QMetaType::QByteArray, 0x80000000 | 4,    7,  197,
    0x80000000 | 178, QMetaType::QByteArray,    7,
    0x80000000 | 178, QMetaType::QByteArray,    7,
    0x80000000 | 178, QMetaType::QByteArray,    7,
    0x80000000 | 178, QMetaType::QByteArray, 0x80000000 | 4,    7,  197,
    0x80000000 | 178, QMetaType::QByteArray,  231,
    0x80000000 | 178, QMetaType::QByteArray,  231,
    0x80000000 | 178, QMetaType::QByteArray,  231,
    0x80000000 | 178,
    0x80000000 | 178,
    0x80000000 | 178, 0x80000000 | 11,  179,
    0x80000000 | 178,
    0x80000000 | 178,
    0x80000000 | 178, 0x80000000 | 11,  267,
    0x80000000 | 178,
    0x80000000 | 178,
    0x80000000 | 178, 0x80000000 | 11,  218,
    0x80000000 | 178, QMetaType::QByteArray,  272,
    0x80000000 | 178, QMetaType::QByteArray,  272,
    0x80000000 | 178, QMetaType::QByteArray,    7,
    0x80000000 | 178,
    0x80000000 | 178, 0x80000000 | 11,  267,
    0x80000000 | 178, 0x80000000 | 11,  267,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QPoint,  267,  279,
    0x80000000 | 178, 0x80000000 | 11,  267,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11,  267,  226,
    0x80000000 | 178, 0x80000000 | 11,  267,
    0x80000000 | 178, 0x80000000 | 11, 0x80000000 | 11,  267,  225,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  267,    7,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray, 0x80000000 | 4,  267,    7,  197,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  267,    7,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray,  267,    7,
    0x80000000 | 178, 0x80000000 | 11, QMetaType::QByteArray, 0x80000000 | 4,  267,    7,  197,
    0x80000000 | 178, 0x80000000 | 11,  267,
    0x80000000 | 178, 0x80000000 | 11,  267,
    0x80000000 | 178, 0x80000000 | 11,  267,

 // enums: name, alias, flags, count, data
     292,  292, 0x0,   81, 2437,

 // enum data: key, value
     293, uint(NeovimQt::NeovimApi0::NEOVIM_FN_NULL),
     294, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_LINE_COUNT),
     295, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_LINE),
     296, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_SET_LINE),
     297, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_DEL_LINE),
     298, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_LINE_SLICE),
     299, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_LINES),
     300, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_SET_LINE_SLICE),
     301, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_SET_LINES),
     302, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_VAR),
     303, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_SET_VAR),
     304, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_DEL_VAR),
     305, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_OPTION),
     306, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_SET_OPTION),
     307, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_NUMBER),
     308, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_NAME),
     309, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_SET_NAME),
     310, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_IS_VALID),
     311, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_INSERT),
     312, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_GET_MARK),
     313, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_ADD_HIGHLIGHT),
     314, uint(NeovimQt::NeovimApi0::NEOVIM_FN_BUFFER_CLEAR_HIGHLIGHT),
     315, uint(NeovimQt::NeovimApi0::NEOVIM_FN_TABPAGE_GET_WINDOWS),
     316, uint(NeovimQt::NeovimApi0::NEOVIM_FN_TABPAGE_GET_VAR),
     317, uint(NeovimQt::NeovimApi0::NEOVIM_FN_TABPAGE_SET_VAR),
     318, uint(NeovimQt::NeovimApi0::NEOVIM_FN_TABPAGE_DEL_VAR),
     319, uint(NeovimQt::NeovimApi0::NEOVIM_FN_TABPAGE_GET_WINDOW),
     320, uint(NeovimQt::NeovimApi0::NEOVIM_FN_TABPAGE_IS_VALID),
     321, uint(NeovimQt::NeovimApi0::NEOVIM_FN_UI_ATTACH),
     322, uint(NeovimQt::NeovimApi0::NEOVIM_FN_UI_DETACH),
     323, uint(NeovimQt::NeovimApi0::NEOVIM_FN_UI_TRY_RESIZE),
     324, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_COMMAND),
     325, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_FEEDKEYS),
     326, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_INPUT),
     327, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_REPLACE_TERMCODES),
     328, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_COMMAND_OUTPUT),
     329, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_EVAL),
     330, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_CALL_FUNCTION),
     331, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_STRWIDTH),
     332, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_LIST_RUNTIME_PATHS),
     333, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_CHANGE_DIRECTORY),
     334, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_CURRENT_LINE),
     335, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_SET_CURRENT_LINE),
     336, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_DEL_CURRENT_LINE),
     337, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_VAR),
     338, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_SET_VAR),
     339, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_DEL_VAR),
     340, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_VVAR),
     341, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_OPTION),
     342, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_SET_OPTION),
     343, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_OUT_WRITE),
     344, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_ERR_WRITE),
     345, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_REPORT_ERROR),
     346, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_BUFFERS),
     347, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_CURRENT_BUFFER),
     348, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_SET_CURRENT_BUFFER),
     349, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_WINDOWS),
     350, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_CURRENT_WINDOW),
     351, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_SET_CURRENT_WINDOW),
     352, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_TABPAGES),
     353, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_CURRENT_TABPAGE),
     354, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_SET_CURRENT_TABPAGE),
     355, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_SUBSCRIBE),
     356, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_UNSUBSCRIBE),
     357, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_NAME_TO_COLOR),
     358, uint(NeovimQt::NeovimApi0::NEOVIM_FN_VIM_GET_COLOR_MAP),
     359, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_BUFFER),
     360, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_CURSOR),
     361, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_SET_CURSOR),
     362, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_HEIGHT),
     363, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_SET_HEIGHT),
     364, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_WIDTH),
     365, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_SET_WIDTH),
     366, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_VAR),
     367, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_SET_VAR),
     368, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_DEL_VAR),
     369, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_OPTION),
     370, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_SET_OPTION),
     371, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_POSITION),
     372, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_GET_TABPAGE),
     373, uint(NeovimQt::NeovimApi0::NEOVIM_FN_WINDOW_IS_VALID),

       0        // eod
};

Q_CONSTINIT const QMetaObject NeovimQt::NeovimApi0::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_meta_stringdata_ZN8NeovimQt10NeovimApi0E.offsetsAndSizes,
    qt_meta_data_ZN8NeovimQt10NeovimApi0E,
    qt_static_metacall,
    nullptr,
    qt_incomplete_metaTypeArray<qt_meta_tag_ZN8NeovimQt10NeovimApi0E_t,
        // enum 'FunctionId'
        QtPrivate::TypeAndForceComplete<NeovimApi0::FunctionId, std::true_type>,
        // Q_OBJECT / Q_GADGET
        QtPrivate::TypeAndForceComplete<NeovimApi0, std::true_type>,
        // method 'error'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'neovimNotification'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QByteArray &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariantList &, std::false_type>,
        // method 'on_buffer_line_count'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_buffer_line_count'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'err_buffer_get_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_set_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_set_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_del_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_del_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_line_slice'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<QByteArray>, std::false_type>,
        // method 'err_buffer_get_line_slice'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_lines'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<QByteArray>, std::false_type>,
        // method 'err_buffer_get_lines'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_set_line_slice'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_set_line_slice'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_set_lines'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_set_lines'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_buffer_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_buffer_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_buffer_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_buffer_get_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_set_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_set_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_number'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_buffer_get_number'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_name'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'err_buffer_get_name'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_set_name'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_set_name'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_is_valid'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'err_buffer_is_valid'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_insert'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_insert'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_get_mark'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QPoint, std::false_type>,
        // method 'err_buffer_get_mark'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_add_highlight'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_buffer_add_highlight'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_buffer_clear_highlight'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_buffer_clear_highlight'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_tabpage_get_windows'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<int64_t>, std::false_type>,
        // method 'err_tabpage_get_windows'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_tabpage_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_tabpage_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_tabpage_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_tabpage_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_tabpage_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_tabpage_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_tabpage_get_window'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_tabpage_get_window'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_tabpage_is_valid'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'err_tabpage_is_valid'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_ui_attach'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_ui_attach'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_ui_detach'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_ui_detach'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_ui_try_resize'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_ui_try_resize'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_command'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_command'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_feedkeys'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_feedkeys'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_input'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_vim_input'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_replace_termcodes'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'err_vim_replace_termcodes'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_command_output'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'err_vim_command_output'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_eval'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_vim_eval'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_call_function'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_vim_call_function'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_strwidth'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_vim_strwidth'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_list_runtime_paths'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<QByteArray>, std::false_type>,
        // method 'err_vim_list_runtime_paths'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_change_directory'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_change_directory'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_current_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'err_vim_get_current_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_set_current_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_set_current_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_del_current_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_del_current_line'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_vim_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_vim_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_vim_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_vvar'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_vim_get_vvar'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_vim_get_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_set_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_set_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_out_write'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_out_write'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_err_write'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_err_write'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_report_error'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_report_error'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_buffers'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<int64_t>, std::false_type>,
        // method 'err_vim_get_buffers'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_current_buffer'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_vim_get_current_buffer'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_set_current_buffer'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_set_current_buffer'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_windows'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<int64_t>, std::false_type>,
        // method 'err_vim_get_windows'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_current_window'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_vim_get_current_window'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_set_current_window'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_set_current_window'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_tabpages'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<int64_t>, std::false_type>,
        // method 'err_vim_get_tabpages'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_current_tabpage'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_vim_get_current_tabpage'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_set_current_tabpage'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_set_current_tabpage'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_subscribe'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_subscribe'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_unsubscribe'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_vim_unsubscribe'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_name_to_color'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_vim_name_to_color'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_vim_get_color_map'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariantMap, std::false_type>,
        // method 'err_vim_get_color_map'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_buffer'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_window_get_buffer'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_cursor'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QPoint, std::false_type>,
        // method 'err_window_get_cursor'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_set_cursor'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_window_set_cursor'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_height'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_window_get_height'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_set_height'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_window_set_height'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_width'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_window_get_width'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_set_width'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_window_set_width'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_window_get_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_window_set_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_window_del_var'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'err_window_get_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_set_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        // method 'err_window_set_option'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_position'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<QPoint, std::false_type>,
        // method 'err_window_get_position'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_get_tabpage'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'err_window_get_tabpage'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'on_window_is_valid'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'err_window_is_valid'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QString &, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'handleResponse'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<quint32, std::false_type>,
        QtPrivate::TypeAndForceComplete<quint64, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'handleResponseError'
        QtPrivate::TypeAndForceComplete<void, std::false_type>,
        QtPrivate::TypeAndForceComplete<quint32, std::false_type>,
        QtPrivate::TypeAndForceComplete<quint64, std::false_type>,
        QtPrivate::TypeAndForceComplete<const QVariant &, std::false_type>,
        // method 'buffer_line_count'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'buffer_get_line'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'buffer_set_line'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'buffer_del_line'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'buffer_get_line_slice'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'buffer_get_lines'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'buffer_set_line_slice'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<QByteArray>, std::false_type>,
        // method 'buffer_set_lines'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<QByteArray>, std::false_type>,
        // method 'buffer_get_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'buffer_set_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'buffer_del_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'buffer_get_option'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'buffer_set_option'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'buffer_get_number'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'buffer_get_name'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'buffer_set_name'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'buffer_is_valid'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'buffer_insert'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QList<QByteArray>, std::false_type>,
        // method 'buffer_get_mark'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'buffer_add_highlight'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'buffer_clear_highlight'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'tabpage_get_windows'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'tabpage_get_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'tabpage_set_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'tabpage_del_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'tabpage_get_window'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'tabpage_is_valid'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'ui_attach'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'ui_detach'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'ui_try_resize'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'vim_command'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_feedkeys'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'vim_input'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_replace_termcodes'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        QtPrivate::TypeAndForceComplete<bool, std::false_type>,
        // method 'vim_command_output'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_eval'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_call_function'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariantList, std::false_type>,
        // method 'vim_strwidth'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_list_runtime_paths'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_change_directory'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_get_current_line'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_set_current_line'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_del_current_line'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_get_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_set_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'vim_del_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_get_vvar'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_get_option'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_set_option'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'vim_out_write'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_err_write'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_report_error'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_get_buffers'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_get_current_buffer'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_set_current_buffer'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'vim_get_windows'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_get_current_window'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_set_current_window'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'vim_get_tabpages'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_get_current_tabpage'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'vim_set_current_tabpage'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'vim_subscribe'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_unsubscribe'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_name_to_color'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'vim_get_color_map'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        // method 'window_get_buffer'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_get_cursor'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_set_cursor'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QPoint, std::false_type>,
        // method 'window_get_height'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_set_height'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_get_width'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_set_width'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_get_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'window_set_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'window_del_var'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'window_get_option'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        // method 'window_set_option'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        QtPrivate::TypeAndForceComplete<QByteArray, std::false_type>,
        QtPrivate::TypeAndForceComplete<QVariant, std::false_type>,
        // method 'window_get_position'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_get_tabpage'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>,
        // method 'window_is_valid'
        QtPrivate::TypeAndForceComplete<NeovimQt::MsgpackRequest *, std::false_type>,
        QtPrivate::TypeAndForceComplete<int64_t, std::false_type>
    >,
    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::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::error; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 0;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QByteArray & , const QVariantList & );
            if (_q_method_type _q_method = &NeovimApi0::neovimNotification; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 1;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_line_count; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 2;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_line_count; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 3;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QByteArray );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 4;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 5;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_set_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 6;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_set_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 7;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_del_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 8;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_del_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 9;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QList<QByteArray> );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_line_slice; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 10;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_line_slice; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 11;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QList<QByteArray> );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_lines; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 12;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_lines; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 13;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_set_line_slice; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 14;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_set_line_slice; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 15;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_set_lines; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 16;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_set_lines; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 17;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 18;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 19;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 20;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 21;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 22;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 23;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 24;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 25;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_set_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 26;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_set_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 27;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_number; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 28;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_number; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 29;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QByteArray );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_name; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 30;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_name; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 31;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_set_name; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 32;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_set_name; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 33;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(bool );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_is_valid; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 34;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_is_valid; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 35;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_insert; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 36;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_insert; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 37;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QPoint );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_get_mark; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 38;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_get_mark; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 39;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_add_highlight; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 40;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_add_highlight; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 41;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_buffer_clear_highlight; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 42;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_buffer_clear_highlight; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 43;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QList<int64_t> );
            if (_q_method_type _q_method = &NeovimApi0::on_tabpage_get_windows; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 44;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_tabpage_get_windows; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 45;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_tabpage_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 46;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_tabpage_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 47;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_tabpage_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 48;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_tabpage_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 49;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_tabpage_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 50;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_tabpage_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 51;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_tabpage_get_window; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 52;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_tabpage_get_window; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 53;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(bool );
            if (_q_method_type _q_method = &NeovimApi0::on_tabpage_is_valid; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 54;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_tabpage_is_valid; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 55;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_ui_attach; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 56;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_ui_attach; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 57;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_ui_detach; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 58;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_ui_detach; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 59;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_ui_try_resize; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 60;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_ui_try_resize; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 61;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_command; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 62;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_command; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 63;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_feedkeys; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 64;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_feedkeys; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 65;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_input; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 66;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_input; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 67;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QByteArray );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_replace_termcodes; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 68;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_replace_termcodes; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 69;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QByteArray );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_command_output; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 70;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_command_output; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 71;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_eval; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 72;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_eval; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 73;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_call_function; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 74;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_call_function; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 75;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_strwidth; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 76;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_strwidth; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 77;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QList<QByteArray> );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_list_runtime_paths; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 78;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_list_runtime_paths; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 79;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_change_directory; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 80;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_change_directory; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 81;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QByteArray );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_current_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 82;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_current_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 83;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_set_current_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 84;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_set_current_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 85;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_del_current_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 86;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_del_current_line; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 87;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 88;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 89;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 90;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 91;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 92;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 93;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_vvar; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 94;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_vvar; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 95;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 96;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 97;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_set_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 98;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_set_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 99;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_out_write; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 100;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_out_write; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 101;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_err_write; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 102;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_err_write; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 103;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_report_error; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 104;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_report_error; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 105;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QList<int64_t> );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_buffers; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 106;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_buffers; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 107;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_current_buffer; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 108;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_current_buffer; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 109;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_set_current_buffer; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 110;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_set_current_buffer; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 111;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QList<int64_t> );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_windows; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 112;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_windows; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 113;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_current_window; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 114;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_current_window; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 115;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_set_current_window; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 116;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_set_current_window; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 117;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QList<int64_t> );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_tabpages; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 118;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_tabpages; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 119;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_current_tabpage; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 120;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_current_tabpage; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 121;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_set_current_tabpage; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 122;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_set_current_tabpage; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 123;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_subscribe; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 124;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_subscribe; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 125;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_vim_unsubscribe; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 126;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_unsubscribe; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 127;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_name_to_color; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 128;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_name_to_color; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 129;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariantMap );
            if (_q_method_type _q_method = &NeovimApi0::on_vim_get_color_map; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 130;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_vim_get_color_map; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 131;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_buffer; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 132;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_buffer; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 133;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QPoint );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_cursor; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 134;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_cursor; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 135;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_window_set_cursor; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 136;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_set_cursor; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 137;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_height; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 138;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_height; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 139;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_window_set_height; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 140;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_set_height; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 141;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_width; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 142;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_width; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 143;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_window_set_width; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 144;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_set_width; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 145;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 146;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 147;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_window_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 148;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_set_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 149;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_window_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 150;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_del_var; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 151;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QVariant );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 152;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 153;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)();
            if (_q_method_type _q_method = &NeovimApi0::on_window_set_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 154;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_set_option; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 155;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(QPoint );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_position; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 156;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_position; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 157;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(int64_t );
            if (_q_method_type _q_method = &NeovimApi0::on_window_get_tabpage; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 158;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_get_tabpage; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 159;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(bool );
            if (_q_method_type _q_method = &NeovimApi0::on_window_is_valid; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 160;
                return;
            }
        }
        {
            using _q_method_type = void (NeovimApi0::*)(const QString & , const QVariant & );
            if (_q_method_type _q_method = &NeovimApi0::err_window_is_valid; *reinterpret_cast<_q_method_type *>(_a[1]) == _q_method) {
                *result = 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_meta_stringdata_ZN8NeovimQt10NeovimApi0E.stringdata0))
        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)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 244;
    }
    return _id;
}

// SIGNAL 0
void NeovimQt::NeovimApi0::error(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void NeovimQt::NeovimApi0::neovimNotification(const QByteArray & _t1, const QVariantList & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void NeovimQt::NeovimApi0::on_buffer_line_count(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void NeovimQt::NeovimApi0::err_buffer_line_count(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void NeovimQt::NeovimApi0::on_buffer_get_line(QByteArray _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}

// SIGNAL 5
void NeovimQt::NeovimApi0::err_buffer_get_line(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 7, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 9, _a);
}

// SIGNAL 10
void NeovimQt::NeovimApi0::on_buffer_get_line_slice(QList<QByteArray> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 10, _a);
}

// SIGNAL 11
void NeovimQt::NeovimApi0::err_buffer_get_line_slice(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 11, _a);
}

// SIGNAL 12
void NeovimQt::NeovimApi0::on_buffer_get_lines(QList<QByteArray> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 12, _a);
}

// SIGNAL 13
void NeovimQt::NeovimApi0::err_buffer_get_lines(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 13, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 15, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 17, _a);
}

// SIGNAL 18
void NeovimQt::NeovimApi0::on_buffer_get_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 18, _a);
}

// SIGNAL 19
void NeovimQt::NeovimApi0::err_buffer_get_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 19, _a);
}

// SIGNAL 20
void NeovimQt::NeovimApi0::on_buffer_set_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 20, _a);
}

// SIGNAL 21
void NeovimQt::NeovimApi0::err_buffer_set_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 21, _a);
}

// SIGNAL 22
void NeovimQt::NeovimApi0::on_buffer_del_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 22, _a);
}

// SIGNAL 23
void NeovimQt::NeovimApi0::err_buffer_del_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 23, _a);
}

// SIGNAL 24
void NeovimQt::NeovimApi0::on_buffer_get_option(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 24, _a);
}

// SIGNAL 25
void NeovimQt::NeovimApi0::err_buffer_get_option(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 25, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 27, _a);
}

// SIGNAL 28
void NeovimQt::NeovimApi0::on_buffer_get_number(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 28, _a);
}

// SIGNAL 29
void NeovimQt::NeovimApi0::err_buffer_get_number(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 29, _a);
}

// SIGNAL 30
void NeovimQt::NeovimApi0::on_buffer_get_name(QByteArray _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 30, _a);
}

// SIGNAL 31
void NeovimQt::NeovimApi0::err_buffer_get_name(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 31, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 33, _a);
}

// SIGNAL 34
void NeovimQt::NeovimApi0::on_buffer_is_valid(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 34, _a);
}

// SIGNAL 35
void NeovimQt::NeovimApi0::err_buffer_is_valid(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 35, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 37, _a);
}

// SIGNAL 38
void NeovimQt::NeovimApi0::on_buffer_get_mark(QPoint _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 38, _a);
}

// SIGNAL 39
void NeovimQt::NeovimApi0::err_buffer_get_mark(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 39, _a);
}

// SIGNAL 40
void NeovimQt::NeovimApi0::on_buffer_add_highlight(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 40, _a);
}

// SIGNAL 41
void NeovimQt::NeovimApi0::err_buffer_add_highlight(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 41, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 43, _a);
}

// SIGNAL 44
void NeovimQt::NeovimApi0::on_tabpage_get_windows(QList<int64_t> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 44, _a);
}

// SIGNAL 45
void NeovimQt::NeovimApi0::err_tabpage_get_windows(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 45, _a);
}

// SIGNAL 46
void NeovimQt::NeovimApi0::on_tabpage_get_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 46, _a);
}

// SIGNAL 47
void NeovimQt::NeovimApi0::err_tabpage_get_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 47, _a);
}

// SIGNAL 48
void NeovimQt::NeovimApi0::on_tabpage_set_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 48, _a);
}

// SIGNAL 49
void NeovimQt::NeovimApi0::err_tabpage_set_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 49, _a);
}

// SIGNAL 50
void NeovimQt::NeovimApi0::on_tabpage_del_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 50, _a);
}

// SIGNAL 51
void NeovimQt::NeovimApi0::err_tabpage_del_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 51, _a);
}

// SIGNAL 52
void NeovimQt::NeovimApi0::on_tabpage_get_window(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 52, _a);
}

// SIGNAL 53
void NeovimQt::NeovimApi0::err_tabpage_get_window(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 53, _a);
}

// SIGNAL 54
void NeovimQt::NeovimApi0::on_tabpage_is_valid(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 54, _a);
}

// SIGNAL 55
void NeovimQt::NeovimApi0::err_tabpage_is_valid(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 55, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 57, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 59, _a);
}

// SIGNAL 60
void NeovimQt::NeovimApi0::on_ui_try_resize(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 60, _a);
}

// SIGNAL 61
void NeovimQt::NeovimApi0::err_ui_try_resize(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 61, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 63, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 65, _a);
}

// SIGNAL 66
void NeovimQt::NeovimApi0::on_vim_input(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 66, _a);
}

// SIGNAL 67
void NeovimQt::NeovimApi0::err_vim_input(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 67, _a);
}

// SIGNAL 68
void NeovimQt::NeovimApi0::on_vim_replace_termcodes(QByteArray _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 68, _a);
}

// SIGNAL 69
void NeovimQt::NeovimApi0::err_vim_replace_termcodes(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 69, _a);
}

// SIGNAL 70
void NeovimQt::NeovimApi0::on_vim_command_output(QByteArray _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 70, _a);
}

// SIGNAL 71
void NeovimQt::NeovimApi0::err_vim_command_output(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 71, _a);
}

// SIGNAL 72
void NeovimQt::NeovimApi0::on_vim_eval(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 72, _a);
}

// SIGNAL 73
void NeovimQt::NeovimApi0::err_vim_eval(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 73, _a);
}

// SIGNAL 74
void NeovimQt::NeovimApi0::on_vim_call_function(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 74, _a);
}

// SIGNAL 75
void NeovimQt::NeovimApi0::err_vim_call_function(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 75, _a);
}

// SIGNAL 76
void NeovimQt::NeovimApi0::on_vim_strwidth(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 76, _a);
}

// SIGNAL 77
void NeovimQt::NeovimApi0::err_vim_strwidth(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 77, _a);
}

// SIGNAL 78
void NeovimQt::NeovimApi0::on_vim_list_runtime_paths(QList<QByteArray> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 78, _a);
}

// SIGNAL 79
void NeovimQt::NeovimApi0::err_vim_list_runtime_paths(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 79, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 81, _a);
}

// SIGNAL 82
void NeovimQt::NeovimApi0::on_vim_get_current_line(QByteArray _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 82, _a);
}

// SIGNAL 83
void NeovimQt::NeovimApi0::err_vim_get_current_line(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 83, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 85, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 87, _a);
}

// SIGNAL 88
void NeovimQt::NeovimApi0::on_vim_get_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 88, _a);
}

// SIGNAL 89
void NeovimQt::NeovimApi0::err_vim_get_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 89, _a);
}

// SIGNAL 90
void NeovimQt::NeovimApi0::on_vim_set_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 90, _a);
}

// SIGNAL 91
void NeovimQt::NeovimApi0::err_vim_set_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 91, _a);
}

// SIGNAL 92
void NeovimQt::NeovimApi0::on_vim_del_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 92, _a);
}

// SIGNAL 93
void NeovimQt::NeovimApi0::err_vim_del_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 93, _a);
}

// SIGNAL 94
void NeovimQt::NeovimApi0::on_vim_get_vvar(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 94, _a);
}

// SIGNAL 95
void NeovimQt::NeovimApi0::err_vim_get_vvar(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 95, _a);
}

// SIGNAL 96
void NeovimQt::NeovimApi0::on_vim_get_option(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 96, _a);
}

// SIGNAL 97
void NeovimQt::NeovimApi0::err_vim_get_option(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 97, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 99, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 101, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 103, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 105, _a);
}

// SIGNAL 106
void NeovimQt::NeovimApi0::on_vim_get_buffers(QList<int64_t> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 106, _a);
}

// SIGNAL 107
void NeovimQt::NeovimApi0::err_vim_get_buffers(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 107, _a);
}

// SIGNAL 108
void NeovimQt::NeovimApi0::on_vim_get_current_buffer(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 108, _a);
}

// SIGNAL 109
void NeovimQt::NeovimApi0::err_vim_get_current_buffer(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 109, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 111, _a);
}

// SIGNAL 112
void NeovimQt::NeovimApi0::on_vim_get_windows(QList<int64_t> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 112, _a);
}

// SIGNAL 113
void NeovimQt::NeovimApi0::err_vim_get_windows(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 113, _a);
}

// SIGNAL 114
void NeovimQt::NeovimApi0::on_vim_get_current_window(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 114, _a);
}

// SIGNAL 115
void NeovimQt::NeovimApi0::err_vim_get_current_window(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 115, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 117, _a);
}

// SIGNAL 118
void NeovimQt::NeovimApi0::on_vim_get_tabpages(QList<int64_t> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 118, _a);
}

// SIGNAL 119
void NeovimQt::NeovimApi0::err_vim_get_tabpages(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 119, _a);
}

// SIGNAL 120
void NeovimQt::NeovimApi0::on_vim_get_current_tabpage(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 120, _a);
}

// SIGNAL 121
void NeovimQt::NeovimApi0::err_vim_get_current_tabpage(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 121, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 123, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 125, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 127, _a);
}

// SIGNAL 128
void NeovimQt::NeovimApi0::on_vim_name_to_color(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 128, _a);
}

// SIGNAL 129
void NeovimQt::NeovimApi0::err_vim_name_to_color(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 129, _a);
}

// SIGNAL 130
void NeovimQt::NeovimApi0::on_vim_get_color_map(QVariantMap _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 130, _a);
}

// SIGNAL 131
void NeovimQt::NeovimApi0::err_vim_get_color_map(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 131, _a);
}

// SIGNAL 132
void NeovimQt::NeovimApi0::on_window_get_buffer(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 132, _a);
}

// SIGNAL 133
void NeovimQt::NeovimApi0::err_window_get_buffer(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 133, _a);
}

// SIGNAL 134
void NeovimQt::NeovimApi0::on_window_get_cursor(QPoint _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 134, _a);
}

// SIGNAL 135
void NeovimQt::NeovimApi0::err_window_get_cursor(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 135, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 137, _a);
}

// SIGNAL 138
void NeovimQt::NeovimApi0::on_window_get_height(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 138, _a);
}

// SIGNAL 139
void NeovimQt::NeovimApi0::err_window_get_height(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 139, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 141, _a);
}

// SIGNAL 142
void NeovimQt::NeovimApi0::on_window_get_width(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 142, _a);
}

// SIGNAL 143
void NeovimQt::NeovimApi0::err_window_get_width(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 143, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 145, _a);
}

// SIGNAL 146
void NeovimQt::NeovimApi0::on_window_get_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 146, _a);
}

// SIGNAL 147
void NeovimQt::NeovimApi0::err_window_get_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 147, _a);
}

// SIGNAL 148
void NeovimQt::NeovimApi0::on_window_set_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 148, _a);
}

// SIGNAL 149
void NeovimQt::NeovimApi0::err_window_set_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 149, _a);
}

// SIGNAL 150
void NeovimQt::NeovimApi0::on_window_del_var(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 150, _a);
}

// SIGNAL 151
void NeovimQt::NeovimApi0::err_window_del_var(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 151, _a);
}

// SIGNAL 152
void NeovimQt::NeovimApi0::on_window_get_option(QVariant _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 152, _a);
}

// SIGNAL 153
void NeovimQt::NeovimApi0::err_window_get_option(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 153, _a);
}

// 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)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 155, _a);
}

// SIGNAL 156
void NeovimQt::NeovimApi0::on_window_get_position(QPoint _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 156, _a);
}

// SIGNAL 157
void NeovimQt::NeovimApi0::err_window_get_position(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 157, _a);
}

// SIGNAL 158
void NeovimQt::NeovimApi0::on_window_get_tabpage(int64_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 158, _a);
}

// SIGNAL 159
void NeovimQt::NeovimApi0::err_window_get_tabpage(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 159, _a);
}

// SIGNAL 160
void NeovimQt::NeovimApi0::on_window_is_valid(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 160, _a);
}

// SIGNAL 161
void NeovimQt::NeovimApi0::err_window_is_valid(const QString & _t1, const QVariant & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 161, _a);
}
QT_WARNING_POP
