
// default includes
#include <shiboken.h>
#ifndef QT_NO_VERSION_TAGGING
#  define QT_NO_VERSION_TAGGING
#endif
#include <QDebug>
#include <pysidesignal.h>
#include <pysideproperty.h>
#include <pyside.h>
#include <pysideqenum.h>
#include <feature_select.h>
QT_WARNING_DISABLE_DEPRECATED

#include <typeinfo>
#include <iterator>

// module include
#include "pyfalkon_python.h"

// main header
#include "qz_wrapper.h"

// inner classes

#include <cctype>
#include <cstring>



template <class T>
static const char *typeNameOf(const T &t)
{
    const char *typeName =  typeid(t).name();
    auto size = std::strlen(typeName);
#if defined(Q_CC_MSVC) // MSVC: "class QPaintDevice * __ptr64"
    if (auto lastStar = strchr(typeName, '*')) {
        // MSVC: "class QPaintDevice * __ptr64"
        while (*--lastStar == ' ') {
        }
        size = lastStar - typeName + 1;
    }
#else // g++, Clang: "QPaintDevice *" -> "P12QPaintDevice"
    if (size > 2 && typeName[0] == 'P' && std::isdigit(typeName[1])) {
        ++typeName;
        --size;
    }
#endif
    char *result = new char[size + 1];
    result[size] = '\0';
    memcpy(result, typeName, size);
    return result;
}


// Target ---------------------------------------------------------

extern "C" {

static const char *Sbk_Qz_PropertyStrings[] = {
    nullptr // Sentinel
};

static PyMethodDef Sbk_Qz_methods[] = {

    {nullptr, nullptr} // Sentinel
};

} // extern "C"

static int Sbk_Qz_traverse(PyObject *self, visitproc visit, void *arg)
{
    return reinterpret_cast<PyTypeObject *>(SbkObject_TypeF())->tp_traverse(self, visit, arg);
}
static int Sbk_Qz_clear(PyObject *self)
{
    return reinterpret_cast<PyTypeObject *>(SbkObject_TypeF())->tp_clear(self);
}
// Class Definition -----------------------------------------------
extern "C" {
static SbkObjectType *_Sbk_Qz_Type = nullptr;
static SbkObjectType *Sbk_Qz_TypeF(void)
{
    return _Sbk_Qz_Type;
}

static PyType_Slot Sbk_Qz_slots[] = {
    {Py_tp_base,        nullptr}, // inserted by introduceWrapperType
    {Py_tp_dealloc,     reinterpret_cast<void *>(Sbk_object_dealloc /* PYSIDE-832: Prevent replacement of "0" with subtype_dealloc. */)},
    {Py_tp_repr,        nullptr},
    {Py_tp_hash,        nullptr},
    {Py_tp_call,        nullptr},
    {Py_tp_str,         nullptr},
    {Py_tp_getattro,    nullptr},
    {Py_tp_setattro,    nullptr},
    {Py_tp_traverse,    reinterpret_cast<void *>(Sbk_Qz_traverse)},
    {Py_tp_clear,       reinterpret_cast<void *>(Sbk_Qz_clear)},
    {Py_tp_richcompare, nullptr},
    {Py_tp_iter,        nullptr},
    {Py_tp_iternext,    nullptr},
    {Py_tp_methods,     reinterpret_cast<void *>(Sbk_Qz_methods)},
    {Py_tp_getset,      nullptr},
    {Py_tp_init,        nullptr},
    {Py_tp_new,         reinterpret_cast<void *>(SbkDummyNew /* PYSIDE-595: Prevent replacement of "0" with base->tp_new. */)},
    {0, nullptr}
};
static PyType_Spec Sbk_Qz_spec = {
    "1:PyFalkon.Qz",
    sizeof(SbkObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_GC,
    Sbk_Qz_slots
};

} //extern "C"

PyObject *SbkPyFalkon_Qz_NewTabPositionFlag___and__(PyObject *self, PyObject *pyArg)
{
    ::Qz::NewTabPositionFlags cppResult, cppSelf, cppArg;
#ifdef IS_PY3K
    cppSelf = static_cast<::Qz::NewTabPositionFlags>(int(PyLong_AsLong(self)));
    cppArg = static_cast<Qz::NewTabPositionFlags>(int(PyLong_AsLong(pyArg)));
    if (PyErr_Occurred())
    return nullptr;
#else
    cppSelf = static_cast<::Qz::NewTabPositionFlags>(int(PyInt_AsLong(self)));
    cppArg = static_cast<Qz::NewTabPositionFlags>(int(PyInt_AsLong(pyArg)));
#endif

    if (PyErr_Occurred())
        return nullptr;
    cppResult = cppSelf & cppArg;
    return Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX])->converter, &cppResult);
}

PyObject *SbkPyFalkon_Qz_NewTabPositionFlag___or__(PyObject *self, PyObject *pyArg)
{
    ::Qz::NewTabPositionFlags cppResult, cppSelf, cppArg;
#ifdef IS_PY3K
    cppSelf = static_cast<::Qz::NewTabPositionFlags>(int(PyLong_AsLong(self)));
    cppArg = static_cast<Qz::NewTabPositionFlags>(int(PyLong_AsLong(pyArg)));
    if (PyErr_Occurred())
    return nullptr;
#else
    cppSelf = static_cast<::Qz::NewTabPositionFlags>(int(PyInt_AsLong(self)));
    cppArg = static_cast<Qz::NewTabPositionFlags>(int(PyInt_AsLong(pyArg)));
#endif

    if (PyErr_Occurred())
        return nullptr;
    cppResult = cppSelf | cppArg;
    return Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX])->converter, &cppResult);
}

PyObject *SbkPyFalkon_Qz_NewTabPositionFlag___xor__(PyObject *self, PyObject *pyArg)
{
    ::Qz::NewTabPositionFlags cppResult, cppSelf, cppArg;
#ifdef IS_PY3K
    cppSelf = static_cast<::Qz::NewTabPositionFlags>(int(PyLong_AsLong(self)));
    cppArg = static_cast<Qz::NewTabPositionFlags>(int(PyLong_AsLong(pyArg)));
    if (PyErr_Occurred())
    return nullptr;
#else
    cppSelf = static_cast<::Qz::NewTabPositionFlags>(int(PyInt_AsLong(self)));
    cppArg = static_cast<Qz::NewTabPositionFlags>(int(PyInt_AsLong(pyArg)));
#endif

    if (PyErr_Occurred())
        return nullptr;
    cppResult = cppSelf ^ cppArg;
    return Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX])->converter, &cppResult);
}

PyObject *SbkPyFalkon_Qz_NewTabPositionFlag___invert__(PyObject *self, PyObject *pyArg)
{
    ::Qz::NewTabPositionFlags cppSelf;
    Shiboken::Conversions::pythonToCppCopy(*PepType_SGTP(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX])->converter, self, &cppSelf);
    ::Qz::NewTabPositionFlags cppResult = ~cppSelf;
    return Shiboken::Conversions::copyToPython(*PepType_SGTP(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX])->converter, &cppResult);
}

static PyObject *SbkPyFalkon_Qz_NewTabPositionFlag_long(PyObject *self)
{
    int val;
    Shiboken::Conversions::pythonToCppCopy(*PepType_SGTP(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX])->converter, self, &val);
    return Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &val);
}
static int SbkPyFalkon_Qz_NewTabPositionFlag__nonzero(PyObject *self)
{
    int val;
    Shiboken::Conversions::pythonToCppCopy(*PepType_SGTP(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX])->converter, self, &val);
    return val != 0;
}

static PyType_Slot SbkPyFalkon_Qz_NewTabPositionFlag_number_slots[] = {
#ifdef IS_PY3K
    {Py_nb_bool,    reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag__nonzero)},
#else
    {Py_nb_nonzero, reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag__nonzero)},
    {Py_nb_long,    reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag_long)},
#endif
    {Py_nb_invert,  reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag___invert__)},
    {Py_nb_and,     reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag___and__)},
    {Py_nb_xor,     reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag___xor__)},
    {Py_nb_or,      reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag___or__)},
    {Py_nb_int,     reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag_long)},
    {Py_nb_index,   reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag_long)},
#ifndef IS_PY3K
    {Py_nb_long,    reinterpret_cast<void *>(SbkPyFalkon_Qz_NewTabPositionFlag_long)},
#endif
    {0, nullptr} // sentinel
};



// Type conversion functions.

// Python to C++ enum conversion.
static void Qz_BrowserWindowType_PythonToCpp_Qz_BrowserWindowType(PyObject *pyIn, void *cppOut) {
    *reinterpret_cast<::Qz::BrowserWindowType *>(cppOut) =
        static_cast<::Qz::BrowserWindowType>(Shiboken::Enum::getValue(pyIn));

}
static PythonToCppFunc is_Qz_BrowserWindowType_PythonToCpp_Qz_BrowserWindowType_Convertible(PyObject *pyIn) {
    if (PyObject_TypeCheck(pyIn, SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX]))
        return Qz_BrowserWindowType_PythonToCpp_Qz_BrowserWindowType;
    return {};
}
static PyObject *Qz_BrowserWindowType_CppToPython_Qz_BrowserWindowType(const void *cppIn) {
    const int castCppIn = int(*reinterpret_cast<const ::Qz::BrowserWindowType *>(cppIn));
    return Shiboken::Enum::newItem(SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX], castCppIn);

}

static void Qz_CommandLineAction_PythonToCpp_Qz_CommandLineAction(PyObject *pyIn, void *cppOut) {
    *reinterpret_cast<::Qz::CommandLineAction *>(cppOut) =
        static_cast<::Qz::CommandLineAction>(Shiboken::Enum::getValue(pyIn));

}
static PythonToCppFunc is_Qz_CommandLineAction_PythonToCpp_Qz_CommandLineAction_Convertible(PyObject *pyIn) {
    if (PyObject_TypeCheck(pyIn, SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX]))
        return Qz_CommandLineAction_PythonToCpp_Qz_CommandLineAction;
    return {};
}
static PyObject *Qz_CommandLineAction_CppToPython_Qz_CommandLineAction(const void *cppIn) {
    const int castCppIn = int(*reinterpret_cast<const ::Qz::CommandLineAction *>(cppIn));
    return Shiboken::Enum::newItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX], castCppIn);

}

static void Qz_ObjectName_PythonToCpp_Qz_ObjectName(PyObject *pyIn, void *cppOut) {
    *reinterpret_cast<::Qz::ObjectName *>(cppOut) =
        static_cast<::Qz::ObjectName>(Shiboken::Enum::getValue(pyIn));

}
static PythonToCppFunc is_Qz_ObjectName_PythonToCpp_Qz_ObjectName_Convertible(PyObject *pyIn) {
    if (PyObject_TypeCheck(pyIn, SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX]))
        return Qz_ObjectName_PythonToCpp_Qz_ObjectName;
    return {};
}
static PyObject *Qz_ObjectName_CppToPython_Qz_ObjectName(const void *cppIn) {
    const int castCppIn = int(*reinterpret_cast<const ::Qz::ObjectName *>(cppIn));
    return Shiboken::Enum::newItem(SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX], castCppIn);

}

static void Qz_NewTabPositionFlag_PythonToCpp_Qz_NewTabPositionFlag(PyObject *pyIn, void *cppOut) {
    *reinterpret_cast<::Qz::NewTabPositionFlag *>(cppOut) =
        static_cast<::Qz::NewTabPositionFlag>(Shiboken::Enum::getValue(pyIn));

}
static PythonToCppFunc is_Qz_NewTabPositionFlag_PythonToCpp_Qz_NewTabPositionFlag_Convertible(PyObject *pyIn) {
    if (PyObject_TypeCheck(pyIn, SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX]))
        return Qz_NewTabPositionFlag_PythonToCpp_Qz_NewTabPositionFlag;
    return {};
}
static PyObject *Qz_NewTabPositionFlag_CppToPython_Qz_NewTabPositionFlag(const void *cppIn) {
    const int castCppIn = int(*reinterpret_cast<const ::Qz::NewTabPositionFlag *>(cppIn));
    return Shiboken::Enum::newItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX], castCppIn);

}

static void QFlags_Qz_NewTabPositionFlag__PythonToCpp_QFlags_Qz_NewTabPositionFlag_(PyObject *pyIn, void *cppOut) {
    *reinterpret_cast<::QFlags<Qz::NewTabPositionFlag> *>(cppOut) =
        ::QFlags<Qz::NewTabPositionFlag>(QFlag(int(PySide::QFlags::getValue(reinterpret_cast<PySideQFlagsObject *>(pyIn)))));

}
static PythonToCppFunc is_QFlags_Qz_NewTabPositionFlag__PythonToCpp_QFlags_Qz_NewTabPositionFlag__Convertible(PyObject *pyIn) {
    if (PyObject_TypeCheck(pyIn, SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX]))
        return QFlags_Qz_NewTabPositionFlag__PythonToCpp_QFlags_Qz_NewTabPositionFlag_;
    return {};
}
static PyObject *QFlags_Qz_NewTabPositionFlag__CppToPython_QFlags_Qz_NewTabPositionFlag_(const void *cppIn) {
    const int castCppIn = int(*reinterpret_cast<const ::QFlags<Qz::NewTabPositionFlag> *>(cppIn));
    return reinterpret_cast<PyObject *>(PySide::QFlags::newObject(castCppIn, SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX]));

}

static void Qz_NewTabPositionFlag_PythonToCpp_QFlags_Qz_NewTabPositionFlag_(PyObject *pyIn, void *cppOut) {
    *reinterpret_cast<::QFlags<Qz::NewTabPositionFlag> *>(cppOut) =
        ::QFlags<Qz::NewTabPositionFlag>(QFlag(int(Shiboken::Enum::getValue(pyIn))));

}
static PythonToCppFunc is_Qz_NewTabPositionFlag_PythonToCpp_QFlags_Qz_NewTabPositionFlag__Convertible(PyObject *pyIn) {
    if (PyObject_TypeCheck(pyIn, SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX]))
        return Qz_NewTabPositionFlag_PythonToCpp_QFlags_Qz_NewTabPositionFlag_;
    return {};
}
static void number_PythonToCpp_QFlags_Qz_NewTabPositionFlag_(PyObject *pyIn, void *cppOut) {
    Shiboken::AutoDecRef pyLong(PyNumber_Long(pyIn));
    *reinterpret_cast<::QFlags<Qz::NewTabPositionFlag> *>(cppOut) =
        ::QFlags<Qz::NewTabPositionFlag>(QFlag(int(PyLong_AsLong(pyLong.object()))));

}
static PythonToCppFunc is_number_PythonToCpp_QFlags_Qz_NewTabPositionFlag__Convertible(PyObject *pyIn) {
    if (PyNumber_Check(pyIn) && PyObject_TypeCheck(pyIn, SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX]))
        return number_PythonToCpp_QFlags_Qz_NewTabPositionFlag_;
    return {};
}
// The signatures string for the functions.
// Multiple signatures have their index "n:" in front.
static const char *PyFalkonQz_SignatureStrings[] = {
    nullptr}; // Sentinel

void init_PyFalkonQz(PyObject *module)
{
    _Sbk_Qz_Type = Shiboken::ObjectType::introduceWrapperType(
        module,
        "Qz",
        "Qz",
        &Sbk_Qz_spec,
        0,
        0,
        0,
        0    );
    
    auto pyType = reinterpret_cast<PyTypeObject *>(_Sbk_Qz_Type);
    InitSignatureStrings(pyType, PyFalkonQz_SignatureStrings);
    SbkObjectType_SetPropertyStrings(reinterpret_cast<PyTypeObject *>(_Sbk_Qz_Type), Sbk_Qz_PropertyStrings);
    SbkPyFalkonTypes[SBK_PyFalkonQZ_IDX]
        = reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF());


    // Initialization of enums.

    // Initialization of enum 'BrowserWindowType'.
    SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Qz_TypeF(),
        "BrowserWindowType",
        "1:PyFalkon.Qz.BrowserWindowType",
        "Qz::BrowserWindowType");
    if (!SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX])
        return;

    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX],
        Sbk_Qz_TypeF(), "BW_FirstAppWindow", (long) Qz::BrowserWindowType::BW_FirstAppWindow))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX],
        Sbk_Qz_TypeF(), "BW_OtherRestoredWindow", (long) Qz::BrowserWindowType::BW_OtherRestoredWindow))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX],
        Sbk_Qz_TypeF(), "BW_NewWindow", (long) Qz::BrowserWindowType::BW_NewWindow))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX],
        Sbk_Qz_TypeF(), "BW_MacFirstWindow", (long) Qz::BrowserWindowType::BW_MacFirstWindow))
        return;
    // Register converter for enum 'Qz::BrowserWindowType'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX],
            Qz_BrowserWindowType_CppToPython_Qz_BrowserWindowType);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Qz_BrowserWindowType_PythonToCpp_Qz_BrowserWindowType,
            is_Qz_BrowserWindowType_PythonToCpp_Qz_BrowserWindowType_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPyFalkonTypes[SBK_QZ_BROWSERWINDOWTYPE_IDX], converter);
        Shiboken::Conversions::registerConverterName(converter, "Qz::BrowserWindowType");
        Shiboken::Conversions::registerConverterName(converter, "BrowserWindowType");
    }
    // End of 'BrowserWindowType' enum.

    // Initialization of enum 'CommandLineAction'.
    SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Qz_TypeF(),
        "CommandLineAction",
        "1:PyFalkon.Qz.CommandLineAction",
        "Qz::CommandLineAction");
    if (!SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX])
        return;

    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_NoAction", (long) Qz::CommandLineAction::CL_NoAction))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_OpenUrl", (long) Qz::CommandLineAction::CL_OpenUrl))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_OpenUrlInCurrentTab", (long) Qz::CommandLineAction::CL_OpenUrlInCurrentTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_OpenUrlInNewWindow", (long) Qz::CommandLineAction::CL_OpenUrlInNewWindow))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_StartWithProfile", (long) Qz::CommandLineAction::CL_StartWithProfile))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_StartWithoutAddons", (long) Qz::CommandLineAction::CL_StartWithoutAddons))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_NewTab", (long) Qz::CommandLineAction::CL_NewTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_NewWindow", (long) Qz::CommandLineAction::CL_NewWindow))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_ShowDownloadManager", (long) Qz::CommandLineAction::CL_ShowDownloadManager))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_ToggleFullScreen", (long) Qz::CommandLineAction::CL_ToggleFullScreen))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_StartPrivateBrowsing", (long) Qz::CommandLineAction::CL_StartPrivateBrowsing))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_StartNewInstance", (long) Qz::CommandLineAction::CL_StartNewInstance))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_StartPortable", (long) Qz::CommandLineAction::CL_StartPortable))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_ExitAction", (long) Qz::CommandLineAction::CL_ExitAction))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
        Sbk_Qz_TypeF(), "CL_WMClass", (long) Qz::CommandLineAction::CL_WMClass))
        return;
    // Register converter for enum 'Qz::CommandLineAction'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX],
            Qz_CommandLineAction_CppToPython_Qz_CommandLineAction);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Qz_CommandLineAction_PythonToCpp_Qz_CommandLineAction,
            is_Qz_CommandLineAction_PythonToCpp_Qz_CommandLineAction_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPyFalkonTypes[SBK_QZ_COMMANDLINEACTION_IDX], converter);
        Shiboken::Conversions::registerConverterName(converter, "Qz::CommandLineAction");
        Shiboken::Conversions::registerConverterName(converter, "CommandLineAction");
    }
    // End of 'CommandLineAction' enum.

    // Initialization of enum 'ObjectName'.
    SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Qz_TypeF(),
        "ObjectName",
        "1:PyFalkon.Qz.ObjectName",
        "Qz::ObjectName");
    if (!SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX])
        return;

    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX],
        Sbk_Qz_TypeF(), "ON_WebView", (long) Qz::ObjectName::ON_WebView))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX],
        Sbk_Qz_TypeF(), "ON_TabBar", (long) Qz::ObjectName::ON_TabBar))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX],
        Sbk_Qz_TypeF(), "ON_TabWidget", (long) Qz::ObjectName::ON_TabWidget))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX],
        Sbk_Qz_TypeF(), "ON_BrowserWindow", (long) Qz::ObjectName::ON_BrowserWindow))
        return;
    // Register converter for enum 'Qz::ObjectName'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX],
            Qz_ObjectName_CppToPython_Qz_ObjectName);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Qz_ObjectName_PythonToCpp_Qz_ObjectName,
            is_Qz_ObjectName_PythonToCpp_Qz_ObjectName_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPyFalkonTypes[SBK_QZ_OBJECTNAME_IDX], converter);
        Shiboken::Conversions::registerConverterName(converter, "Qz::ObjectName");
        Shiboken::Conversions::registerConverterName(converter, "ObjectName");
    }
    // End of 'ObjectName' enum.

    // Initialization of enum 'NewTabPositionFlag'.
    SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX] = PySide::QFlags::create("1:PyFalkon.Qz.NewTabPositionFlags", SbkPyFalkon_Qz_NewTabPositionFlag_number_slots);
    SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX] = Shiboken::Enum::createScopedEnum(Sbk_Qz_TypeF(),
        "NewTabPositionFlag",
        "1:PyFalkon.Qz.NewTabPositionFlag",
        "Qz::NewTabPositionFlag",
        SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX]);
    if (!SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX])
        return;

    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_SelectedTab", (long) Qz::NewTabPositionFlag::NT_SelectedTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_NotSelectedTab", (long) Qz::NewTabPositionFlag::NT_NotSelectedTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_CleanTab", (long) Qz::NewTabPositionFlag::NT_CleanTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_TabAtTheEnd", (long) Qz::NewTabPositionFlag::NT_TabAtTheEnd))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_NewEmptyTab", (long) Qz::NewTabPositionFlag::NT_NewEmptyTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_SelectedNewEmptyTab", (long) Qz::NewTabPositionFlag::NT_SelectedNewEmptyTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_SelectedTabAtTheEnd", (long) Qz::NewTabPositionFlag::NT_SelectedTabAtTheEnd))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_NotSelectedTabAtTheEnd", (long) Qz::NewTabPositionFlag::NT_NotSelectedTabAtTheEnd))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_CleanSelectedTabAtTheEnd", (long) Qz::NewTabPositionFlag::NT_CleanSelectedTabAtTheEnd))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_CleanSelectedTab", (long) Qz::NewTabPositionFlag::NT_CleanSelectedTab))
        return;
    if (!Shiboken::Enum::createScopedEnumItem(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
        Sbk_Qz_TypeF(), "NT_CleanNotSelectedTab", (long) Qz::NewTabPositionFlag::NT_CleanNotSelectedTab))
        return;
    // Register converter for enum 'Qz::NewTabPositionFlag'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX],
            Qz_NewTabPositionFlag_CppToPython_Qz_NewTabPositionFlag);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Qz_NewTabPositionFlag_PythonToCpp_Qz_NewTabPositionFlag,
            is_Qz_NewTabPositionFlag_PythonToCpp_Qz_NewTabPositionFlag_Convertible);
        Shiboken::Enum::setTypeConverter(SbkPyFalkonTypes[SBK_QZ_NEWTABPOSITIONFLAG_IDX], converter);
        Shiboken::Conversions::registerConverterName(converter, "Qz::NewTabPositionFlag");
        Shiboken::Conversions::registerConverterName(converter, "NewTabPositionFlag");
    }
    // Register converter for flag 'QFlags<Qz::NewTabPositionFlag>'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX],
            QFlags_Qz_NewTabPositionFlag__CppToPython_QFlags_Qz_NewTabPositionFlag_);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Qz_NewTabPositionFlag_PythonToCpp_QFlags_Qz_NewTabPositionFlag_,
            is_Qz_NewTabPositionFlag_PythonToCpp_QFlags_Qz_NewTabPositionFlag__Convertible);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            QFlags_Qz_NewTabPositionFlag__PythonToCpp_QFlags_Qz_NewTabPositionFlag_,
            is_QFlags_Qz_NewTabPositionFlag__PythonToCpp_QFlags_Qz_NewTabPositionFlag__Convertible);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            number_PythonToCpp_QFlags_Qz_NewTabPositionFlag_,
            is_number_PythonToCpp_QFlags_Qz_NewTabPositionFlag__Convertible);
        Shiboken::Enum::setTypeConverter(SbkPyFalkonTypes[SBK_QFLAGS_QZ_NEWTABPOSITIONFLAG_IDX], converter);
        Shiboken::Conversions::registerConverterName(converter, "Qz::NewTabPositionFlags");
        Shiboken::Conversions::registerConverterName(converter, "NewTabPositionFlags");
    }
    // End of 'NewTabPositionFlag' enum/flags.

    PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF())->tp_dict, "APPNAME", Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::APPNAME));
    PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF())->tp_dict, "VERSION", Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::VERSION));
    PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF())->tp_dict, "AUTHOR", Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::AUTHOR));
    PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF())->tp_dict, "COPYRIGHT", Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::COPYRIGHT));
    PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF())->tp_dict, "WWWADDRESS", Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::WWWADDRESS));
    PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF())->tp_dict, "BUGSADDRESS", Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::BUGSADDRESS));
    PyDict_SetItemString(reinterpret_cast<PyTypeObject *>(Sbk_Qz_TypeF())->tp_dict, "WIKIADDRESS", Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::WIKIADDRESS));

    qRegisterMetaType< ::Qz::BrowserWindowType >("Qz::BrowserWindowType");
    qRegisterMetaType< ::Qz::CommandLineAction >("Qz::CommandLineAction");
    qRegisterMetaType< ::Qz::ObjectName >("Qz::ObjectName");
    qRegisterMetaType< ::Qz::NewTabPositionFlag >("Qz::NewTabPositionFlag");
    qRegisterMetaType< ::Qz::NewTabPositionFlags >("Qz::NewTabPositionFlags");
}
