bindingDOtherSide.cs

// ----------------------------------------------------------------------------
// <auto-generated>
// This is autogenerated code by CppSharp.
// Do not edit this file or all your changes will be lost after re-generation.
// </auto-generated>
// ----------------------------------------------------------------------------
using System;
using System.Runtime.InteropServices;
using System.Security;

namespace DOtherSide
{
    public unsafe partial class DOtherSide
    {
        public partial struct __Internal
        {
            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qcoreapplication_application_dir_path")]
            internal static extern sbyte* DosQcoreapplicationApplicationDirPath();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qguiapplication_create")]
            internal static extern void DosQguiapplicationCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qguiapplication_exec")]
            internal static extern void DosQguiapplicationExec();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qguiapplication_quit")]
            internal static extern void DosQguiapplicationQuit();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qguiapplication_delete")]
            internal static extern void DosQguiapplicationDelete();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qapplication_create")]
            internal static extern void DosQapplicationCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qapplication_exec")]
            internal static extern void DosQapplicationExec();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qapplication_quit")]
            internal static extern void DosQapplicationQuit();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qapplication_delete")]
            internal static extern void DosQapplicationDelete();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_create")]
            internal static extern global::System.IntPtr DosQqmlapplicationengineCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_load")]
            internal static extern void DosQqmlapplicationengineLoad(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string filename);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_load_url")]
            internal static extern void DosQqmlapplicationengineLoadUrl(global::System.IntPtr vptr, global::System.IntPtr url);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_load_data")]
            internal static extern void DosQqmlapplicationengineLoadData(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string data);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_add_import_path")]
            internal static extern void DosQqmlapplicationengineAddImportPath(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string path);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_context")]
            internal static extern global::System.IntPtr DosQqmlapplicationengineContext(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_addImageProvider")]
            internal static extern void DosQqmlapplicationengineAddImageProvider(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string name, global::System.IntPtr vptr_i);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlapplicationengine_delete")]
            internal static extern void DosQqmlapplicationengineDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickimageprovider_create")]
            internal static extern global::System.IntPtr DosQquickimageproviderCreate(global::System.IntPtr callback);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickimageprovider_delete")]
            internal static extern void DosQquickimageproviderDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_create")]
            internal static extern global::System.IntPtr DosQpixmapCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_create_qpixmap")]
            internal static extern global::System.IntPtr DosQpixmapCreateQpixmap(global::System.IntPtr other);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_create_width_and_height")]
            internal static extern global::System.IntPtr DosQpixmapCreateWidthAndHeight(int width, int height);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_delete")]
            internal static extern void DosQpixmapDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_load")]
            internal static extern void DosQpixmapLoad(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string filepath, [MarshalAs(UnmanagedType.LPStr)] string format);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_loadFromData")]
            internal static extern void DosQpixmapLoadFromData(global::System.IntPtr vptr, byte* data, uint len);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_fill")]
            internal static extern void DosQpixmapFill(global::System.IntPtr vptr, byte r, byte g, byte b, byte a);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_assign")]
            internal static extern void DosQpixmapAssign(global::System.IntPtr vptr, global::System.IntPtr other);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qpixmap_isNull")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQpixmapIsNull(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickstyle_set_style")]
            internal static extern void DosQquickstyleSetStyle([MarshalAs(UnmanagedType.LPStr)] string style);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickstyle_set_fallback_style")]
            internal static extern void DosQquickstyleSetFallbackStyle([MarshalAs(UnmanagedType.LPStr)] string style);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_create")]
            internal static extern global::System.IntPtr DosQquickviewCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_show")]
            internal static extern void DosQquickviewShow(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_source")]
            internal static extern sbyte* DosQquickviewSource(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_set_source_url")]
            internal static extern void DosQquickviewSetSourceUrl(global::System.IntPtr vptr, global::System.IntPtr url);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_set_source")]
            internal static extern void DosQquickviewSetSource(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string filename);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_set_resize_mode")]
            internal static extern void DosQquickviewSetResizeMode(global::System.IntPtr vptr, int resizeMode);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_delete")]
            internal static extern void DosQquickviewDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qquickview_rootContext")]
            internal static extern global::System.IntPtr DosQquickviewRootContext(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlcontext_baseUrl")]
            internal static extern sbyte* DosQqmlcontextBaseUrl(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qqmlcontext_setcontextproperty")]
            internal static extern void DosQqmlcontextSetcontextproperty(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string name, global::System.IntPtr value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_chararray_delete")]
            internal static extern void DosChararrayDelete(sbyte* ptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariantarray_delete")]
            internal static extern void DosQvariantarrayDelete(global::System.IntPtr ptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create")]
            internal static extern global::System.IntPtr DosQvariantCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_int")]
            internal static extern global::System.IntPtr DosQvariantCreateInt(int value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_bool")]
            internal static extern global::System.IntPtr DosQvariantCreateBool(bool value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_string")]
            internal static extern global::System.IntPtr DosQvariantCreateString([MarshalAs(UnmanagedType.LPStr)] string value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_qobject")]
            internal static extern global::System.IntPtr DosQvariantCreateQobject(global::System.IntPtr value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_qvariant")]
            internal static extern global::System.IntPtr DosQvariantCreateQvariant(global::System.IntPtr value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_float")]
            internal static extern global::System.IntPtr DosQvariantCreateFloat(float value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_double")]
            internal static extern global::System.IntPtr DosQvariantCreateDouble(double value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_create_array")]
            internal static extern global::System.IntPtr DosQvariantCreateArray(int size, void** array);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_setInt")]
            internal static extern void DosQvariantSetInt(global::System.IntPtr vptr, int value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_setBool")]
            internal static extern void DosQvariantSetBool(global::System.IntPtr vptr, bool value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_setFloat")]
            internal static extern void DosQvariantSetFloat(global::System.IntPtr vptr, float value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_setDouble")]
            internal static extern void DosQvariantSetDouble(global::System.IntPtr vptr, double value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_setString")]
            internal static extern void DosQvariantSetString(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_setQObject")]
            internal static extern void DosQvariantSetQObject(global::System.IntPtr vptr, global::System.IntPtr value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_setArray")]
            internal static extern void DosQvariantSetArray(global::System.IntPtr vptr, int size, void** array);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_isnull")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQvariantIsnull(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_delete")]
            internal static extern void DosQvariantDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_assign")]
            internal static extern void DosQvariantAssign(global::System.IntPtr vptr, global::System.IntPtr other);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_toInt")]
            internal static extern int DosQvariantToInt(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_toBool")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQvariantToBool(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_toString")]
            internal static extern sbyte* DosQvariantToString(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_toFloat")]
            internal static extern float DosQvariantToFloat(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_toDouble")]
            internal static extern double DosQvariantToDouble(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_toArray")]
            internal static extern global::System.IntPtr DosQvariantToArray(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qvariant_toQObject")]
            internal static extern global::System.IntPtr DosQvariantToQObject(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmetaobject_create")]
            internal static extern global::System.IntPtr DosQmetaobjectCreate(global::System.IntPtr superClassMetaObject, [MarshalAs(UnmanagedType.LPStr)] string className, global::System.IntPtr signalDefinitions, global::System.IntPtr slotDefinitions, global::System.IntPtr propertyDefinitions);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmetaobject_delete")]
            internal static extern void DosQmetaobjectDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractlistmodel_qmetaobject")]
            internal static extern global::System.IntPtr DosQabstractlistmodelQmetaobject();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractlistmodel_create")]
            internal static extern global::System.IntPtr DosQabstractlistmodelCreate(global::System.IntPtr callbackObject, global::System.IntPtr metaObject, global::System.IntPtr dObjectCallback, global::System.IntPtr callbacks);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractlistmodel_index")]
            internal static extern global::System.IntPtr DosQabstractlistmodelIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr parent);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractlistmodel_parent")]
            internal static extern global::System.IntPtr DosQabstractlistmodelParent(global::System.IntPtr vptr, global::System.IntPtr child);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractlistmodel_columnCount")]
            internal static extern int DosQabstractlistmodelColumnCount(global::System.IntPtr vptr, global::System.IntPtr parent);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstracttablemodel_qmetaobject")]
            internal static extern global::System.IntPtr DosQabstracttablemodelQmetaobject();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstracttablemodel_create")]
            internal static extern global::System.IntPtr DosQabstracttablemodelCreate(global::System.IntPtr callbackObject, global::System.IntPtr metaObject, global::System.IntPtr dObjectCallback, global::System.IntPtr callbacks);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstracttablemodel_index")]
            internal static extern global::System.IntPtr DosQabstracttablemodelIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr parent);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstracttablemodel_parent")]
            internal static extern global::System.IntPtr DosQabstracttablemodelParent(global::System.IntPtr vptr, global::System.IntPtr child);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_qmetaobject")]
            internal static extern global::System.IntPtr DosQabstractitemmodelQmetaobject();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_create")]
            internal static extern global::System.IntPtr DosQabstractitemmodelCreate(global::System.IntPtr callbackObject, global::System.IntPtr metaObject, global::System.IntPtr dObjectCallback, global::System.IntPtr callbacks);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_setData")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQabstractitemmodelSetData(global::System.IntPtr vptr, global::System.IntPtr index, global::System.IntPtr data, int role);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_roleNames")]
            internal static extern global::System.IntPtr DosQabstractitemmodelRoleNames(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_flags")]
            internal static extern int DosQabstractitemmodelFlags(global::System.IntPtr vptr, global::System.IntPtr index);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_headerData")]
            internal static extern global::System.IntPtr DosQabstractitemmodelHeaderData(global::System.IntPtr vptr, int section, int orientation, int role);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_hasChildren")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQabstractitemmodelHasChildren(global::System.IntPtr vptr, global::System.IntPtr parentIndex);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_hasIndex")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQabstractitemmodelHasIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr dosParentIndex);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_canFetchMore")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQabstractitemmodelCanFetchMore(global::System.IntPtr vptr, global::System.IntPtr parentIndex);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_fetchMore")]
            internal static extern void DosQabstractitemmodelFetchMore(global::System.IntPtr vptr, global::System.IntPtr parentIndex);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_beginInsertRows")]
            internal static extern void DosQabstractitemmodelBeginInsertRows(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_endInsertRows")]
            internal static extern void DosQabstractitemmodelEndInsertRows(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_beginRemoveRows")]
            internal static extern void DosQabstractitemmodelBeginRemoveRows(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_endRemoveRows")]
            internal static extern void DosQabstractitemmodelEndRemoveRows(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_beginInsertColumns")]
            internal static extern void DosQabstractitemmodelBeginInsertColumns(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_endInsertColumns")]
            internal static extern void DosQabstractitemmodelEndInsertColumns(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_beginRemoveColumns")]
            internal static extern void DosQabstractitemmodelBeginRemoveColumns(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_endRemoveColumns")]
            internal static extern void DosQabstractitemmodelEndRemoveColumns(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_beginResetModel")]
            internal static extern void DosQabstractitemmodelBeginResetModel(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_endResetModel")]
            internal static extern void DosQabstractitemmodelEndResetModel(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_dataChanged")]
            internal static extern void DosQabstractitemmodelDataChanged(global::System.IntPtr vptr, global::System.IntPtr topLeft, global::System.IntPtr bottomRight, int* rolesPtr, int rolesLength);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qabstractitemmodel_createIndex")]
            internal static extern global::System.IntPtr DosQabstractitemmodelCreateIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr data);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_qmetaobject")]
            internal static extern global::System.IntPtr DosQobjectQmetaobject();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_create")]
            internal static extern global::System.IntPtr DosQobjectCreate(global::System.IntPtr dObjectPointer, global::System.IntPtr metaObject, global::System.IntPtr dObjectCallback);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_signal_emit")]
            internal static extern void DosQobjectSignalEmit(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string name, int parametersCount, void** parameters);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_signal_connect")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQobjectSignalConnect(global::System.IntPtr senderVPtr, [MarshalAs(UnmanagedType.LPStr)] string signal, global::System.IntPtr receiverVPtr, [MarshalAs(UnmanagedType.LPStr)] string method, int type);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_signal_disconnect")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQobjectSignalDisconnect(global::System.IntPtr senderVPtr, [MarshalAs(UnmanagedType.LPStr)] string signal, global::System.IntPtr receiverVPtr, [MarshalAs(UnmanagedType.LPStr)] string method);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_objectName")]
            internal static extern sbyte* DosQobjectObjectName(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_setObjectName")]
            internal static extern void DosQobjectSetObjectName(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string name);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_delete")]
            internal static extern void DosQobjectDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_deleteLater")]
            internal static extern void DosQobjectDeleteLater(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_property")]
            internal static extern global::System.IntPtr DosQobjectProperty(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string propertyName);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qobject_setProperty")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQobjectSetProperty(global::System.IntPtr vptr, [MarshalAs(UnmanagedType.LPStr)] string propertyName, global::System.IntPtr value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_create")]
            internal static extern global::System.IntPtr DosQmodelindexCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_create_qmodelindex")]
            internal static extern global::System.IntPtr DosQmodelindexCreateQmodelindex(global::System.IntPtr index);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_delete")]
            internal static extern void DosQmodelindexDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_row")]
            internal static extern int DosQmodelindexRow(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_column")]
            internal static extern int DosQmodelindexColumn(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_isValid")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQmodelindexIsValid(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_data")]
            internal static extern global::System.IntPtr DosQmodelindexData(global::System.IntPtr vptr, int role);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_parent")]
            internal static extern global::System.IntPtr DosQmodelindexParent(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_child")]
            internal static extern global::System.IntPtr DosQmodelindexChild(global::System.IntPtr vptr, int row, int column);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_sibling")]
            internal static extern global::System.IntPtr DosQmodelindexSibling(global::System.IntPtr vptr, int row, int column);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_assign")]
            internal static extern void DosQmodelindexAssign(global::System.IntPtr l, global::System.IntPtr r);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qmodelindex_internalPointer")]
            internal static extern global::System.IntPtr DosQmodelindexInternalPointer(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qhash_int_qbytearray_create")]
            internal static extern global::System.IntPtr DosQhashIntQbytearrayCreate();

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qhash_int_qbytearray_delete")]
            internal static extern void DosQhashIntQbytearrayDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qhash_int_qbytearray_insert")]
            internal static extern void DosQhashIntQbytearrayInsert(global::System.IntPtr vptr, int key, [MarshalAs(UnmanagedType.LPStr)] string value);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qhash_int_qbytearray_value")]
            internal static extern sbyte* DosQhashIntQbytearrayValue(global::System.IntPtr vptr, int key);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qresource_register")]
            internal static extern void DosQresourceRegister([MarshalAs(UnmanagedType.LPStr)] string filename);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qurl_create")]
            internal static extern global::System.IntPtr DosQurlCreate([MarshalAs(UnmanagedType.LPStr)] string url, int parsingMode);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qurl_delete")]
            internal static extern void DosQurlDelete(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qurl_to_string")]
            internal static extern sbyte* DosQurlToString(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qurl_isValid")]
            [return: MarshalAs(UnmanagedType.I1)]
            internal static extern bool DosQurlIsValid(global::System.IntPtr vptr);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qdeclarative_qmlregistertype")]
            internal static extern int DosQdeclarativeQmlregistertype(global::System.IntPtr qmlRegisterType);

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.Cdecl,
                EntryPoint = "dos_qdeclarative_qmlregistersingletontype")]
            internal static extern int DosQdeclarativeQmlregistersingletontype(global::System.IntPtr qmlRegisterType);
        }

        /// <summary>Return the QCore::applicationDirPath</summary>
        /// <returns>The QCore::applicationDirPath as a UTF-8 string</returns>
        /// <remarks>
        /// <para>The returned string should be deleted by the calling code by using</para>
        /// <para>the dos_chararray_delete() function</para>
        /// </remarks>
        public static sbyte* DosQcoreapplicationApplicationDirPath()
        {
            var __ret = __Internal.DosQcoreapplicationApplicationDirPath();
            return __ret;
        }

        /// <summary>Create a QGuiApplication</summary>
        /// <remarks>The created QGuiApplication should be freed by calling dos_qguiapplication_delete()</remarks>
        public static void DosQguiapplicationCreate()
        {
            __Internal.DosQguiapplicationCreate();
        }

        /// <summary>Calls the QGuiApplication::exec() function of the current QGuiApplication</summary>
        /// <remarks>A QGuiApplication should have been already created through dos_qguiapplication_create()</remarks>
        public static void DosQguiapplicationExec()
        {
            __Internal.DosQguiapplicationExec();
        }

        /// <summary>Calls the QGuiApplication::quit() function of the current QGuiApplication</summary>
        /// <remarks>A QGuiApplication should have been already created through dos_qguiapplication_create()</remarks>
        public static void DosQguiapplicationQuit()
        {
            __Internal.DosQguiapplicationQuit();
        }

        /// <summary>Free the memory of the current QGuiApplication</summary>
        /// <remarks>A QGuiApplication should have been already created through dos_qguiapplication_create()</remarks>
        public static void DosQguiapplicationDelete()
        {
            __Internal.DosQguiapplicationDelete();
        }

        /// <summary>Create a QApplication</summary>
        /// <remarks>The created QApplication should be freed by calling dos_qapplication_delete()</remarks>
        public static void DosQapplicationCreate()
        {
            __Internal.DosQapplicationCreate();
        }

        /// <summary>Calls the QApplication::exec() function of the current QGuiApplication</summary>
        /// <remarks>A QApplication should have been already created through dos_qapplication_create()</remarks>
        public static void DosQapplicationExec()
        {
            __Internal.DosQapplicationExec();
        }

        /// <summary>Calls the QApplication::quit() function of the current QGuiApplication</summary>
        /// <remarks>A QApplication should have been already created through dos_qapplication_create()</remarks>
        public static void DosQapplicationQuit()
        {
            __Internal.DosQapplicationQuit();
        }

        /// <summary>Free the memory of the current QApplication</summary>
        /// <remarks>A QApplication should have been already created through dos_qapplication_create()</remarks>
        public static void DosQapplicationDelete()
        {
            __Internal.DosQapplicationDelete();
        }

        /// <summary>Create a new QQmlApplicationEngine</summary>
        /// <returns>A new QQmlApplicationEngine</returns>
        /// <remarks>The returned QQmlApplicationEngine should be freed by using dos_qqmlapplicationengine_delete(DosQQmlApplicationEngine*)</remarks>
        public static global::System.IntPtr DosQqmlapplicationengineCreate()
        {
            var __ret = __Internal.DosQqmlapplicationengineCreate();
            return __ret;
        }

        /// <summary>Calls the QQmlApplicationEngine::load function</summary>
        /// <param name="vptr">The QQmlApplicationEngine</param>
        /// <param name="filename">The file to load. The file is relative to the directory that contains the application executable</param>
        public static void DosQqmlapplicationengineLoad(global::System.IntPtr vptr, string filename)
        {
            __Internal.DosQqmlapplicationengineLoad(vptr, filename);
        }

        /// <summary>Calls the QQmlApplicationEngine::load function</summary>
        /// <param name="vptr">The QQmlApplicationEngine</param>
        /// <param name="url">The QUrl of the file to load</param>
        public static void DosQqmlapplicationengineLoadUrl(global::System.IntPtr vptr, global::System.IntPtr url)
        {
            __Internal.DosQqmlapplicationengineLoadUrl(vptr, url);
        }

        /// <summary>Calls the QQmlApplicationEngine::loadData function</summary>
        /// <param name="vptr">The QQmlApplicationEngine</param>
        /// <param name="data">The UTF-8 string of the QML to load</param>
        public static void DosQqmlapplicationengineLoadData(global::System.IntPtr vptr, string data)
        {
            __Internal.DosQqmlapplicationengineLoadData(vptr, data);
        }

        /// <summary>Calls the QQmlApplicationEngine::addImportPath function</summary>
        /// <param name="vptr">The QQmlApplicationEngine</param>
        /// <param name="path">The path to be added to the list of import paths</param>
        public static void DosQqmlapplicationengineAddImportPath(global::System.IntPtr vptr, string path)
        {
            __Internal.DosQqmlapplicationengineAddImportPath(vptr, path);
        }

        /// <summary>Calls the QQmlApplicationEngine::context</summary>
        /// <param name="vptr">The QQmlApplicationEngine</param>
        /// <returns>
        /// <para>A pointer to a QQmlContext. This should not be stored nor made available to the binded language if</para>
        /// <para>you can't guarantee that this QQmlContext should not live more that its Engine. This context is owned by</para>
        /// <para>the engine and so it should die with the engine.</para>
        /// </returns>
        public static global::System.IntPtr DosQqmlapplicationengineContext(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQqmlapplicationengineContext(vptr);
            return __ret;
        }

        /// <summary>Calls the QQMLApplicationengine::addImageProvider</summary>
        /// <param name="vptr">The QQmlApplicationEngine</param>
        /// <param name="vptr_i">A QQuickImageProvider, the QQmlApplicationEngine takes ownership of this pointer</param>
        public static void DosQqmlapplicationengineAddImageProvider(global::System.IntPtr vptr, string name, global::System.IntPtr vptr_i)
        {
            __Internal.DosQqmlapplicationengineAddImageProvider(vptr, name, vptr_i);
        }

        /// <summary>Free the memory allocated for the given QQmlApplicationEngine</summary>
        /// <param name="vptr">The QQmlApplicationEngine</param>
        public static void DosQqmlapplicationengineDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQqmlapplicationengineDelete(vptr);
        }

        /// <summary>Create a new QQuickImageProvider</summary>
        /// <returns>A new QQuickImageProvider</returns>
        /// <remarks>The returned QQuickImageProvider should be freed by using dos_qquickimageprovider_delete(DosQQuickImageProvider*) unless the QQuickImageProvider has been bound to a QQmlApplicationEngine</remarks>
        public static global::System.IntPtr DosQquickimageproviderCreate(global::DOtherSide.RequestPixmapCallback callback)
        {
            var __arg0 = callback == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(callback);
            var __ret = __Internal.DosQquickimageproviderCreate(__arg0);
            return __ret;
        }

        /// <summary>Frees a QQuickImageProvider</summary>
        public static void DosQquickimageproviderDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQquickimageproviderDelete(vptr);
        }

        /// <summary>Creates a null QPixmap</summary>
        public static global::System.IntPtr DosQpixmapCreate()
        {
            var __ret = __Internal.DosQpixmapCreate();
            return __ret;
        }

        /// <summary>Creates a QPixmap copied from another</summary>
        public static global::System.IntPtr DosQpixmapCreateQpixmap(global::System.IntPtr other)
        {
            var __ret = __Internal.DosQpixmapCreateQpixmap(other);
            return __ret;
        }

        /// <summary>Create a new QPixmap</summary>
        public static global::System.IntPtr DosQpixmapCreateWidthAndHeight(int width, int height)
        {
            var __ret = __Internal.DosQpixmapCreateWidthAndHeight(width, height);
            return __ret;
        }

        /// <summary>Frees a QPixmap</summary>
        public static void DosQpixmapDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQpixmapDelete(vptr);
        }

        /// <summary>Load image data into a QPixmap from an image file</summary>
        public static void DosQpixmapLoad(global::System.IntPtr vptr, string filepath, string format)
        {
            __Internal.DosQpixmapLoad(vptr, filepath, format);
        }

        /// <summary>Load image data into a QPixmap from a buffer</summary>
        public static void DosQpixmapLoadFromData(global::System.IntPtr vptr, byte* data, uint len)
        {
            __Internal.DosQpixmapLoadFromData(vptr, data, len);
        }

        /// <summary>Fill a QPixmap with a single color</summary>
        public static void DosQpixmapFill(global::System.IntPtr vptr, byte r, byte g, byte b, byte a)
        {
            __Internal.DosQpixmapFill(vptr, r, g, b, a);
        }

        /// <summary>Calls the QPixmap::operator=(const QPixmap&amp;) function</summary>
        /// <param name="vptr">The left hand side QPixmap</param>
        /// <param name="other">The right hand side QPixmap</param>
        public static void DosQpixmapAssign(global::System.IntPtr vptr, global::System.IntPtr other)
        {
            __Internal.DosQpixmapAssign(vptr, other);
        }

        /// <summary>Calls the QPixmap::isNull</summary>
        /// <returns>True if the QPixmap is null, false otherwise</returns>
        public static bool DosQpixmapIsNull(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQpixmapIsNull(vptr);
            return __ret;
        }

        /// <summary>Set the QtQuickControls2 style</summary>
        public static void DosQquickstyleSetStyle(string style)
        {
            __Internal.DosQquickstyleSetStyle(style);
        }

        /// <summary>Set the QtQuickControls2 fallback style</summary>
        public static void DosQquickstyleSetFallbackStyle(string style)
        {
            __Internal.DosQquickstyleSetFallbackStyle(style);
        }

        /// <summary>Create a new QQuickView</summary>
        /// <returns>A new QQuickView</returns>
        /// <remarks>The returned QQuickView should be freed by using dos_qquickview_delete(DosQQuickview*)</remarks>
        public static global::System.IntPtr DosQquickviewCreate()
        {
            var __ret = __Internal.DosQquickviewCreate();
            return __ret;
        }

        /// <summary>Calls the QQuickView::show() function</summary>
        /// <param name="vptr">The QQuickView</param>
        public static void DosQquickviewShow(global::System.IntPtr vptr)
        {
            __Internal.DosQquickviewShow(vptr);
        }

        /// <summary>Calls the QQuickView::source() function</summary>
        /// <param name="vptr">The QQuickView</param>
        /// <returns>The QQuickView source as an UTF-8 string</returns>
        /// <remarks>The returned string should be freed by using the dos_chararray_delete() function</remarks>
        public static sbyte* DosQquickviewSource(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQquickviewSource(vptr);
            return __ret;
        }

        /// <summary>Calls the QQuickView::setSource() function</summary>
        /// <param name="vptr">The QQuickView</param>
        /// <param name="url">The source QUrl</param>
        public static void DosQquickviewSetSourceUrl(global::System.IntPtr vptr, global::System.IntPtr url)
        {
            __Internal.DosQquickviewSetSourceUrl(vptr, url);
        }

        /// <summary>Calls the QQuickView::setSource() function</summary>
        /// <param name="vptr">The QQuickView</param>
        /// <param name="filename">
        /// <para>The source path as an UTF-8 string. The path is relative to the directory</para>
        /// <para>that contains the application executable</para>
        /// </param>
        public static void DosQquickviewSetSource(global::System.IntPtr vptr, string filename)
        {
            __Internal.DosQquickviewSetSource(vptr, filename);
        }

        /// <summary>Calls the QQuickView::setResizeMode() function</summary>
        /// <param name="vptr">The QQuickView</param>
        /// <param name="resizeMode">The resize mode</param>
        public static void DosQquickviewSetResizeMode(global::System.IntPtr vptr, int resizeMode)
        {
            __Internal.DosQquickviewSetResizeMode(vptr, resizeMode);
        }

        /// <summary>Free the memory allocated for the given QQuickView</summary>
        /// <param name="vptr">The QQuickView</param>
        public static void DosQquickviewDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQquickviewDelete(vptr);
        }

        /// <summary>Return the QQuickView::rootContext() as a QQuickContext</summary>
        /// <param name="vptr">The QQuickView</param>
        public static global::System.IntPtr DosQquickviewRootContext(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQquickviewRootContext(vptr);
            return __ret;
        }

        /// <summary>Calls the QQmlContext::baseUrl function</summary>
        /// <returns>The QQmlContext url as an UTF-8 string</returns>
        /// <remarks>The returned string should be freed using with the dos_chararray_delete() function</remarks>
        public static sbyte* DosQqmlcontextBaseUrl(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQqmlcontextBaseUrl(vptr);
            return __ret;
        }

        /// <summary>Sets a property inside the context</summary>
        /// <param name="vptr">The DosQQmlContext</param>
        /// <param name="name">The property name. The string is owned by the caller thus it will not be deleted by the library</param>
        /// <param name="value">The property value. The DosQVariant is owned by the caller thus it will not be deleted by the library</param>
        public static void DosQqmlcontextSetcontextproperty(global::System.IntPtr vptr, string name, global::System.IntPtr value)
        {
            __Internal.DosQqmlcontextSetcontextproperty(vptr, name, value);
        }

        /// <summary>Free the memory allocated for the given UTF-8 string</summary>
        /// <param name="ptr">The UTF-8 string to be freed</param>
        public static void DosChararrayDelete(sbyte* ptr)
        {
            __Internal.DosChararrayDelete(ptr);
        }

        /// <summary>Delete a DosQVariantArray</summary>
        public static void DosQvariantarrayDelete(global::DOtherSide.DosQVariantArray ptr)
        {
            var __arg0 = ReferenceEquals(ptr, null) ? global::System.IntPtr.Zero : ptr.__Instance;
            __Internal.DosQvariantarrayDelete(__arg0);
        }

        /// <summary>Create a new QVariant (null)</summary>
        /// <returns>The a new QVariant</returns>
        /// <remarks>The returned QVariant should be freed using dos_qvariant_delete()</remarks>
        public static global::System.IntPtr DosQvariantCreate()
        {
            var __ret = __Internal.DosQvariantCreate();
            return __ret;
        }

        /// <summary>Create a new QVariant holding an int value</summary>
        /// <param name="value">The int value</param>
        /// <returns>The a new QVariant</returns>
        /// <remarks>The returned QVariant should be freed using dos_qvariant_delete()</remarks>
        public static global::System.IntPtr DosQvariantCreateInt(int value)
        {
            var __ret = __Internal.DosQvariantCreateInt(value);
            return __ret;
        }

        /// <summary>Create a new QVariant holding a bool value</summary>
        /// <param name="value">The bool value</param>
        /// <returns>The a new QVariant</returns>
        /// <remarks>The returned QVariant should be freed using dos_qvariant_delete()</remarks>
        public static global::System.IntPtr DosQvariantCreateBool(bool value)
        {
            var __ret = __Internal.DosQvariantCreateBool(value);
            return __ret;
        }

        /// <summary>Create a new QVariant holding a string value</summary>
        /// <param name="value">The string value</param>
        /// <returns>The a new QVariant</returns>
        /// <remarks>
        /// <para>The returned QVariant should be freed using dos_qvariant_delete()</para>
        /// <para>The given string is copied inside the QVariant and will not be deleted</para>
        /// </remarks>
        public static global::System.IntPtr DosQvariantCreateString(string value)
        {
            var __ret = __Internal.DosQvariantCreateString(value);
            return __ret;
        }

        /// <summary>Create a new QVariant holding a QObject value</summary>
        /// <param name="value">The QObject value</param>
        /// <returns>The a new QVariant</returns>
        /// <remarks>The returned QVariant should be freed using dos_qvariant_delete()</remarks>
        public static global::System.IntPtr DosQvariantCreateQobject(global::System.IntPtr value)
        {
            var __ret = __Internal.DosQvariantCreateQobject(value);
            return __ret;
        }

        /// <summary>Create a new QVariant with the same value of the one given as argument</summary>
        /// <param name="value">The QVariant to which copy its value</param>
        /// <returns>The a new QVariant</returns>
        /// <remarks>The returned QVariant should be freed using dos_qvariant_delete()</remarks>
        public static global::System.IntPtr DosQvariantCreateQvariant(global::System.IntPtr value)
        {
            var __ret = __Internal.DosQvariantCreateQvariant(value);
            return __ret;
        }

        /// <summary>Create a new QVariant holding a float value</summary>
        /// <param name="value">The float value</param>
        /// <returns>The a new QVariant</returns>
        /// <remarks>The returned QVariant should be freed using dos_qvariant_delete()</remarks>
        public static global::System.IntPtr DosQvariantCreateFloat(float value)
        {
            var __ret = __Internal.DosQvariantCreateFloat(value);
            return __ret;
        }

        /// <summary>Create a new QVariant holding a double value</summary>
        /// <param name="value">The double value</param>
        /// <returns>The a new QVariant</returns>
        /// <remarks>The returned QVariant should be freed using dos_qvariant_delete()</remarks>
        public static global::System.IntPtr DosQvariantCreateDouble(double value)
        {
            var __ret = __Internal.DosQvariantCreateDouble(value);
            return __ret;
        }

        /// <summary>Create a new QVariant holding a QVariantList</summary>
        /// <param name="size">The size of the QVariant array</param>
        /// <param name="array">The array of QVariant that will be inserted in the inner QVariantList</param>
        /// <returns>A new QVariant</returns>
        /// <remarks>Theis owned by the caller thus it will not be deleted</remarks>
        public static global::System.IntPtr DosQvariantCreateArray(int size, void** array)
        {
            var __ret = __Internal.DosQvariantCreateArray(size, array);
            return __ret;
        }

        /// <summary>Calls the QVariant::setValue&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <param name="value">The int value</param>
        public static void DosQvariantSetInt(global::System.IntPtr vptr, int value)
        {
            __Internal.DosQvariantSetInt(vptr, value);
        }

        /// <summary>Calls the QVariant::setValue&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <param name="value">The bool value</param>
        public static void DosQvariantSetBool(global::System.IntPtr vptr, bool value)
        {
            __Internal.DosQvariantSetBool(vptr, value);
        }

        /// <summary>Calls the QVariant::setValue&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <param name="value">The float value</param>
        public static void DosQvariantSetFloat(global::System.IntPtr vptr, float value)
        {
            __Internal.DosQvariantSetFloat(vptr, value);
        }

        /// <summary>Calls the QVariant::setValue&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <param name="value">The double value</param>
        public static void DosQvariantSetDouble(global::System.IntPtr vptr, double value)
        {
            __Internal.DosQvariantSetDouble(vptr, value);
        }

        /// <summary>Calls the QVariant::setValue&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <param name="value">The string value</param>
        /// <remarks>The string argument is copied inside the QVariant and it will not be deleted</remarks>
        public static void DosQvariantSetString(global::System.IntPtr vptr, string value)
        {
            __Internal.DosQvariantSetString(vptr, value);
        }

        /// <summary>Calls the QVariant::setValue*&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <param name="value">The string value</param>
        /// <remarks>The string argument is copied inside the QVariant and it will not be deleted</remarks>
        public static void DosQvariantSetQObject(global::System.IntPtr vptr, global::System.IntPtr value)
        {
            __Internal.DosQvariantSetQObject(vptr, value);
        }

        /// <summary>Calls the QVariant::setValue&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <param name="size">The size of the</param>
        /// <param name="array">The array of QVariant use for setting the inner QVariantList</param>
        public static void DosQvariantSetArray(global::System.IntPtr vptr, int size, void** array)
        {
            __Internal.DosQvariantSetArray(vptr, size, array);
        }

        /// <summary>Calls the QVariant::isNull function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>True if the QVariant is null, false otherwise</returns>
        public static bool DosQvariantIsnull(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantIsnull(vptr);
            return __ret;
        }

        /// <summary>Free the memory allocated for the given QVariant</summary>
        /// <param name="vptr">The QVariant</param>
        public static void DosQvariantDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQvariantDelete(vptr);
        }

        /// <summary>Calls the QVariant::operator=(const QVariant&amp;) function</summary>
        /// <param name="vptr">The QVariant (left side)</param>
        /// <param name="other">The QVariant (right side)</param>
        public static void DosQvariantAssign(global::System.IntPtr vptr, global::System.IntPtr other)
        {
            __Internal.DosQvariantAssign(vptr, other);
        }

        /// <summary>Calls the QVariant::value&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>The int value</returns>
        public static int DosQvariantToInt(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantToInt(vptr);
            return __ret;
        }

        /// <summary>Calls the QVariant::value&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>The bool value</returns>
        public static bool DosQvariantToBool(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantToBool(vptr);
            return __ret;
        }

        /// <summary>Calls the QVariant::value&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>The string value</returns>
        /// <remarks>The returned string should be freed by using dos_chararray_delete()</remarks>
        public static sbyte* DosQvariantToString(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantToString(vptr);
            return __ret;
        }

        /// <summary>Calls the QVariant::value&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>The float value</returns>
        public static float DosQvariantToFloat(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantToFloat(vptr);
            return __ret;
        }

        /// <summary>Calls the QVariant::value&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>The double value</returns>
        public static double DosQvariantToDouble(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantToDouble(vptr);
            return __ret;
        }

        /// <summary>Calls the QVariant::value&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>The QVariantList value as an array</returns>
        public static global::DOtherSide.DosQVariantArray DosQvariantToArray(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantToArray(vptr);
            global::DOtherSide.DosQVariantArray __result0;
            if (__ret == IntPtr.Zero) __result0 = null;
            else if (global::DOtherSide.DosQVariantArray.NativeToManagedMap.ContainsKey(__ret))
                __result0 = (global::DOtherSide.DosQVariantArray)global::DOtherSide.DosQVariantArray.NativeToManagedMap[__ret];
            else __result0 = global::DOtherSide.DosQVariantArray.__CreateInstance(__ret);
            return __result0;
        }

        /// <summary>Calls the QVariant::value*&gt;() function</summary>
        /// <param name="vptr">The QVariant</param>
        /// <returns>The QObject* value</returns>
        /// <remarks>
        /// <para>Storing the returned QObject* is higly dengerous and depends on how you managed the memory</para>
        /// <para>of QObjects in the binded language</para>
        /// </remarks>
        public static global::System.IntPtr DosQvariantToQObject(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQvariantToQObject(vptr);
            return __ret;
        }

        /// <summary>Create a new QMetaObject</summary>
        /// <param name="superClassMetaObject">The superclass metaobject</param>
        /// <param name="className">The class name</param>
        /// <param name="signalDefinitions">The SignalDefinitions</param>
        /// <param name="slotDefinitions">The SlotDefinitions struct</param>
        /// <param name="propertyDefinitions">The PropertyDefinitions struct</param>
        /// <remarks>
        /// <para>The returned QMetaObject should be freed using dos_qmetaobject_delete().</para>
        /// <para>The QMetaObject should live more than the QObject it refears to.</para>
        /// <para>Depending on the implementation usually the QMetaObject should be modeled as static variable</para>
        /// <para>So with a lifetime equals to the entire application</para>
        /// </remarks>
        public static global::System.IntPtr DosQmetaobjectCreate(global::System.IntPtr superClassMetaObject, string className, global::DOtherSide.SignalDefinitions signalDefinitions, global::DOtherSide.SlotDefinitions slotDefinitions, global::DOtherSide.PropertyDefinitions propertyDefinitions)
        {
            var __arg2 = ReferenceEquals(signalDefinitions, null) ? global::System.IntPtr.Zero : signalDefinitions.__Instance;
            var __arg3 = ReferenceEquals(slotDefinitions, null) ? global::System.IntPtr.Zero : slotDefinitions.__Instance;
            var __arg4 = ReferenceEquals(propertyDefinitions, null) ? global::System.IntPtr.Zero : propertyDefinitions.__Instance;
            var __ret = __Internal.DosQmetaobjectCreate(superClassMetaObject, className, __arg2, __arg3, __arg4);
            return __ret;
        }

        /// <summary>Free the memory allocated for the given QMetaObject</summary>
        /// <param name="vptr">The QMetaObject</param>
        public static void DosQmetaobjectDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQmetaobjectDelete(vptr);
        }

        /// <summary>Return QMetaObject associated to the QAbstractListModel class</summary>
        /// <returns>The QMetaObject of the QAbstractListModel class</returns>
        /// <remarks>The returned QMetaObject should be freed using dos_qmetaobject_delete().</remarks>
        public static global::System.IntPtr DosQabstractlistmodelQmetaobject()
        {
            var __ret = __Internal.DosQabstractlistmodelQmetaobject();
            return __ret;
        }

        /// <summary>Create a new QAbstractListModel</summary>
        /// <param name="callbackObject">The pointer of QAbstractListModel in the binded language</param>
        /// <param name="metaObject">The QMetaObject for this QAbstractListModel</param>
        /// <param name="dObjectCallback">The callback for handling the properties read/write and slots execution</param>
        /// <param name="callbacks">The QAbstractItemModel callbacks</param>
        public static global::System.IntPtr DosQabstractlistmodelCreate(global::System.IntPtr callbackObject, global::System.IntPtr metaObject, global::DOtherSide.DObjectCallback dObjectCallback, global::DOtherSide.DosQAbstractItemModelCallbacks callbacks)
        {
            var __arg2 = dObjectCallback == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(dObjectCallback);
            var __arg3 = ReferenceEquals(callbacks, null) ? global::System.IntPtr.Zero : callbacks.__Instance;
            var __ret = __Internal.DosQabstractlistmodelCreate(callbackObject, metaObject, __arg2, __arg3);
            return __ret;
        }

        /// <summary>Calls the default QAbstractListModel::index() function</summary>
        public static global::System.IntPtr DosQabstractlistmodelIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr parent)
        {
            var __ret = __Internal.DosQabstractlistmodelIndex(vptr, row, column, parent);
            return __ret;
        }

        /// <summary>Calls the default QAbstractListModel::parent() function</summary>
        public static global::System.IntPtr DosQabstractlistmodelParent(global::System.IntPtr vptr, global::System.IntPtr child)
        {
            var __ret = __Internal.DosQabstractlistmodelParent(vptr, child);
            return __ret;
        }

        /// <summary>Calls the default QAbstractListModel::columnCount() function</summary>
        public static int DosQabstractlistmodelColumnCount(global::System.IntPtr vptr, global::System.IntPtr parent)
        {
            var __ret = __Internal.DosQabstractlistmodelColumnCount(vptr, parent);
            return __ret;
        }

        /// <summary>Return QMetaObject associated to the QAbstractTableModel class</summary>
        /// <returns>The QMetaObject of the QAbstractTableModel class</returns>
        /// <remarks>The returned QMetaObject should be freed using dos_qmetaobject_delete().</remarks>
        public static global::System.IntPtr DosQabstracttablemodelQmetaobject()
        {
            var __ret = __Internal.DosQabstracttablemodelQmetaobject();
            return __ret;
        }

        /// <summary>Create a new QAbstractTableModel</summary>
        /// <param name="callbackObject">The pointer of QAbstractTableModel in the binded language</param>
        /// <param name="metaObject">The QMetaObject for this QAbstractTableModel</param>
        /// <param name="dObjectCallback">The callback for handling the properties read/write and slots execution</param>
        /// <param name="callbacks">The QAbstractItemModel callbacks</param>
        public static global::System.IntPtr DosQabstracttablemodelCreate(global::System.IntPtr callbackObject, global::System.IntPtr metaObject, global::DOtherSide.DObjectCallback dObjectCallback, global::DOtherSide.DosQAbstractItemModelCallbacks callbacks)
        {
            var __arg2 = dObjectCallback == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(dObjectCallback);
            var __arg3 = ReferenceEquals(callbacks, null) ? global::System.IntPtr.Zero : callbacks.__Instance;
            var __ret = __Internal.DosQabstracttablemodelCreate(callbackObject, metaObject, __arg2, __arg3);
            return __ret;
        }

        /// <summary>Calls the default QAbstractTableModel::index() function</summary>
        public static global::System.IntPtr DosQabstracttablemodelIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr parent)
        {
            var __ret = __Internal.DosQabstracttablemodelIndex(vptr, row, column, parent);
            return __ret;
        }

        /// <summary>Calls the default QAbstractTableModel::parent() function</summary>
        public static global::System.IntPtr DosQabstracttablemodelParent(global::System.IntPtr vptr, global::System.IntPtr child)
        {
            var __ret = __Internal.DosQabstracttablemodelParent(vptr, child);
            return __ret;
        }

        /// <summary>Return QMetaObject associated to the QAbstractItemModel class</summary>
        /// <returns>The QMetaObject of the QAbstractItemModel class</returns>
        /// <remarks>The returned QMetaObject should be freed using dos_qmetaobject_delete().</remarks>
        public static global::System.IntPtr DosQabstractitemmodelQmetaobject()
        {
            var __ret = __Internal.DosQabstractitemmodelQmetaobject();
            return __ret;
        }

        /// <summary>Create a new QAbstractItemModel</summary>
        /// <param name="callbackObject">The pointer of QAbstractItemModel in the binded language</param>
        /// <param name="metaObject">The QMetaObject for this QAbstractItemModel</param>
        /// <param name="dObjectCallback">The callback for handling the properties read/write and slots execution</param>
        /// <param name="callbacks">The QAbstractItemModel callbacks</param>
        /// <remarks>The callbacks struct is copied so you can freely delete after calling this function</remarks>
        public static global::System.IntPtr DosQabstractitemmodelCreate(global::System.IntPtr callbackObject, global::System.IntPtr metaObject, global::DOtherSide.DObjectCallback dObjectCallback, global::DOtherSide.DosQAbstractItemModelCallbacks callbacks)
        {
            var __arg2 = dObjectCallback == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(dObjectCallback);
            var __arg3 = ReferenceEquals(callbacks, null) ? global::System.IntPtr.Zero : callbacks.__Instance;
            var __ret = __Internal.DosQabstractitemmodelCreate(callbackObject, metaObject, __arg2, __arg3);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::setData function</summary>
        public static bool DosQabstractitemmodelSetData(global::System.IntPtr vptr, global::System.IntPtr index, global::System.IntPtr data, int role)
        {
            var __ret = __Internal.DosQabstractitemmodelSetData(vptr, index, data, role);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::roleNames function</summary>
        public static global::System.IntPtr DosQabstractitemmodelRoleNames(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQabstractitemmodelRoleNames(vptr);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::flags function</summary>
        public static int DosQabstractitemmodelFlags(global::System.IntPtr vptr, global::System.IntPtr index)
        {
            var __ret = __Internal.DosQabstractitemmodelFlags(vptr, index);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::headerData function</summary>
        public static global::System.IntPtr DosQabstractitemmodelHeaderData(global::System.IntPtr vptr, int section, int orientation, int role)
        {
            var __ret = __Internal.DosQabstractitemmodelHeaderData(vptr, section, orientation, role);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::hasChildren function</summary>
        public static bool DosQabstractitemmodelHasChildren(global::System.IntPtr vptr, global::System.IntPtr parentIndex)
        {
            var __ret = __Internal.DosQabstractitemmodelHasChildren(vptr, parentIndex);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::hasIndex function</summary>
        public static bool DosQabstractitemmodelHasIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr dosParentIndex)
        {
            var __ret = __Internal.DosQabstractitemmodelHasIndex(vptr, row, column, dosParentIndex);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::canFetchMore function</summary>
        public static bool DosQabstractitemmodelCanFetchMore(global::System.IntPtr vptr, global::System.IntPtr parentIndex)
        {
            var __ret = __Internal.DosQabstractitemmodelCanFetchMore(vptr, parentIndex);
            return __ret;
        }

        /// <summary>Calls the QAbstractItemModel::fetchMore function</summary>
        public static void DosQabstractitemmodelFetchMore(global::System.IntPtr vptr, global::System.IntPtr parentIndex)
        {
            __Internal.DosQabstractitemmodelFetchMore(vptr, parentIndex);
        }

        /// <summary>Calls the QAbstractItemModel::beginInsertRows() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        /// <param name="parent">The parent QModelIndex</param>
        /// <param name="first">The first row in the range</param>
        /// <param name="last">The last row in the range</param>
        /// <remarks>TheQModelIndex is owned by the caller thus it will not be deleted</remarks>
        public static void DosQabstractitemmodelBeginInsertRows(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last)
        {
            __Internal.DosQabstractitemmodelBeginInsertRows(vptr, parent, first, last);
        }

        /// <summary>Calls the QAbstractItemModel::endInsertRows() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        public static void DosQabstractitemmodelEndInsertRows(global::System.IntPtr vptr)
        {
            __Internal.DosQabstractitemmodelEndInsertRows(vptr);
        }

        /// <summary>Calls the QAbstractItemModel::beginRemovetRows() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        /// <param name="parent">The parent QModelIndex</param>
        /// <param name="first">The first column in the range</param>
        /// <param name="last">The last column in the range</param>
        /// <remarks>TheQModelIndex is owned by the caller thus it will not be deleted</remarks>
        public static void DosQabstractitemmodelBeginRemoveRows(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last)
        {
            __Internal.DosQabstractitemmodelBeginRemoveRows(vptr, parent, first, last);
        }

        /// <summary>Calls the QAbstractItemModel::endRemoveRows() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        public static void DosQabstractitemmodelEndRemoveRows(global::System.IntPtr vptr)
        {
            __Internal.DosQabstractitemmodelEndRemoveRows(vptr);
        }

        /// <summary>Calls the QAbstractItemModel::beginInsertColumns() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        /// <param name="parent">The parent QModelIndex</param>
        /// <param name="first">The first column in the range</param>
        /// <param name="last">The last column in the range</param>
        /// <remarks>TheQModelIndex is owned by the caller thus it will not be deleted</remarks>
        public static void DosQabstractitemmodelBeginInsertColumns(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last)
        {
            __Internal.DosQabstractitemmodelBeginInsertColumns(vptr, parent, first, last);
        }

        /// <summary>Calls the QAbstractItemModel::endInsertColumns() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        public static void DosQabstractitemmodelEndInsertColumns(global::System.IntPtr vptr)
        {
            __Internal.DosQabstractitemmodelEndInsertColumns(vptr);
        }

        /// <summary>Calls the QAbstractItemModel::beginRemovetColumns() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        /// <param name="parent">The parent QModelIndex</param>
        /// <param name="first">The first column in the range</param>
        /// <param name="last">The last column in the range</param>
        /// <remarks>TheQModelIndex is owned by the caller thus it will not be deleted</remarks>
        public static void DosQabstractitemmodelBeginRemoveColumns(global::System.IntPtr vptr, global::System.IntPtr parent, int first, int last)
        {
            __Internal.DosQabstractitemmodelBeginRemoveColumns(vptr, parent, first, last);
        }

        /// <summary>Calls the QAbstractItemModel::endRemoveColumns() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        public static void DosQabstractitemmodelEndRemoveColumns(global::System.IntPtr vptr)
        {
            __Internal.DosQabstractitemmodelEndRemoveColumns(vptr);
        }

        /// <summary>Calls the QAbstractItemModel::beginResetModel() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        public static void DosQabstractitemmodelBeginResetModel(global::System.IntPtr vptr)
        {
            __Internal.DosQabstractitemmodelBeginResetModel(vptr);
        }

        /// <summary>Calls the QAbstractItemModel::endResetModel() function</summary>
        /// <param name="vptr">The QAbstractItemModel</param>
        public static void DosQabstractitemmodelEndResetModel(global::System.IntPtr vptr)
        {
            __Internal.DosQabstractitemmodelEndResetModel(vptr);
        }

        /// <summary>Emit the dataChanged signal</summary>
        /// <param name="vptr">The DosQAbstractItemModel pointer</param>
        /// <param name="topLeft">The topLeft DosQModelIndex</param>
        /// <param name="bottomRight">The bottomright DosQModelIndex</param>
        /// <param name="rolesPtr">The roles array</param>
        /// <param name="rolesLength">The roles array length</param>
        /// <remarks>Theandarguments are owned by the caller thus they will not be deleted</remarks>
        public static void DosQabstractitemmodelDataChanged(global::System.IntPtr vptr, global::System.IntPtr topLeft, global::System.IntPtr bottomRight, ref int rolesPtr, int rolesLength)
        {
            fixed (int* __refParamPtr3 = &rolesPtr)
            {
                var __arg3 = __refParamPtr3;
                __Internal.DosQabstractitemmodelDataChanged(vptr, topLeft, bottomRight, __arg3, rolesLength);
            }
        }

        /// <summary>Calls the QAbstractItemModel::createIndex() function</summary>
        public static global::System.IntPtr DosQabstractitemmodelCreateIndex(global::System.IntPtr vptr, int row, int column, global::System.IntPtr data)
        {
            var __ret = __Internal.DosQabstractitemmodelCreateIndex(vptr, row, column, data);
            return __ret;
        }

        /// <summary>Return QMetaObject associated to the QObject class</summary>
        /// <returns>The QMetaObject of the QObject class</returns>
        /// <remarks>The returned QObject should be freed using dos_qmetaobject_delete().</remarks>
        public static global::System.IntPtr DosQobjectQmetaobject()
        {
            var __ret = __Internal.DosQobjectQmetaobject();
            return __ret;
        }

        /// <summary>Create a new QObject</summary>
        /// <param name="dObjectPointer">The pointer of the QObject in the binded language</param>
        /// <param name="metaObject">The QMetaObject associated to the given QObject</param>
        /// <param name="dObjectCallback">
        /// <para>The callback called from QML whenever a slot or property</para>
        /// <para>should be in read, write or invoked</para>
        /// </param>
        /// <returns>A new QObject</returns>
        /// <remarks>
        /// <para>The returned QObject should be freed by calling dos_qobject_delete()</para>
        /// <para>Theis usefull for forwarding a property read/slot to the correct</para>
        /// <para>object in the binded language in the callback</para>
        /// </remarks>
        public static global::System.IntPtr DosQobjectCreate(global::System.IntPtr dObjectPointer, global::System.IntPtr metaObject, global::DOtherSide.DObjectCallback dObjectCallback)
        {
            var __arg2 = dObjectCallback == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(dObjectCallback);
            var __ret = __Internal.DosQobjectCreate(dObjectPointer, metaObject, __arg2);
            return __ret;
        }

        /// <summary>Emit a signal definited in a QObject</summary>
        /// <param name="vptr">The QObject</param>
        /// <param name="name">The signal name</param>
        /// <param name="parametersCount">The number of parameters in thearray</param>
        /// <param name="parameters">An array of DosQVariant with the values of signal arguments</param>
        public static void DosQobjectSignalEmit(global::System.IntPtr vptr, string name, int parametersCount, void** parameters)
        {
            __Internal.DosQobjectSignalEmit(vptr, name, parametersCount, parameters);
        }

        public static bool DosQobjectSignalConnect(global::System.IntPtr senderVPtr, string signal, global::System.IntPtr receiverVPtr, string method, int type)
        {
            var __ret = __Internal.DosQobjectSignalConnect(senderVPtr, signal, receiverVPtr, method, type);
            return __ret;
        }

        public static bool DosQobjectSignalDisconnect(global::System.IntPtr senderVPtr, string signal, global::System.IntPtr receiverVPtr, string method)
        {
            var __ret = __Internal.DosQobjectSignalDisconnect(senderVPtr, signal, receiverVPtr, method);
            return __ret;
        }

        /// <summary>Return the DosQObject objectName</summary>
        /// <param name="vptr">The DosQObject pointer</param>
        /// <returns>A string in UTF8 format</returns>
        /// <remarks>The returned string should be freed using the dos_chararray_delete() function</remarks>
        public static sbyte* DosQobjectObjectName(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQobjectObjectName(vptr);
            return __ret;
        }

        /// <summary>Calls the QObject::setObjectName() function</summary>
        /// <param name="vptr">The QObject</param>
        /// <param name="name">A pointer to an UTF-8 string</param>
        /// <remarks>Thestring is owned by the caller thus it will not be deleted</remarks>
        public static void DosQobjectSetObjectName(global::System.IntPtr vptr, string name)
        {
            __Internal.DosQobjectSetObjectName(vptr, name);
        }

        /// <summary>Free the memory allocated for the QObject</summary>
        /// <param name="vptr">The QObject</param>
        public static void DosQobjectDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQobjectDelete(vptr);
        }

        /// <summary>Free the memory allocated for the QObject in the next event loop cycle</summary>
        /// <param name="vptr">The QObject</param>
        public static void DosQobjectDeleteLater(global::System.IntPtr vptr)
        {
            __Internal.DosQobjectDeleteLater(vptr);
        }

        /// <summary>Read Value of a property by its name</summary>
        /// <param name="vptr">The QObject</param>
        /// <param name="propertyName">the Name of the property to be read</param>
        /// <remarks>
        /// <para>Value of the given property</para>
        /// <para>returns an empty QVariant if the propertyName does not exist</para>
        /// </remarks>
        public static global::System.IntPtr DosQobjectProperty(global::System.IntPtr vptr, string propertyName)
        {
            var __ret = __Internal.DosQobjectProperty(vptr, propertyName);
            return __ret;
        }

        /// <summary>Write Value to a property by its name</summary>
        /// <param name="vptr">The QObject</param>
        /// <param name="propertyName">The Name of the property to be written</param>
        /// <param name="value">The value to be written</param>
        /// <returns>Result as bool</returns>
        public static bool DosQobjectSetProperty(global::System.IntPtr vptr, string propertyName, global::System.IntPtr value)
        {
            var __ret = __Internal.DosQobjectSetProperty(vptr, propertyName, value);
            return __ret;
        }

        /// <summary>Create a new QModelIndex()</summary>
        /// <remarks>The returned QModelIndex should be freed by calling the dos_qmodelindex_delete() function</remarks>
        public static global::System.IntPtr DosQmodelindexCreate()
        {
            var __ret = __Internal.DosQmodelindexCreate();
            return __ret;
        }

        /// <summary>Create a new QModelIndex() copy constructed with given index</summary>
        /// <remarks>The returned QModelIndex should be freed by calling the dos_qmodelindex_delete() function</remarks>
        public static global::System.IntPtr DosQmodelindexCreateQmodelindex(global::System.IntPtr index)
        {
            var __ret = __Internal.DosQmodelindexCreateQmodelindex(index);
            return __ret;
        }

        /// <summary>Free the memory allocated for the QModelIndex</summary>
        /// <param name="vptr">The QModelIndex</param>
        public static void DosQmodelindexDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQmodelindexDelete(vptr);
        }

        /// <summary>Calls the QModelIndex::row() function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <returns>The QModelIndex row</returns>
        public static int DosQmodelindexRow(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQmodelindexRow(vptr);
            return __ret;
        }

        /// <summary>Calls the QModelIndex::column() function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <returns>The QModelIndex column</returns>
        public static int DosQmodelindexColumn(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQmodelindexColumn(vptr);
            return __ret;
        }

        /// <summary>Calls the QModelIndex::isvalid() function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <returns>True if the QModelIndex is valid, false otherwise</returns>
        public static bool DosQmodelindexIsValid(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQmodelindexIsValid(vptr);
            return __ret;
        }

        /// <summary>Calls the QModelIndex::data() function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <param name="role">The model role to which we want the data</param>
        /// <returns>The QVariant associated at the given role</returns>
        /// <remarks>The returned QVariant should be freed by calling the dos_qvariant_delete() function</remarks>
        public static global::System.IntPtr DosQmodelindexData(global::System.IntPtr vptr, int role)
        {
            var __ret = __Internal.DosQmodelindexData(vptr, role);
            return __ret;
        }

        /// <summary>Calls the QModelIndex::parent() function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <returns>The model parent QModelIndex</returns>
        /// <remarks>The returned QModelIndex should be freed by calling the dos_qmodelindex_delete() function</remarks>
        public static global::System.IntPtr DosQmodelindexParent(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQmodelindexParent(vptr);
            return __ret;
        }

        /// <summary>Calls the QModelIndex::child() function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <param name="row">The child row</param>
        /// <param name="column">The child column</param>
        /// <returns>The model child QModelIndex at the givenand</returns>
        /// <remarks>The returned QModelIndex should be freed by calling the dos_qmodelindex_delete() function</remarks>
        public static global::System.IntPtr DosQmodelindexChild(global::System.IntPtr vptr, int row, int column)
        {
            var __ret = __Internal.DosQmodelindexChild(vptr, row, column);
            return __ret;
        }

        /// <summary>Calls the QModelIndex::sibling() function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <param name="row">The sibling row</param>
        /// <param name="column">The sibling column</param>
        /// <returns>The model sibling QModelIndex at the givenand</returns>
        /// <remarks>The returned QModelIndex should be freed by calling the dos_qmodelindex_delete() function</remarks>
        public static global::System.IntPtr DosQmodelindexSibling(global::System.IntPtr vptr, int row, int column)
        {
            var __ret = __Internal.DosQmodelindexSibling(vptr, row, column);
            return __ret;
        }

        /// <summary>Calls the QModelIndex::operator=(const QModelIndex&amp;) function</summary>
        /// <param name="l">The left side QModelIndex</param>
        /// <param name="r">The right side QModelIndex</param>
        public static void DosQmodelindexAssign(global::System.IntPtr l, global::System.IntPtr r)
        {
            __Internal.DosQmodelindexAssign(l, r);
        }

        /// <summary>Calls the QModelIndex::internalPointer function</summary>
        /// <param name="vptr">The QModelIndex</param>
        /// <returns>The internal pointer</returns>
        public static global::System.IntPtr DosQmodelindexInternalPointer(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQmodelindexInternalPointer(vptr);
            return __ret;
        }

        /// <summary>Create a new QHash, QByteArray&gt;</summary>
        /// <returns>A new QHash, QByteArray&gt;</returns>
        /// <remarks>
        /// <para>The retuned QHash, QByteArray&gt; should be freed using</para>
        /// <para>the dos_qhash_int_qbytearray_delete(DosQHashIntQByteArray *) function</para>
        /// </remarks>
        public static global::System.IntPtr DosQhashIntQbytearrayCreate()
        {
            var __ret = __Internal.DosQhashIntQbytearrayCreate();
            return __ret;
        }

        /// <summary>Free the memory allocated for the QHash, QByteArray&gt;</summary>
        /// <param name="vptr">The QHash, QByteArray&gt;</param>
        public static void DosQhashIntQbytearrayDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQhashIntQbytearrayDelete(vptr);
        }

        /// <summary>Calls the QHash, QByteArray&gt;::insert() function</summary>
        /// <param name="vptr">The QHash, QByteArray&gt;</param>
        /// <param name="key">The key</param>
        /// <param name="value">The UTF-8 string</param>
        /// <remarks>Thestring is owned by the caller thus it will not be freed</remarks>
        public static void DosQhashIntQbytearrayInsert(global::System.IntPtr vptr, int key, string value)
        {
            __Internal.DosQhashIntQbytearrayInsert(vptr, key, value);
        }

        /// <summary>Calls the QHash, QByteArray&gt;::value() function</summary>
        /// <param name="vptr">The QHash, QByteArray&gt;</param>
        /// <param name="key">The key to which retrive the value</param>
        /// <returns>The UTF-8 string associated to the given value</returns>
        /// <remarks>The returned string should be freed by calling the dos_chararray_delete() function</remarks>
        public static sbyte* DosQhashIntQbytearrayValue(global::System.IntPtr vptr, int key)
        {
            var __ret = __Internal.DosQhashIntQbytearrayValue(vptr, key);
            return __ret;
        }

        /// <summary>Register the given .rcc (compiled) file in the resource system</summary>
        public static void DosQresourceRegister(string filename)
        {
            __Internal.DosQresourceRegister(filename);
        }

        /// <summary>Create a new QUrl</summary>
        /// <param name="url">The UTF-8 string that represents an url</param>
        /// <param name="parsingMode">The parsing mode</param>
        /// <remarks>The retuned QUrl should be freed using the dos_qurl_delete() function</remarks>
        public static global::System.IntPtr DosQurlCreate(string url, int parsingMode)
        {
            var __ret = __Internal.DosQurlCreate(url, parsingMode);
            return __ret;
        }

        /// <summary>Free the memory allocated for the QUrl</summary>
        /// <param name="vptr">The QUrl to be freed</param>
        public static void DosQurlDelete(global::System.IntPtr vptr)
        {
            __Internal.DosQurlDelete(vptr);
        }

        /// <summary>Calls the QUrl::toString() function</summary>
        /// <param name="vptr">The QUrl</param>
        /// <returns>The url as an UTF-8 string</returns>
        /// <remarks>The returned string should be freed using the dos_chararray_delete() function</remarks>
        public static sbyte* DosQurlToString(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQurlToString(vptr);
            return __ret;
        }

        /// <summary>Class the QUrl::isValid() function</summary>
        /// <param name="vptr">The QUrl</param>
        /// <returns>True if the QUrl is valid, false otherwise</returns>
        public static bool DosQurlIsValid(global::System.IntPtr vptr)
        {
            var __ret = __Internal.DosQurlIsValid(vptr);
            return __ret;
        }

        /// <summary>Register a type in order to be instantiable from QML</summary>
        /// <returns>
        /// <para>An integer value that represents the registration ID in the</para>
        /// <para>qml environment</para>
        /// </returns>
        /// <remarks>Theis owned by the caller thus it will not be freed</remarks>
        public static int DosQdeclarativeQmlregistertype(global::DOtherSide.QmlRegisterType qmlRegisterType)
        {
            var __arg0 = ReferenceEquals(qmlRegisterType, null) ? global::System.IntPtr.Zero : qmlRegisterType.__Instance;
            var __ret = __Internal.DosQdeclarativeQmlregistertype(__arg0);
            return __ret;
        }

        /// <summary>Register a singleton type in order to be accessible from QML</summary>
        /// <returns>An integer value that represents the registration ID in the</returns>
        /// <remarks>Theis owned by the caller thus it will not be freed</remarks>
        public static int DosQdeclarativeQmlregistersingletontype(global::DOtherSide.QmlRegisterType qmlRegisterType)
        {
            var __arg0 = ReferenceEquals(qmlRegisterType, null) ? global::System.IntPtr.Zero : qmlRegisterType.__Instance;
            var __ret = __Internal.DosQdeclarativeQmlregistersingletontype(__arg0);
            return __ret;
        }
    }

    /// <summary>A pointer to a QVariant</summary>
    /// <summary>A pointer to a QModelIndex</summary>
    /// <summary>A pointer to a QAbstractItemModel</summary>
    /// <summary>A pointer to a QAbstractListModel</summary>
    /// <summary>A pointer to a QAbstractTableModel</summary>
    /// <summary>A pointer to a QQmlApplicationEngine</summary>
    /// <summary>A pointer to a QQuickView</summary>
    /// <summary>A pointer to a QQmlContext</summary>
    /// <summary>A pointer to a QHash,QByteArray&gt;</summary>
    /// <summary>A pointer to a QUrl</summary>
    /// <summary>A pointer to a QMetaObject</summary>
    /// <summary>A pointer to a QObject</summary>
    /// <summary>A pointer to a QQuickImageProvider</summary>
    /// <summary>A pointer to a QPixmap</summary>
    /// <summary>A pixmap callback to be supplied to an image provider</summary>
    /// <param name="id">Image source id</param>
    /// <param name="width">pointer to the width of the image</param>
    /// <param name="height">pointer to the height of the image</param>
    /// <param name="requestedHeight">sourceSize.height attribute</param>
    /// <param name="requestedWidth">sourcesSize.width attribute</param>
    /// <param name="result">The result QPixmap. This should be assigned from the binded language</param>
    /// <remarks>
    /// <para>is the trailing part of an image source url for example &quot;image://_id&gt;/&gt;</para>
    /// <para>Thearg is an out parameter so it <c>shouldn't</c> be deleted. See the dos_qpixmap_assign</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void RequestPixmapCallback([MarshalAs(UnmanagedType.LPStr)] string id, int* width, int* height, int requestedWidth, int requestedHeight, global::System.IntPtr result);

    /// <summary>Called when a property is readed/written or a slot should be executed</summary>
    /// <param name="self">The pointer of QObject in the binded language</param>
    /// <param name="slotName">The slotName as DosQVariant</param>
    /// <param name="argc">The number of arguments</param>
    /// <param name="argv">An array of DosQVariant pointers</param>
    /// <remarks>
    /// <para>The first argument ofis always the return value of the called slot.</para>
    /// <para>In other words the length of argv is always 1 + number of arguments ofThe return value should be assigned and modified by calling the dos_qvariant_assign()</para>
    /// <para>or other dos_qvariant_set... setters.</para>
    /// <para>Theis owned by the library thus it <c>shouldn't</c> be deleted</para>
    /// <para>Thearray is owned by the library thus it <c>shouldn't</c> be deleted</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void DObjectCallback(global::System.IntPtr self, global::System.IntPtr slotName, int argc, void** argv);

    /// <summary>Called when the QAbstractItemModel::rowCount method must be executed</summary>
    /// <param name="self">The pointer of the QAbstractItemModel in the binded language</param>
    /// <param name="index">The parent DosQModelIndex</param>
    /// <param name="result">The rowCount result. This must be deferenced and filled from the binded language</param>
    /// <remarks>
    /// <para>TheQModelIndex is owned by the DOtherSide library thus it <c>shouldn't</c> be deleted</para>
    /// <para>Thearg is an out parameter so it <c>shouldn't</c> be deleted</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void RowCountCallback(global::System.IntPtr self, global::System.IntPtr parent, int* result);

    /// <summary>Called when the QAbstractItemModel::columnCount method must be executed</summary>
    /// <param name="self">The pointer to the QAbstractItemModel in the binded language</param>
    /// <param name="index">The parent DosQModelIndex</param>
    /// <param name="result">The rowCount result. This must be deferenced and filled from the binded language</param>
    /// <remarks>
    /// <para>TheQModelIndex is owned by the DOtherSide library thus it <c>shouldn't</c> be deleted</para>
    /// <para>Thearg is an out parameter so it <c>shouldn't</c> be deleted</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void ColumnCountCallback(global::System.IntPtr self, global::System.IntPtr parent, int* result);

    /// <summary>Called when the QAbstractItemModel::data method must be executed</summary>
    /// <param name="self">The pointer to the QAbstractItemModel in the binded language</param>
    /// <param name="index">The DosQModelIndex to which we request the data</param>
    /// <param name="result">The DosQVariant result. This must be deferenced and filled from the binded language.</param>
    /// <remarks>
    /// <para>TheQModelIndex is owned by the DOtherSide library thus it <c>shouldn't</c> be deleted</para>
    /// <para>Thearg is an out parameter so it <c>shouldn't</c> be deleted</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void DataCallback(global::System.IntPtr self, global::System.IntPtr index, int role, global::System.IntPtr result);

    /// <summary>Called when the QAbstractItemModel::setData method must be executed</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void SetDataCallback(global::System.IntPtr self, global::System.IntPtr index, global::System.IntPtr value, int role, bool* result);

    /// <summary>Called when the QAbstractItemModel::roleNames method must be executed</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void RoleNamesCallback(global::System.IntPtr self, global::System.IntPtr result);

    /// <summary>Called when the QAbstractItemModel::flags method must be called</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void FlagsCallback(global::System.IntPtr self, global::System.IntPtr index, int* result);

    /// <summary>Called when the QAbstractItemModel::headerData method must be called</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void HeaderDataCallback(global::System.IntPtr self, int section, int orientation, int role, global::System.IntPtr result);

    /// <summary>Called when the QAbstractItemModel::index method must be called</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void IndexCallback(global::System.IntPtr self, int row, int column, global::System.IntPtr parent, global::System.IntPtr result);

    /// <summary>Called when the QAbstractItemModel::parent method must be called</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void ParentCallback(global::System.IntPtr self, global::System.IntPtr child, global::System.IntPtr result);

    /// <summary>Called when the QAbstractItemModel::hasChildren method must be called</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void HasChildrenCallback(global::System.IntPtr self, global::System.IntPtr parent, bool* result);

    /// <summary>Called when the QAbstractItemModel::canFetchMore method must be called</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void CanFetchMoreCallback(global::System.IntPtr self, global::System.IntPtr parent, bool* result);

    /// <summary>Called when the QAbstractItemModel::fetchMore method must be called</summary>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void FetchMoreCallback(global::System.IntPtr self, global::System.IntPtr parent);

    /// <summary>Callback called from QML for creating a registered type</summary>
    /// <param name="id">
    /// <para>This is the id for which we are requesting the creation.</para>
    /// <para>This is the same value that was returned during registration through the calls</para>
    /// <para>to dos_qdeclarative_qmlregistertype() or dos_qdeclarative_qmlregistersingletontype()</para>
    /// </param>
    /// <param name="wrapper">
    /// <para>This is the QObject wrapper that should be stored by the binded language and to which forward the</para>
    /// <para>DOtherSide calls</para>
    /// </param>
    /// <param name="bindedQObject">This should be deferenced and assigned with the pointer of the QObject modeled in the binded language</param>
    /// <param name="dosQObject">This should be deferenced and assigned with the DosQObject pointer you gained from calling the dos_qobject_create() function</param>
    /// <remarks>
    /// <para>When a type is created through the QML engine a new QObjectis created. This becomes a proxy</para>
    /// <para>between the &quot;default&quot; QObject created through dos_qobject_create() and the QML engine. This imply that implementation</para>
    /// <para>for this callback should swap the DosQObject* stored in the binded language with the wrapper. At the end the wrapper</para>
    /// <para>becomes the owner of the original &quot;default&quot; DosQObject. Furthermore if the binding language is garbage collected you</para>
    /// <para>should disable (pin/ref) the original object and unref in the DeleteDObject() callback. Since the wrapper has been created</para>
    /// <para>from QML is QML that expect to free the memory for it thus it shouldn't be destroyed by the QObject in the binded language.</para>
    /// <para>An example of implementation in pseudocode is:</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void CreateDObject(int id, global::System.IntPtr wrapper, void** bindedQObject, void** dosQObject);

    /// <summary>Callback invoked from QML for deleting a registered type</summary>
    /// <param name="id">This is the type id for which we are requesting the deletion</param>
    /// <param name="bindedQObject">
    /// <para>This is the pointer you given in the CreateDObject callback and you can use it</para>
    /// <para>for obtaining the QObject in your binded language. This allows you to unpin/unref it or delete it.</para>
    /// </param>
    /// <remarks>
    /// <para>This is called when the wrapper gets deleted from QML. The implementation should unref/unpin</para>
    /// <para>theor delete it in the case of languages without GC</para>
    /// </remarks>
    [SuppressUnmanagedCodeSecurity, UnmanagedFunctionPointer(global::System.Runtime.InteropServices.CallingConvention.Cdecl)]
    public unsafe delegate void DeleteDObject(int id, global::System.IntPtr bindedQObject);

    /// <summary>Store an array of QVariant</summary>
    /// <remarks>
    /// <para>This struct should be freed by calling dos_qvariantarray_delete(DosQVariantArray *ptr). This in turn</para>
    /// <para>cleans up the internal array</para>
    /// </remarks>
    public unsafe partial class DosQVariantArray : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int size;

            [FieldOffset(4)]
            internal global::System.IntPtr data;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0DosQVariantArray@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.DosQVariantArray> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.DosQVariantArray>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.DosQVariantArray __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.DosQVariantArray(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.DosQVariantArray __CreateInstance(global::DOtherSide.DosQVariantArray.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.DosQVariantArray(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.DosQVariantArray.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.DosQVariantArray.__Internal));
            *(global::DOtherSide.DosQVariantArray.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private DosQVariantArray(global::DOtherSide.DosQVariantArray.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected DosQVariantArray(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public DosQVariantArray()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.DosQVariantArray.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public DosQVariantArray(global::DOtherSide.DosQVariantArray _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.DosQVariantArray.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.DosQVariantArray.__Internal*)__Instance) = *((global::DOtherSide.DosQVariantArray.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.DosQVariantArray __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int Size
        {
            get
            {
                return ((global::DOtherSide.DosQVariantArray.__Internal*)__Instance)->size;
            }

            set
            {
                ((global::DOtherSide.DosQVariantArray.__Internal*)__Instance)->size = value;
            }
        }

        public void** Data
        {
            get
            {
                var instance = (global::DOtherSide.DosQVariantArray.__Internal*)__Instance;
                return (void**) instance->data;
            }

            set
            {
                ((global::DOtherSide.DosQVariantArray.__Internal*)__Instance)->data = (global::System.IntPtr)value;
            }
        }
    }

    /// <summary>The data needed for registering a custom type in the QML environment</summary>
    /// <remarks>
    /// <para>This is used from dos_qdeclarative_qmlregistertype() and dos_qdeclarative_qmlregistersingletontype() calls.</para>
    /// <para>dos_qdeclarative_qmlregistertype()</para>
    /// <para>dos_qdeclarative_qmlregistersingletontype()</para>
    /// <para>All string and objects are considered to be owned by the caller thus they'll</para>
    /// <para>not be freed</para>
    /// </remarks>
    public unsafe partial class QmlRegisterType : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 28)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int major;

            [FieldOffset(4)]
            internal int minor;

            [FieldOffset(8)]
            internal global::System.IntPtr uri;

            [FieldOffset(12)]
            internal global::System.IntPtr qml;

            [FieldOffset(16)]
            internal global::System.IntPtr staticMetaObject;

            [FieldOffset(20)]
            internal global::System.IntPtr createDObject;

            [FieldOffset(24)]
            internal global::System.IntPtr deleteDObject;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0QmlRegisterType@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.QmlRegisterType> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.QmlRegisterType>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.QmlRegisterType __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.QmlRegisterType(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.QmlRegisterType __CreateInstance(global::DOtherSide.QmlRegisterType.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.QmlRegisterType(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.QmlRegisterType.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.QmlRegisterType.__Internal));
            *(global::DOtherSide.QmlRegisterType.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private QmlRegisterType(global::DOtherSide.QmlRegisterType.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected QmlRegisterType(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public QmlRegisterType()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.QmlRegisterType.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public QmlRegisterType(global::DOtherSide.QmlRegisterType _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.QmlRegisterType.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.QmlRegisterType.__Internal*)__Instance) = *((global::DOtherSide.QmlRegisterType.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.QmlRegisterType __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int Major
        {
            get
            {
                return ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->major;
            }

            set
            {
                ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->major = value;
            }
        }

        public int Minor
        {
            get
            {
                return ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->minor;
            }

            set
            {
                ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->minor = value;
            }
        }

        public string Uri
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->uri);
            }

            set
            {
                ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->uri = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public string Qml
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->qml);
            }

            set
            {
                ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->qml = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public global::System.IntPtr StaticMetaObject
        {
            get
            {
                return ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->staticMetaObject;
            }

            set
            {
                ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->staticMetaObject = (global::System.IntPtr)value;
            }
        }

        public global::DOtherSide.CreateDObject CreateDObject
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->createDObject;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.CreateDObject)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.CreateDObject));
            }

            set
            {
                ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->createDObject = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.DeleteDObject DeleteDObject
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->deleteDObject;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.DeleteDObject)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.DeleteDObject));
            }

            set
            {
                ((global::DOtherSide.QmlRegisterType.__Internal*)__Instance)->deleteDObject = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }
    }

    /// <summary>Represents a parameter definition</summary>
    public unsafe partial class ParameterDefinition : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr name;

            [FieldOffset(4)]
            internal int metaType;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0ParameterDefinition@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.ParameterDefinition> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.ParameterDefinition>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.ParameterDefinition __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.ParameterDefinition(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.ParameterDefinition __CreateInstance(global::DOtherSide.ParameterDefinition.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.ParameterDefinition(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.ParameterDefinition.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.ParameterDefinition.__Internal));
            *(global::DOtherSide.ParameterDefinition.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private ParameterDefinition(global::DOtherSide.ParameterDefinition.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected ParameterDefinition(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public ParameterDefinition()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.ParameterDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public ParameterDefinition(global::DOtherSide.ParameterDefinition _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.ParameterDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.ParameterDefinition.__Internal*)__Instance) = *((global::DOtherSide.ParameterDefinition.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.ParameterDefinition __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public string Name
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.ParameterDefinition.__Internal*)__Instance)->name);
            }

            set
            {
                ((global::DOtherSide.ParameterDefinition.__Internal*)__Instance)->name = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public int MetaType
        {
            get
            {
                return ((global::DOtherSide.ParameterDefinition.__Internal*)__Instance)->metaType;
            }

            set
            {
                ((global::DOtherSide.ParameterDefinition.__Internal*)__Instance)->metaType = value;
            }
        }
    }

    /// <summary>Represents a single signal definition</summary>
    public unsafe partial class SignalDefinition : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 12)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr name;

            [FieldOffset(4)]
            internal int parametersCount;

            [FieldOffset(8)]
            internal global::System.IntPtr parameters;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0SignalDefinition@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SignalDefinition> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SignalDefinition>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.SignalDefinition __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.SignalDefinition(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.SignalDefinition __CreateInstance(global::DOtherSide.SignalDefinition.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.SignalDefinition(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.SignalDefinition.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SignalDefinition.__Internal));
            *(global::DOtherSide.SignalDefinition.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private SignalDefinition(global::DOtherSide.SignalDefinition.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected SignalDefinition(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public SignalDefinition()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SignalDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public SignalDefinition(global::DOtherSide.SignalDefinition _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SignalDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.SignalDefinition.__Internal*)__Instance) = *((global::DOtherSide.SignalDefinition.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.SignalDefinition __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public string Name
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->name);
            }

            set
            {
                ((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->name = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public int ParametersCount
        {
            get
            {
                return ((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->parametersCount;
            }

            set
            {
                ((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->parametersCount = value;
            }
        }

        public global::DOtherSide.ParameterDefinition Parameters
        {
            get
            {
                global::DOtherSide.ParameterDefinition __result0;
                if (((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->parameters == IntPtr.Zero) __result0 = null;
                else if (global::DOtherSide.ParameterDefinition.NativeToManagedMap.ContainsKey(((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->parameters))
                    __result0 = (global::DOtherSide.ParameterDefinition)global::DOtherSide.ParameterDefinition.NativeToManagedMap[((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->parameters];
                else __result0 = global::DOtherSide.ParameterDefinition.__CreateInstance(((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->parameters);
                return __result0;
            }

            set
            {
                ((global::DOtherSide.SignalDefinition.__Internal*)__Instance)->parameters = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    /// <summary>Represents a set of signal definitions</summary>
    public unsafe partial class SignalDefinitions : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int count;

            [FieldOffset(4)]
            internal global::System.IntPtr definitions;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0SignalDefinitions@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SignalDefinitions> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SignalDefinitions>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.SignalDefinitions __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.SignalDefinitions(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.SignalDefinitions __CreateInstance(global::DOtherSide.SignalDefinitions.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.SignalDefinitions(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.SignalDefinitions.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SignalDefinitions.__Internal));
            *(global::DOtherSide.SignalDefinitions.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private SignalDefinitions(global::DOtherSide.SignalDefinitions.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected SignalDefinitions(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public SignalDefinitions()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SignalDefinitions.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public SignalDefinitions(global::DOtherSide.SignalDefinitions _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SignalDefinitions.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.SignalDefinitions.__Internal*)__Instance) = *((global::DOtherSide.SignalDefinitions.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.SignalDefinitions __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int Count
        {
            get
            {
                return ((global::DOtherSide.SignalDefinitions.__Internal*)__Instance)->count;
            }

            set
            {
                ((global::DOtherSide.SignalDefinitions.__Internal*)__Instance)->count = value;
            }
        }

        public global::DOtherSide.SignalDefinition Definitions
        {
            get
            {
                global::DOtherSide.SignalDefinition __result0;
                if (((global::DOtherSide.SignalDefinitions.__Internal*)__Instance)->definitions == IntPtr.Zero) __result0 = null;
                else if (global::DOtherSide.SignalDefinition.NativeToManagedMap.ContainsKey(((global::DOtherSide.SignalDefinitions.__Internal*)__Instance)->definitions))
                    __result0 = (global::DOtherSide.SignalDefinition)global::DOtherSide.SignalDefinition.NativeToManagedMap[((global::DOtherSide.SignalDefinitions.__Internal*)__Instance)->definitions];
                else __result0 = global::DOtherSide.SignalDefinition.__CreateInstance(((global::DOtherSide.SignalDefinitions.__Internal*)__Instance)->definitions);
                return __result0;
            }

            set
            {
                ((global::DOtherSide.SignalDefinitions.__Internal*)__Instance)->definitions = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    /// <summary>Represents a single slot definition</summary>
    public unsafe partial class SlotDefinition : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 16)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr name;

            [FieldOffset(4)]
            internal int returnMetaType;

            [FieldOffset(8)]
            internal int parametersCount;

            [FieldOffset(12)]
            internal global::System.IntPtr parameters;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0SlotDefinition@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SlotDefinition> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SlotDefinition>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.SlotDefinition __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.SlotDefinition(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.SlotDefinition __CreateInstance(global::DOtherSide.SlotDefinition.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.SlotDefinition(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.SlotDefinition.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SlotDefinition.__Internal));
            *(global::DOtherSide.SlotDefinition.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private SlotDefinition(global::DOtherSide.SlotDefinition.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected SlotDefinition(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public SlotDefinition()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SlotDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public SlotDefinition(global::DOtherSide.SlotDefinition _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SlotDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.SlotDefinition.__Internal*)__Instance) = *((global::DOtherSide.SlotDefinition.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.SlotDefinition __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public string Name
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->name);
            }

            set
            {
                ((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->name = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public int ReturnMetaType
        {
            get
            {
                return ((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->returnMetaType;
            }

            set
            {
                ((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->returnMetaType = value;
            }
        }

        public int ParametersCount
        {
            get
            {
                return ((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->parametersCount;
            }

            set
            {
                ((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->parametersCount = value;
            }
        }

        public global::DOtherSide.ParameterDefinition Parameters
        {
            get
            {
                global::DOtherSide.ParameterDefinition __result0;
                if (((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->parameters == IntPtr.Zero) __result0 = null;
                else if (global::DOtherSide.ParameterDefinition.NativeToManagedMap.ContainsKey(((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->parameters))
                    __result0 = (global::DOtherSide.ParameterDefinition)global::DOtherSide.ParameterDefinition.NativeToManagedMap[((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->parameters];
                else __result0 = global::DOtherSide.ParameterDefinition.__CreateInstance(((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->parameters);
                return __result0;
            }

            set
            {
                ((global::DOtherSide.SlotDefinition.__Internal*)__Instance)->parameters = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    /// <summary>Represents a set of slot definitions</summary>
    public unsafe partial class SlotDefinitions : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int count;

            [FieldOffset(4)]
            internal global::System.IntPtr definitions;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0SlotDefinitions@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SlotDefinitions> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.SlotDefinitions>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.SlotDefinitions __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.SlotDefinitions(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.SlotDefinitions __CreateInstance(global::DOtherSide.SlotDefinitions.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.SlotDefinitions(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.SlotDefinitions.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SlotDefinitions.__Internal));
            *(global::DOtherSide.SlotDefinitions.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private SlotDefinitions(global::DOtherSide.SlotDefinitions.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected SlotDefinitions(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public SlotDefinitions()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SlotDefinitions.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public SlotDefinitions(global::DOtherSide.SlotDefinitions _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.SlotDefinitions.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.SlotDefinitions.__Internal*)__Instance) = *((global::DOtherSide.SlotDefinitions.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.SlotDefinitions __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int Count
        {
            get
            {
                return ((global::DOtherSide.SlotDefinitions.__Internal*)__Instance)->count;
            }

            set
            {
                ((global::DOtherSide.SlotDefinitions.__Internal*)__Instance)->count = value;
            }
        }

        public global::DOtherSide.SlotDefinition Definitions
        {
            get
            {
                global::DOtherSide.SlotDefinition __result0;
                if (((global::DOtherSide.SlotDefinitions.__Internal*)__Instance)->definitions == IntPtr.Zero) __result0 = null;
                else if (global::DOtherSide.SlotDefinition.NativeToManagedMap.ContainsKey(((global::DOtherSide.SlotDefinitions.__Internal*)__Instance)->definitions))
                    __result0 = (global::DOtherSide.SlotDefinition)global::DOtherSide.SlotDefinition.NativeToManagedMap[((global::DOtherSide.SlotDefinitions.__Internal*)__Instance)->definitions];
                else __result0 = global::DOtherSide.SlotDefinition.__CreateInstance(((global::DOtherSide.SlotDefinitions.__Internal*)__Instance)->definitions);
                return __result0;
            }

            set
            {
                ((global::DOtherSide.SlotDefinitions.__Internal*)__Instance)->definitions = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    /// <summary>Represents a single property definition</summary>
    public unsafe partial class PropertyDefinition : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 20)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr name;

            [FieldOffset(4)]
            internal int propertyMetaType;

            [FieldOffset(8)]
            internal global::System.IntPtr readSlot;

            [FieldOffset(12)]
            internal global::System.IntPtr writeSlot;

            [FieldOffset(16)]
            internal global::System.IntPtr notifySignal;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0PropertyDefinition@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.PropertyDefinition> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.PropertyDefinition>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.PropertyDefinition __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.PropertyDefinition(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.PropertyDefinition __CreateInstance(global::DOtherSide.PropertyDefinition.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.PropertyDefinition(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.PropertyDefinition.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.PropertyDefinition.__Internal));
            *(global::DOtherSide.PropertyDefinition.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private PropertyDefinition(global::DOtherSide.PropertyDefinition.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected PropertyDefinition(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public PropertyDefinition()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.PropertyDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public PropertyDefinition(global::DOtherSide.PropertyDefinition _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.PropertyDefinition.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.PropertyDefinition.__Internal*)__Instance) = *((global::DOtherSide.PropertyDefinition.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.PropertyDefinition __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public string Name
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->name);
            }

            set
            {
                ((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->name = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public int PropertyMetaType
        {
            get
            {
                return ((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->propertyMetaType;
            }

            set
            {
                ((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->propertyMetaType = value;
            }
        }

        public string ReadSlot
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->readSlot);
            }

            set
            {
                ((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->readSlot = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public string WriteSlot
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->writeSlot);
            }

            set
            {
                ((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->writeSlot = Marshal.StringToHGlobalAnsi(value);
            }
        }

        public string NotifySignal
        {
            get
            {
                return Marshal.PtrToStringAnsi(((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->notifySignal);
            }

            set
            {
                ((global::DOtherSide.PropertyDefinition.__Internal*)__Instance)->notifySignal = Marshal.StringToHGlobalAnsi(value);
            }
        }
    }

    /// <summary>Represents a set of property definitions</summary>
    public unsafe partial class PropertyDefinitions : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal int count;

            [FieldOffset(4)]
            internal global::System.IntPtr definitions;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0PropertyDefinitions@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.PropertyDefinitions> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.PropertyDefinitions>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.PropertyDefinitions __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.PropertyDefinitions(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.PropertyDefinitions __CreateInstance(global::DOtherSide.PropertyDefinitions.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.PropertyDefinitions(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.PropertyDefinitions.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.PropertyDefinitions.__Internal));
            *(global::DOtherSide.PropertyDefinitions.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private PropertyDefinitions(global::DOtherSide.PropertyDefinitions.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected PropertyDefinitions(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public PropertyDefinitions()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.PropertyDefinitions.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public PropertyDefinitions(global::DOtherSide.PropertyDefinitions _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.PropertyDefinitions.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance) = *((global::DOtherSide.PropertyDefinitions.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.PropertyDefinitions __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public int Count
        {
            get
            {
                return ((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance)->count;
            }

            set
            {
                ((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance)->count = value;
            }
        }

        public global::DOtherSide.PropertyDefinition Definitions
        {
            get
            {
                global::DOtherSide.PropertyDefinition __result0;
                if (((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance)->definitions == IntPtr.Zero) __result0 = null;
                else if (global::DOtherSide.PropertyDefinition.NativeToManagedMap.ContainsKey(((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance)->definitions))
                    __result0 = (global::DOtherSide.PropertyDefinition)global::DOtherSide.PropertyDefinition.NativeToManagedMap[((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance)->definitions];
                else __result0 = global::DOtherSide.PropertyDefinition.__CreateInstance(((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance)->definitions);
                return __result0;
            }

            set
            {
                ((global::DOtherSide.PropertyDefinitions.__Internal*)__Instance)->definitions = ReferenceEquals(value, null) ? global::System.IntPtr.Zero : value.__Instance;
            }
        }
    }

    /// <summary>Incapsulate all the QAbstractItemModel callbacks</summary>
    public unsafe partial class DosQAbstractItemModelCallbacks : IDisposable
    {
        [StructLayout(LayoutKind.Explicit, Size = 48)]
        public partial struct __Internal
        {
            [FieldOffset(0)]
            internal global::System.IntPtr rowCount;

            [FieldOffset(4)]
            internal global::System.IntPtr columnCount;

            [FieldOffset(8)]
            internal global::System.IntPtr data;

            [FieldOffset(12)]
            internal global::System.IntPtr setData;

            [FieldOffset(16)]
            internal global::System.IntPtr roleNames;

            [FieldOffset(20)]
            internal global::System.IntPtr flags;

            [FieldOffset(24)]
            internal global::System.IntPtr headerData;

            [FieldOffset(28)]
            internal global::System.IntPtr index;

            [FieldOffset(32)]
            internal global::System.IntPtr parent;

            [FieldOffset(36)]
            internal global::System.IntPtr hasChildren;

            [FieldOffset(40)]
            internal global::System.IntPtr canFetchMore;

            [FieldOffset(44)]
            internal global::System.IntPtr fetchMore;

            [SuppressUnmanagedCodeSecurity]
            [DllImport("DOtherSide", CallingConvention = global::System.Runtime.InteropServices.CallingConvention.ThisCall,
                EntryPoint = "??0DosQAbstractItemModelCallbacks@@QAE@ABU0@@Z")]
            internal static extern global::System.IntPtr cctor(global::System.IntPtr instance, global::System.IntPtr _0);
        }

        public global::System.IntPtr __Instance { get; protected set; }

        protected int __PointerAdjustment;
        internal static readonly global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.DosQAbstractItemModelCallbacks> NativeToManagedMap = new global::System.Collections.Concurrent.ConcurrentDictionary<IntPtr, global::DOtherSide.DosQAbstractItemModelCallbacks>();
        protected void*[] __OriginalVTables;

        protected bool __ownsNativeInstance;

        internal static global::DOtherSide.DosQAbstractItemModelCallbacks __CreateInstance(global::System.IntPtr native, bool skipVTables = false)
        {
            return new global::DOtherSide.DosQAbstractItemModelCallbacks(native.ToPointer(), skipVTables);
        }

        internal static global::DOtherSide.DosQAbstractItemModelCallbacks __CreateInstance(global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal native, bool skipVTables = false)
        {
            return new global::DOtherSide.DosQAbstractItemModelCallbacks(native, skipVTables);
        }

        private static void* __CopyValue(global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal native)
        {
            var ret = Marshal.AllocHGlobal(sizeof(global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal));
            *(global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)ret = native;
            return ret.ToPointer();
        }

        private DosQAbstractItemModelCallbacks(global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal native, bool skipVTables = false)
            : this(__CopyValue(native), skipVTables)
        {
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        protected DosQAbstractItemModelCallbacks(void* native, bool skipVTables = false)
        {
            if (native == null)
                return;
            __Instance = new global::System.IntPtr(native);
        }

        public DosQAbstractItemModelCallbacks()
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
        }

        public DosQAbstractItemModelCallbacks(global::DOtherSide.DosQAbstractItemModelCallbacks _0)
        {
            __Instance = Marshal.AllocHGlobal(sizeof(global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal));
            __ownsNativeInstance = true;
            NativeToManagedMap[__Instance] = this;
            *((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance) = *((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)_0.__Instance);
        }

        public void Dispose()
        {
            Dispose(disposing: true);
        }

        public virtual void Dispose(bool disposing)
        {
            if (__Instance == IntPtr.Zero)
                return;
            global::DOtherSide.DosQAbstractItemModelCallbacks __dummy;
            NativeToManagedMap.TryRemove(__Instance, out __dummy);
            if (__ownsNativeInstance)
                Marshal.FreeHGlobal(__Instance);
            __Instance = IntPtr.Zero;
        }

        public global::DOtherSide.RowCountCallback RowCount
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->rowCount;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.RowCountCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.RowCountCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->rowCount = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.ColumnCountCallback ColumnCount
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->columnCount;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.ColumnCountCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.ColumnCountCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->columnCount = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.DataCallback Data
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->data;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.DataCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.DataCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->data = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.SetDataCallback SetData
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->setData;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.SetDataCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.SetDataCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->setData = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.RoleNamesCallback RoleNames
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->roleNames;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.RoleNamesCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.RoleNamesCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->roleNames = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.FlagsCallback Flags
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->flags;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.FlagsCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.FlagsCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->flags = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.HeaderDataCallback HeaderData
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->headerData;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.HeaderDataCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.HeaderDataCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->headerData = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.IndexCallback Index
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->index;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.IndexCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.IndexCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->index = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.ParentCallback Parent
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->parent;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.ParentCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.ParentCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->parent = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.HasChildrenCallback HasChildren
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->hasChildren;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.HasChildrenCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.HasChildrenCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->hasChildren = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.CanFetchMoreCallback CanFetchMore
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->canFetchMore;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.CanFetchMoreCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.CanFetchMoreCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->canFetchMore = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }

        public global::DOtherSide.FetchMoreCallback FetchMore
        {
            get
            {
                var __ptr0 = ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->fetchMore;
                return __ptr0 == IntPtr.Zero ? null : (global::DOtherSide.FetchMoreCallback)Marshal.GetDelegateForFunctionPointer(__ptr0, typeof(global::DOtherSide.FetchMoreCallback));
            }

            set
            {
                ((global::DOtherSide.DosQAbstractItemModelCallbacks.__Internal*)__Instance)->fetchMore = value == null ? global::System.IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value);
            }
        }
    }
}