
// default includes
#include <shiboken.h>
#include <sbkpep.h>
#include <sbkpepbuffer.h>

#define PYSIDE6_COMOPT_COMPRESS 1

#ifndef QT_NO_VERSION_TAGGING
#  define QT_NO_VERSION_TAGGING
#endif
#include <QtCore/QDebug>
#include <pysideqenum.h>
#include <pysideutils.h>
#include <feature_select.h>
QT_WARNING_DISABLE_DEPRECATED


// module include
#include "pyfalkon_python.h"

// main header
#include "qz_wrapper.h"

#include <cctype>
#include <cstring>
#include <iterator>
#include <type_traits>
#include <typeinfo>


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

extern "C" {
static int Sbk_Qz_Init(PyObject *, PyObject *, PyObject *)
{
    Shiboken::Errors::setInstantiateNamespace("Qz");
    return -1;
}


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

static const char *Sbk_Qz_EnumFlagInfo[] = {
    "BrowserWindowType:IntEnum",
    "ColorScheme:IntEnum",
    "CommandLineAction:IntEnum",
    "NewTabPositionFlag:IntFlag:NewTabPositionFlags",
    "ObjectName:IntEnum",
    nullptr // Sentinel
};

static PyMethodDef Sbk_Qz_methods[] = {
    {nullptr, nullptr, 0, nullptr} // Sentinel
};

} // extern "C"

static int Sbk_Qz_traverse(PyObject *self, visitproc visit, void *arg)
{
    auto traverseProc = reinterpret_cast<traverseproc>(PyType_GetSlot(SbkObject_TypeF(), Py_tp_traverse));
    ;
    return traverseProc(self, visit, arg);
}
static int Sbk_Qz_clear(PyObject *self)
{
    auto clearProc = reinterpret_cast<inquiry>(PyType_GetSlot(SbkObject_TypeF(), Py_tp_clear));
    ;
    return clearProc(self);
}

// Class Definition -----------------------------------------------
extern "C" {

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_traverse,    reinterpret_cast<void *>(Sbk_Qz_traverse)},
    {Py_tp_clear,       reinterpret_cast<void *>(Sbk_Qz_clear)},
    {Py_tp_methods,     reinterpret_cast<void *>(Sbk_Qz_methods)},
    {Py_tp_init,        reinterpret_cast<void *>(Sbk_Qz_Init)},
    {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_HAVE_GC,
    Sbk_Qz_slots
};

} //extern "C"

// Type conversion functions.

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

}
static PythonToCppFunc is_Enum_PythonToCpp_Qz_BrowserWindowType_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, Shiboken::Module::get(SbkPyFalkonTypeStructs[SBK_Qz_BrowserWindowType_IDX])))
        return Enum_PythonToCpp_Qz_BrowserWindowType;
    return {};
}

static PyObject *Qz_BrowserWindowType_CppToPython_Enum(PyTypeObject *pyType, const void *cppIn)
{
    using IntType = std::underlying_type_t<::Qz::BrowserWindowType>;
    const auto castCppIn = IntType(*reinterpret_cast<const ::Qz::BrowserWindowType *>(cppIn));
    return Shiboken::Enum::newItem(pyType, castCppIn);

}

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

}
static PythonToCppFunc is_Enum_PythonToCpp_Qz_CommandLineAction_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, Shiboken::Module::get(SbkPyFalkonTypeStructs[SBK_Qz_CommandLineAction_IDX])))
        return Enum_PythonToCpp_Qz_CommandLineAction;
    return {};
}

static PyObject *Qz_CommandLineAction_CppToPython_Enum(PyTypeObject *pyType, const void *cppIn)
{
    using IntType = std::underlying_type_t<::Qz::CommandLineAction>;
    const auto castCppIn = IntType(*reinterpret_cast<const ::Qz::CommandLineAction *>(cppIn));
    return Shiboken::Enum::newItem(pyType, castCppIn);

}

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

}
static PythonToCppFunc is_Enum_PythonToCpp_Qz_ObjectName_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, Shiboken::Module::get(SbkPyFalkonTypeStructs[SBK_Qz_ObjectName_IDX])))
        return Enum_PythonToCpp_Qz_ObjectName;
    return {};
}

static PyObject *Qz_ObjectName_CppToPython_Enum(PyTypeObject *pyType, const void *cppIn)
{
    using IntType = std::underlying_type_t<::Qz::ObjectName>;
    const auto castCppIn = IntType(*reinterpret_cast<const ::Qz::ObjectName *>(cppIn));
    return Shiboken::Enum::newItem(pyType, castCppIn);

}

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

}
static PythonToCppFunc is_Enum_PythonToCpp_Qz_NewTabPositionFlag_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, Shiboken::Module::get(SbkPyFalkonTypeStructs[SBK_Qz_NewTabPositionFlag_IDX])))
        return Enum_PythonToCpp_Qz_NewTabPositionFlag;
    return {};
}

static PyObject *Qz_NewTabPositionFlag_CppToPython_Enum(PyTypeObject *pyType, const void *cppIn)
{
    using IntType = std::underlying_type_t<::Qz::NewTabPositionFlag>;
    const auto castCppIn = IntType(*reinterpret_cast<const ::Qz::NewTabPositionFlag *>(cppIn));
    return Shiboken::Enum::newItem(pyType, castCppIn);

}

static void Flag_PythonToCpp_Qz_NewTabPositionFlag(PyObject *pyIn, void *cppOut)
{
    const auto value = QFlags<::Qz::NewTabPositionFlag>::fromInt(Shiboken::Enum::getValue(pyIn));
    *reinterpret_cast<QFlags<::Qz::NewTabPositionFlag> *>(cppOut) = value;

}

static PyObject *Qz_NewTabPositionFlag_CppToPython_Flag(const void *cppIn)
{
    const auto flags = *reinterpret_cast<const QFlags<::Qz::NewTabPositionFlag> *>(cppIn);
    return Shiboken::Enum::newItem(Shiboken::Module::get(SbkPyFalkonTypeStructs[SBK_Qz_NewTabPositionFlag_IDX]), flags.toInt());

}

static void Enum_PythonToCpp_Qz_ColorScheme(PyObject *pyIn, void *cppOut)
{
    const auto value = static_cast<::Qz::ColorScheme>(Shiboken::Enum::getValue(pyIn));
    *reinterpret_cast<::Qz::ColorScheme *>(cppOut) = value;

}
static PythonToCppFunc is_Enum_PythonToCpp_Qz_ColorScheme_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, Shiboken::Module::get(SbkPyFalkonTypeStructs[SBK_Qz_ColorScheme_IDX])))
        return Enum_PythonToCpp_Qz_ColorScheme;
    return {};
}

static PyObject *Qz_ColorScheme_CppToPython_Enum(PyTypeObject *pyType, const void *cppIn)
{
    using IntType = std::underlying_type_t<::Qz::ColorScheme>;
    const auto castCppIn = IntType(*reinterpret_cast<const ::Qz::ColorScheme *>(cppIn));
    return Shiboken::Enum::newItem(pyType, castCppIn);

}

// The signatures string for the functions.
// Multiple signatures have their index "n:" in front.
#if PYSIDE6_COMOPT_COMPRESS == 0
static const char *PyFalkonQz_SignatureStrings[] = {
    nullptr}; // Sentinel
#else
static constexpr size_t PyFalkonQz_SignatureByteSize = 0;
static constexpr uint8_t PyFalkonQz_SignatureBytes[1] = {
    0x00
};
#endif

PyTypeObject *init_PyFalkonQz(PyObject *module)
{
    auto &typeStruct = SbkPyFalkonTypeStructs[SBK_PyFalkonQz_IDX];
    if (typeStruct.type != nullptr)
        return typeStruct.type;

    auto *base1 = SbkObject_TypeF();
    Shiboken::AutoDecRef Sbk_Qz_Type_bases(PyTuple_Pack(1, base1));

    PyTypeObject *pyType = Shiboken::ObjectType::introduceWrapperType(
        module,
        "Qz",
        "Qz",
        &Sbk_Qz_spec,
        nullptr,
        Sbk_Qz_Type_bases.object(),
        0);
#if PYSIDE6_COMOPT_COMPRESS == 0
    InitSignatureStrings(pyType, PyFalkonQz_SignatureStrings);
#else
    InitSignatureBytes(pyType, PyFalkonQz_SignatureBytes, PyFalkonQz_SignatureByteSize);
#endif
    SbkObjectType_SetPropertyStrings(pyType, Sbk_Qz_PropertyStrings);
    typeStruct.type = pyType;


    // Pass the ..._EnumFlagInfo to the class.
    SbkObjectType_SetEnumFlagInfo(pyType, Sbk_Qz_EnumFlagInfo);

    // Initialization of enums.
    Shiboken::AutoDecRef tpDict{};
    [[maybe_unused]] PyTypeObject *EType{};

    // Initialization of enum 'BrowserWindowType'.
    const char *BrowserWindowType_Initializer[] = {
        "BW_FirstAppWindow",
        "BW_OtherRestoredWindow",
        "BW_NewWindow",
        "BW_MacFirstWindow",
        nullptr};
    // "uint8_t" used instead of "unsigned int"
    constexpr uint8_t BrowserWindowType_InitializerValues[] = {
        uint8_t(Qz::BrowserWindowType::BW_FirstAppWindow),      //  0x00  0
        uint8_t(Qz::BrowserWindowType::BW_OtherRestoredWindow), //  0x01  1
        uint8_t(Qz::BrowserWindowType::BW_NewWindow),           //  0x02  2
        uint8_t(Qz::BrowserWindowType::BW_MacFirstWindow)       //  0x03  3
        };
    EType = Shiboken::Enum::createPythonEnum(pyType,
        "1:PyFalkon.Qz.BrowserWindowType",
        BrowserWindowType_Initializer, BrowserWindowType_InitializerValues);
    SbkPyFalkonTypeStructs[SBK_Qz_BrowserWindowType_IDX].type = EType;
    // Register converter for enum 'Qz::BrowserWindowType'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(EType,
            Qz_BrowserWindowType_CppToPython_Enum);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Enum_PythonToCpp_Qz_BrowserWindowType,
            is_Enum_PythonToCpp_Qz_BrowserWindowType_Convertible);
        Shiboken::Conversions::registerConverterName(converter, "Qz::BrowserWindowType");
        Shiboken::Conversions::registerConverterAlias(converter, "BrowserWindowType");
        Shiboken::Enum::setTypeConverter(EType, converter, nullptr);
    }
    // End of 'BrowserWindowType' enum.

    // Initialization of enum 'CommandLineAction'.
    const char *CommandLineAction_Initializer[] = {
        "CL_NoAction",
        "CL_OpenUrl",
        "CL_OpenUrlInCurrentTab",
        "CL_OpenUrlInNewWindow",
        "CL_StartWithProfile",
        "CL_StartWithoutAddons",
        "CL_NewTab",
        "CL_NewWindow",
        "CL_ShowDownloadManager",
        "CL_ToggleFullScreen",
        "CL_StartPrivateBrowsing",
        "CL_StartNewInstance",
        "CL_StartPortable",
        "CL_ExitAction",
        "CL_WMClass",
        nullptr};
    // "uint8_t" used instead of "unsigned int"
    constexpr uint8_t CommandLineAction_InitializerValues[] = {
        uint8_t(Qz::CommandLineAction::CL_NoAction),             //  0x00  0
        uint8_t(Qz::CommandLineAction::CL_OpenUrl),              //  0x01  1
        uint8_t(Qz::CommandLineAction::CL_OpenUrlInCurrentTab),  //  0x02  2
        uint8_t(Qz::CommandLineAction::CL_OpenUrlInNewWindow),   //  0x03  3
        uint8_t(Qz::CommandLineAction::CL_StartWithProfile),     //  0x04  4
        uint8_t(Qz::CommandLineAction::CL_StartWithoutAddons),   //  0x05  5
        uint8_t(Qz::CommandLineAction::CL_NewTab),               //  0x06  6
        uint8_t(Qz::CommandLineAction::CL_NewWindow),            //  0x07  7
        uint8_t(Qz::CommandLineAction::CL_ShowDownloadManager),  //  0x08  8
        uint8_t(Qz::CommandLineAction::CL_ToggleFullScreen),     //  0x09  9
        uint8_t(Qz::CommandLineAction::CL_StartPrivateBrowsing), //  0x0a  10
        uint8_t(Qz::CommandLineAction::CL_StartNewInstance),     //  0x0b  11
        uint8_t(Qz::CommandLineAction::CL_StartPortable),        //  0x0c  12
        uint8_t(Qz::CommandLineAction::CL_ExitAction),           //  0x0d  13
        uint8_t(Qz::CommandLineAction::CL_WMClass)               //  0x0e  14
        };
    EType = Shiboken::Enum::createPythonEnum(pyType,
        "1:PyFalkon.Qz.CommandLineAction",
        CommandLineAction_Initializer, CommandLineAction_InitializerValues);
    SbkPyFalkonTypeStructs[SBK_Qz_CommandLineAction_IDX].type = EType;
    // Register converter for enum 'Qz::CommandLineAction'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(EType,
            Qz_CommandLineAction_CppToPython_Enum);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Enum_PythonToCpp_Qz_CommandLineAction,
            is_Enum_PythonToCpp_Qz_CommandLineAction_Convertible);
        Shiboken::Conversions::registerConverterName(converter, "Qz::CommandLineAction");
        Shiboken::Conversions::registerConverterAlias(converter, "CommandLineAction");
        Shiboken::Enum::setTypeConverter(EType, converter, nullptr);
    }
    // End of 'CommandLineAction' enum.

    // Initialization of enum 'ObjectName'.
    const char *ObjectName_Initializer[] = {
        "ON_WebView",
        "ON_TabBar",
        "ON_TabWidget",
        "ON_BrowserWindow",
        nullptr};
    // "uint8_t" used instead of "unsigned int"
    constexpr uint8_t ObjectName_InitializerValues[] = {
        uint8_t(Qz::ObjectName::ON_WebView),      //  0x00  0
        uint8_t(Qz::ObjectName::ON_TabBar),       //  0x01  1
        uint8_t(Qz::ObjectName::ON_TabWidget),    //  0x02  2
        uint8_t(Qz::ObjectName::ON_BrowserWindow) //  0x03  3
        };
    EType = Shiboken::Enum::createPythonEnum(pyType,
        "1:PyFalkon.Qz.ObjectName",
        ObjectName_Initializer, ObjectName_InitializerValues);
    SbkPyFalkonTypeStructs[SBK_Qz_ObjectName_IDX].type = EType;
    // Register converter for enum 'Qz::ObjectName'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(EType,
            Qz_ObjectName_CppToPython_Enum);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Enum_PythonToCpp_Qz_ObjectName,
            is_Enum_PythonToCpp_Qz_ObjectName_Convertible);
        Shiboken::Conversions::registerConverterName(converter, "Qz::ObjectName");
        Shiboken::Conversions::registerConverterAlias(converter, "ObjectName");
        Shiboken::Enum::setTypeConverter(EType, converter, nullptr);
    }
    // End of 'ObjectName' enum.

    // Initialization of enum 'NewTabPositionFlag'.
    const char *NewTabPositionFlag_Initializer[] = {
        "NT_SelectedTab",
        "NT_NotSelectedTab",
        "NT_CleanTab",
        "NT_TabAtTheEnd",
        "NT_NewEmptyTab",
        "NT_SelectedNewEmptyTab",
        "NT_SelectedTabAtTheEnd",
        "NT_NotSelectedTabAtTheEnd",
        "NT_CleanSelectedTabAtTheEnd",
        "NT_CleanSelectedTab",
        "NT_CleanNotSelectedTab",
        nullptr};
    // "uint8_t" used instead of "unsigned int"
    constexpr uint8_t NewTabPositionFlag_InitializerValues[] = {
        uint8_t(Qz::NewTabPositionFlag::NT_SelectedTab),              //  0x01  1
        uint8_t(Qz::NewTabPositionFlag::NT_NotSelectedTab),           //  0x02  2
        uint8_t(Qz::NewTabPositionFlag::NT_CleanTab),                 //  0x04  4
        uint8_t(Qz::NewTabPositionFlag::NT_TabAtTheEnd),              //  0x08  8
        uint8_t(Qz::NewTabPositionFlag::NT_NewEmptyTab),              //  0x10  16
        uint8_t(Qz::NewTabPositionFlag::NT_SelectedNewEmptyTab),      //  0x19  25
        uint8_t(Qz::NewTabPositionFlag::NT_SelectedTabAtTheEnd),      //  0x09  9
        uint8_t(Qz::NewTabPositionFlag::NT_NotSelectedTabAtTheEnd),   //  0x0a  10
        uint8_t(Qz::NewTabPositionFlag::NT_CleanSelectedTabAtTheEnd), //  0x0d  13
        uint8_t(Qz::NewTabPositionFlag::NT_CleanSelectedTab),         //  0x05  5
        uint8_t(Qz::NewTabPositionFlag::NT_CleanNotSelectedTab)       //  0x06  6
        };
    EType = Shiboken::Enum::createPythonEnum(pyType,
        "1:PyFalkon.Qz.NewTabPositionFlag",
        NewTabPositionFlag_Initializer, NewTabPositionFlag_InitializerValues);
    SbkPyFalkonTypeStructs[SBK_Qz_NewTabPositionFlag_IDX].type = EType;
    // PYSIDE-1735: Mapping the flags class to the same enum class.
    SbkPyFalkonTypeStructs[SBK_QFlags_Qz_NewTabPositionFlag_IDX].type =
        EType;
    // Register converter for enum 'Qz::NewTabPositionFlag'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(EType,
            Qz_NewTabPositionFlag_CppToPython_Enum);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Enum_PythonToCpp_Qz_NewTabPositionFlag,
            is_Enum_PythonToCpp_Qz_NewTabPositionFlag_Convertible);
        Shiboken::Conversions::registerConverterName(converter, "Qz::NewTabPositionFlag");
        Shiboken::Conversions::registerConverterAlias(converter, "NewTabPositionFlag");
        SbkConverter *flagsConverter = Shiboken::Conversions::createConverter(EType,
            Qz_NewTabPositionFlag_CppToPython_Flag);
        Shiboken::Conversions::addPythonToCppValueConversion(flagsConverter,
            Flag_PythonToCpp_Qz_NewTabPositionFlag,
            is_Enum_PythonToCpp_Qz_NewTabPositionFlag_Convertible);
        // Register converter for flag 'QFlags<Qz::NewTabPositionFlag>'.
        Shiboken::Conversions::registerConverterName(flagsConverter, "QFlags<Qz::NewTabPositionFlag>");
        Shiboken::Conversions::registerConverterName(flagsConverter, "Qz::NewTabPositionFlags");
        Shiboken::Enum::setTypeConverter(EType, converter, flagsConverter);
    }
    // End of 'NewTabPositionFlag' enum/flags.

    // Initialization of enum 'ColorScheme'.
    const char *ColorScheme_Initializer[] = {
        "ColorScheme_Auto",
        "ColorScheme_Light",
        "ColorScheme_Dark",
        nullptr};
    // "uint8_t" used instead of "unsigned int"
    constexpr uint8_t ColorScheme_InitializerValues[] = {
        uint8_t(Qz::ColorScheme::ColorScheme_Auto),  //  0x00  0
        uint8_t(Qz::ColorScheme::ColorScheme_Light), //  0x01  1
        uint8_t(Qz::ColorScheme::ColorScheme_Dark)   //  0x02  2
        };
    EType = Shiboken::Enum::createPythonEnum(pyType,
        "1:PyFalkon.Qz.ColorScheme",
        ColorScheme_Initializer, ColorScheme_InitializerValues);
    SbkPyFalkonTypeStructs[SBK_Qz_ColorScheme_IDX].type = EType;
    // Register converter for enum 'Qz::ColorScheme'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(EType,
            Qz_ColorScheme_CppToPython_Enum);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Enum_PythonToCpp_Qz_ColorScheme,
            is_Enum_PythonToCpp_Qz_ColorScheme_Convertible);
        Shiboken::Conversions::registerConverterName(converter, "Qz::ColorScheme");
        Shiboken::Conversions::registerConverterAlias(converter, "ColorScheme");
        Shiboken::Enum::setTypeConverter(EType, converter, nullptr);
    }
    // End of 'ColorScheme' enum.

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

    return pyType;
}

PyTypeObject *init_PyFalkonQzStaticFields(PyObject *module)
{
    Shiboken::AutoDecRef obType(PyObject_GetAttrString(module, "Qz"));
    assert(!obType.isNull());
    auto *type = reinterpret_cast<PyTypeObject *>(obType.object());
    Shiboken::AutoDecRef dict(PepType_GetDict(type));
    PyDict_SetItemString(dict, "APPNAME",
                         Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::APPNAME));
    PyDict_SetItemString(dict, "VERSION",
                         Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::VERSION));
    PyDict_SetItemString(dict, "AUTHOR",
                         Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::AUTHOR));
    PyDict_SetItemString(dict, "COPYRIGHT",
                         Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::COPYRIGHT));
    PyDict_SetItemString(dict, "WWWADDRESS",
                         Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::WWWADDRESS));
    PyDict_SetItemString(dict, "BUGSADDRESS",
                         Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::BUGSADDRESS));
    PyDict_SetItemString(dict, "WIKIADDRESS",
                         Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<const char *>(), Qz::WIKIADDRESS));
    return type;
}
