Shiboken does not recognize call operator from XML

#pragma once

#include <QVector>
#include <QObject>

namespace bje::model {

struct ChannelConfigurationFunctor {
    static QString name() { return "channel.configure"; }
    void operator()(QVector<QObject*> const&) const;
};

}

<!-- Escape sequences replaced with normal chars for convenience. Actual XML uses escaped chars. -->
<object-type name="ChannelConfigurationFunctor">
    <modify-function signature="operator()(QVector<QObject*> const&)const" remove="all"/>
    <add-function signature="operator()(QVector<QObject*> const&)const">
        <inject-code file="glue/processors.cpp" snippet="generic-operatorcall"/>
    </add-function>
</object-type>

// @snippet generic-operatorcall
PyThreadState* _save = PyEval_SaveThread(); // Py_BEGIN_ALLOW_THREADS
const_cast<const ::bje::model::%CPPTYPE*>(%CPPSELF)->operator()(%1);
PyEval_RestoreThread(_save); // Py_END_ALLOW_THREADS
// @snippet generic-operatorcall

static PyObject* Sbk_bje_model_ChannelConfigurationFunctorFunc_operator(PyObject* self, PyObject* pyArg)
{
    ::bje::model::ChannelConfigurationFunctor* cppSelf = nullptr;
    SBK_UNUSED(cppSelf)
    if (!Shiboken::Object::isValid(self))
        return {};
    cppSelf = reinterpret_cast< ::bje::model::ChannelConfigurationFunctor *>(Shiboken::Conversions::cppPointer(SbkfreeathomeTypes[SBK_BJE_MODEL_CHANNELCONFIGURATIONFUNCTOR_IDX], reinterpret_cast<SbkObject *>(self)));
    int overloadId = -1;
    PythonToCppFunc pythonToCpp{};
    SBK_UNUSED(pythonToCpp)

    // Overloaded function decisor
    // 0: ChannelConfigurationFunctor::operator(QVector<QObject*>)const
    if ((pythonToCpp = Shiboken::Conversions::isPythonToCppConvertible(SbkfreeathomeTypeConverters[SBK_FREEATHOME_QVECTOR_QOBJECTPTR_IDX], (pyArg)))) {
        overloadId = 0; // operator(QVector<QObject*>)const
    }

    // Function signature not found.
    if (overloadId == -1) goto Sbk_bje_model_ChannelConfigurationFunctorFunc_operator_TypeError;

    // Call function/method
    {
        ::QVector<QObject* > cppArg0;
        pythonToCpp(pyArg, &cppArg0);
        SBK_UNUSED(cppArg0)

        if (!PyErr_Occurred()) {
            // operator(QVector<QObject*>)const
        }
    }

    if (PyErr_Occurred()) {
        return {};
    }
    Py_RETURN_NONE;

    Sbk_bje_model_ChannelConfigurationFunctorFunc_operator_TypeError:
        Shiboken::setErrorAboutWrongArguments(pyArg, "freeathome.bje.model.ChannelConfigurationFunctor.operator");
        return {};
}

static PyType_Slot Sbk_bje_model_ChannelConfigurationFunctor_slots[] = {
    {Py_tp_base,        nullptr}, // inserted by introduceWrapperType
    {Py_tp_dealloc,     reinterpret_cast<void*>(&SbkDeallocWrapper)},
    {Py_tp_repr,        nullptr},
    {Py_tp_hash,        nullptr},
    {Py_tp_call,        nullptr}, // <- this should reference the __call__ implementation
    {Py_tp_str,         nullptr},
    {Py_tp_getattro,    nullptr},
    {Py_tp_setattro,    nullptr},
    {Py_tp_traverse,    reinterpret_cast<void*>(Sbk_bje_model_ChannelConfigurationFunctor_traverse)},
    {Py_tp_clear,       reinterpret_cast<void*>(Sbk_bje_model_ChannelConfigurationFunctor_clear)},
    {Py_tp_richcompare, nullptr},
    {Py_tp_iter,        nullptr},
    {Py_tp_iternext,    nullptr},
    {Py_tp_methods,     reinterpret_cast<void*>(Sbk_bje_model_ChannelConfigurationFunctor_methods)},
    {Py_tp_getset,      nullptr},
    {Py_tp_init,        reinterpret_cast<void*>(Sbk_bje_model_ChannelConfigurationFunctor_Init)},
    {Py_tp_new,         reinterpret_cast<void*>(SbkObjectTpNew)},
    {0, nullptr}
};