diff --git a/src/net/Qml.Net/Internal/Qml/NetJsValue.cs b/src/net/Qml.Net/Internal/Qml/NetJsValue.cs
index 2d78ac55..693b0603 100644
--- a/src/net/Qml.Net/Internal/Qml/NetJsValue.cs
+++ b/src/net/Qml.Net/Internal/Qml/NetJsValue.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Dynamic;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Qml
 {
@@ -197,36 +198,50 @@ namespace Qml.Net.Internal.Qml
         [NativeSymbol(Entrypoint = "net_js_value_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr jsValue);
 
         [NativeSymbol(Entrypoint = "net_js_value_isCallable")]
         public IsCallableDel IsCallable { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte IsCallableDel(IntPtr jsValue);
 
         [NativeSymbol(Entrypoint = "net_js_value_isArray")]
         public IsArrayDel IsArray { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte IsArrayDel(IntPtr jsValue);
 
         [NativeSymbol(Entrypoint = "net_js_value_call")]
         public CallDel Call { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CallDel(IntPtr jsValue, IntPtr parameters);
 
         [NativeSymbol(Entrypoint = "net_js_value_getProperty")]
         public GetPropertyDel GetProperty { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetPropertyDel(IntPtr jsValue, [MarshalAs(UnmanagedType.LPWStr)] string propertyName);
 
         [NativeSymbol(Entrypoint = "net_js_value_getItemAtIndex")]
         public GetItemAtIndexDel GetItemAtIndex { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetItemAtIndexDel(IntPtr jsValue, int arrayIndex);
 
         [NativeSymbol(Entrypoint = "net_js_value_setProperty")]
         public SetPropertyDel SetProperty { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetPropertyDel(IntPtr jsValue, [MarshalAs(UnmanagedType.LPWStr)] string propertyName, IntPtr value);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Qml/NetQObject.cs b/src/net/Qml.Net/Internal/Qml/NetQObject.cs
index 100b112b..97a910cb 100644
--- a/src/net/Qml.Net/Internal/Qml/NetQObject.cs
+++ b/src/net/Qml.Net/Internal/Qml/NetQObject.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Dynamic;
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal.Types;
 
 namespace Qml.Net.Internal.Qml
@@ -253,36 +254,50 @@ namespace Qml.Net.Internal.Qml
         [NativeSymbol(Entrypoint = "net_qobject_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr qObject);
         
         [NativeSymbol(Entrypoint = "net_qobject_getProperty")]
         public GetPropertyDel GetProperty { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetPropertyDel(IntPtr qObject, [MarshalAs(UnmanagedType.LPWStr)] string propertyName, ref byte result);
 
         [NativeSymbol(Entrypoint = "net_qobject_setProperty")]
         public SetPropertyDel SetProperty { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr SetPropertyDel(IntPtr qObject, [MarshalAs(UnmanagedType.LPWStr)] string propertyName, IntPtr netVariant, ref byte result);
 
         [NativeSymbol(Entrypoint = "net_qobject_invokeMethod")]
         public InvokeMethodDel InvokeMethod { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr InvokeMethodDel(IntPtr qObject, [MarshalAs(UnmanagedType.LPWStr)] string methodName, IntPtr parameters, ref byte result);
         
         [NativeSymbol(Entrypoint = "net_qobject_attachSignal")]
         public AttachSignalDel AttachSignal { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr AttachSignalDel(IntPtr qObject, [MarshalAs(UnmanagedType.LPWStr)] string signalName, IntPtr del, ref byte result);
         
         [NativeSymbol(Entrypoint = "net_qobject_attachNotifySignal")]
         public AttachNotifySignalDel AttachNotifySignal { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr AttachNotifySignalDel(IntPtr qObject, [MarshalAs(UnmanagedType.LPWStr)] string signalName, IntPtr del, ref byte result);
 
         [NativeSymbol(Entrypoint = "net_qobject_buildQObject")]
         public BuildQObjectDel BuildQObject { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr BuildQObjectDel([MarshalAs(UnmanagedType.LPWStr)] string className, IntPtr constructorParameters);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Qml/NetQObjectSignalConnection.cs b/src/net/Qml.Net/Internal/Qml/NetQObjectSignalConnection.cs
index 1d5c1eeb..8cc03f2a 100644
--- a/src/net/Qml.Net/Internal/Qml/NetQObjectSignalConnection.cs
+++ b/src/net/Qml.Net/Internal/Qml/NetQObjectSignalConnection.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Qml
 {
@@ -20,6 +22,8 @@ namespace Qml.Net.Internal.Qml
         [NativeSymbol(Entrypoint = "net_qobject_signal_handler_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr signalHandler);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Qml/NetTestHelper.cs b/src/net/Qml.Net/Internal/Qml/NetTestHelper.cs
index 6cf3c973..07b56d2a 100644
--- a/src/net/Qml.Net/Internal/Qml/NetTestHelper.cs
+++ b/src/net/Qml.Net/Internal/Qml/NetTestHelper.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Qml
 {
@@ -15,7 +16,9 @@ namespace Qml.Net.Internal.Qml
     {
         [NativeSymbol(Entrypoint = "net_test_helper_runQml")]
         public RunQmlDel RunQml { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void RunQmlDel(IntPtr qmlEngine, [MarshalAs(UnmanagedType.LPWStr)]string qml);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Qml/NetVariant.cs b/src/net/Qml.Net/Internal/Qml/NetVariant.cs
index ee25e87a..31bb5d5a 100644
--- a/src/net/Qml.Net/Internal/Qml/NetVariant.cs
+++ b/src/net/Qml.Net/Internal/Qml/NetVariant.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal.Types;
 
 namespace Qml.Net.Internal.Qml
@@ -257,161 +258,225 @@ namespace Qml.Net.Internal.Qml
         [NativeSymbol(Entrypoint = "net_variant_create")]
         public CreateDel Create { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel();
 
         [NativeSymbol(Entrypoint = "net_variant_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_getVariantType")]
         public GetVariantTypeDel GetVariantType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate NetVariantType GetVariantTypeDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setNetReference")]
         public SetNetReferenceDel SetNetReference { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetNetReferenceDel(IntPtr variant, IntPtr instance);
 
         [NativeSymbol(Entrypoint = "net_variant_getNetReference")]
         public GetNetReferenceDel GetNetReference { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetNetReferenceDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setBool")]
         public SetBoolDel SetBool { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetBoolDel(IntPtr variant, byte value);
 
         [NativeSymbol(Entrypoint = "net_variant_getBool")]
         public GetBoolDel GetBool { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetBoolDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setChar")]
         public SetCharDel SetChar { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetCharDel(IntPtr variant, ushort value);
 
         [NativeSymbol(Entrypoint = "net_variant_getChar")]
         public GetCharDel GetChar { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate ushort GetCharDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setInt")]
         public SetIntDel SetInt { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetIntDel(IntPtr variant, int value);
 
         [NativeSymbol(Entrypoint = "net_variant_getInt")]
         public GetIntDel GetInt { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetIntDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setUInt")]
         public SetUIntDel SetUInt { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetUIntDel(IntPtr variant, uint value);
 
         [NativeSymbol(Entrypoint = "net_variant_getUInt")]
         public GetUIntDel GetUInt { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate uint GetUIntDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setLong")]
         public SetLongDel SetLong { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetLongDel(IntPtr variant, long value);
 
         [NativeSymbol(Entrypoint = "net_variant_getLong")]
         public GetLongDel GetLong { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate long GetLongDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setULong")]
         public SetULongDel SetULong { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetULongDel(IntPtr variant, ulong value);
 
         [NativeSymbol(Entrypoint = "net_variant_getULong")]
         public GetULongDel GetULong { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate ulong GetULongDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setFloat")]
         public SetFloatDel SetFloat { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetFloatDel(IntPtr variant, float value);
 
         [NativeSymbol(Entrypoint = "net_variant_getFloat")]
         public GetFloatDel GetFloat { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate float GetFloatDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setDouble")]
         public SetDoubleDel SetDouble { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetDoubleDel(IntPtr variant, double value);
 
         [NativeSymbol(Entrypoint = "net_variant_getDouble")]
         public GetDoubleDel GetDouble { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate double GetDoubleDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setString")]
         public SetStringDel SetString { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetStringDel(IntPtr variant, [MarshalAs(UnmanagedType.LPWStr)]string value);
 
         [NativeSymbol(Entrypoint = "net_variant_getString")]
         public GetStringDel GetString { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetStringDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setDateTime")]
         public SetDateTimeDel SetDateTime { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetDateTimeDel(IntPtr variant, ref DateTimeContainer dateTime);
 
         [NativeSymbol(Entrypoint = "net_variant_getDateTime")]
         public GetDateTimeDel GetDateTime { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void GetDateTimeDel(IntPtr variant, ref DateTimeContainer dateTime);
 
         [NativeSymbol(Entrypoint = "net_variant_setJsValue")]
         public SetJsValueDel SetJsValue { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetJsValueDel(IntPtr variant, IntPtr jsValue);
 
         [NativeSymbol(Entrypoint = "net_variant_getJsValue")]
         public GetJsValueDel GetJsValue { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetJsValueDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setQObject")]
         public SetQObjectDel SetQObject { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetQObjectDel(IntPtr variant, IntPtr jsValue);
 
         [NativeSymbol(Entrypoint = "net_variant_getQObject")]
         public GetQObjectDel GetQObject { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetQObjectDel(IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_setNetVariantList")]
         public SetNetVariantListDel SetNetVariantList { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetNetVariantListDel(IntPtr variant, IntPtr variantList);
         
         [NativeSymbol(Entrypoint = "net_variant_getNetVariantList")]
         public GetNetVariantListDel GetNetVariantList { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetNetVariantListDel(IntPtr variant);
         
         [NativeSymbol(Entrypoint = "net_variant_clear")]
         public ClearDel Clear { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void ClearDel(IntPtr variant);
     }
 
diff --git a/src/net/Qml.Net/Internal/Qml/NetVariantList.cs b/src/net/Qml.Net/Internal/Qml/NetVariantList.cs
index 4f400b04..47cff3b3 100644
--- a/src/net/Qml.Net/Internal/Qml/NetVariantList.cs
+++ b/src/net/Qml.Net/Internal/Qml/NetVariantList.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Qml
 {
@@ -61,36 +63,50 @@ namespace Qml.Net.Internal.Qml
         [NativeSymbol(Entrypoint = "net_variant_list_create")]
         public CreateDel Create { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel();
 
         [NativeSymbol(Entrypoint = "net_variant_list_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr list);
 
         [NativeSymbol(Entrypoint = "net_variant_list_count")]
         public CountDel Count { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int CountDel(IntPtr list);
 
         [NativeSymbol(Entrypoint = "net_variant_list_add")]
         public AddDel Add { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddDel(IntPtr list, IntPtr variant);
 
         [NativeSymbol(Entrypoint = "net_variant_list_get")]
         public GetDel Get { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetDel(IntPtr list, int index);
 
         [NativeSymbol(Entrypoint = "net_variant_list_remove")]
         public RemoveDel Remove { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void RemoveDel(IntPtr list, int index);
 
         [NativeSymbol(Entrypoint = "net_variant_list_clear")]
         public ClearDel Clear { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void ClearDel(IntPtr list);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Types/Callbacks.cs b/src/net/Qml.Net/Internal/Types/Callbacks.cs
index 48f09785..118206ce 100644
--- a/src/net/Qml.Net/Internal/Types/Callbacks.cs
+++ b/src/net/Qml.Net/Internal/Types/Callbacks.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Dynamic;
 using System.Runtime.InteropServices;
+using System.Security;
 using System.Threading.Tasks;
 
 namespace Qml.Net.Internal.Types
@@ -31,31 +32,43 @@ namespace Qml.Net.Internal.Types
         [NativeSymbol(Entrypoint = "type_info_callbacks_registerCallbacks")]
         public RegisterCallbacksDel RegisterCallbacks { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void RegisterCallbacksDel(ref Callbacks callbacks);
 
         [NativeSymbol(Entrypoint = "type_info_callbacks_isTypeValid")]
         public IsTypeValidDel IsTypeValid { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate bool IsTypeValidDel([MarshalAs(UnmanagedType.LPWStr)]string typeName);
 
         [NativeSymbol(Entrypoint = "type_info_callbacks_releaseNetReferenceGCHandle")]
         public ReleaseNetReferenceDel ReleaseNetReference { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void ReleaseNetReferenceDel(UInt64 objectId);
 
         [NativeSymbol(Entrypoint = "type_info_callbacks_releaseNetDelegateGCHandle")]
         public ReleaseNetDelegateGCHandleDel ReleaseNetDelegateGCHandle { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void ReleaseNetDelegateGCHandleDel(IntPtr handle);
 
         [NativeSymbol(Entrypoint = "type_info_callbacks_instantiateType")]
         public InstantiateTypeDel InstantiateType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr InstantiateTypeDel(IntPtr type);
 
         [NativeSymbol(Entrypoint = "type_info_callbacks_invokeMethod")]
         public InvokeMethodDel InvokeMethod { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void InvokeMethodDel(IntPtr method, IntPtr target, IntPtr variants, IntPtr result);
     }
 
@@ -115,51 +128,67 @@ namespace Qml.Net.Internal.Types
         InvokeDelegateDelegate _invokeDelegateDelegate;
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate byte IsTypeValidDelegate([MarshalAs(UnmanagedType.LPWStr)]string typeName);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void CreateLazyTypeInfoDelegate(IntPtr typeInfo);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void LoadTypeInfoDelegate(IntPtr typeInfo);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void CallComponentCompletedDelegate(IntPtr target);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void CallObjectDestroyedDelegate(IntPtr target);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void ReleaseNetReferenceDelegate(UInt64 objectId);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void ReleaseNetDelegateGCHandleDelegate(IntPtr handle);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate IntPtr InstantiateTypeDelgate(IntPtr type);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void ReadPropertyDelegate(IntPtr property, IntPtr target, IntPtr indexParameter, IntPtr result);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void WritePropertyDelegate(IntPtr property, IntPtr target, IntPtr indexParameter, IntPtr value);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void InvokeMethodDelegate(IntPtr method, IntPtr target, IntPtr variants, IntPtr result);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void GCCollectDelegate(int maxGeneration);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate byte RaiseNetSignalsDelegate(IntPtr target, [MarshalAs(UnmanagedType.LPWStr)]string signalName, IntPtr parameters);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void AwaitTaskDelegate(IntPtr target, IntPtr successCallback, IntPtr failureCallback);
 
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate byte SerializeDelegate(IntPtr instance, IntPtr result);
         
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        [SuppressUnmanagedCodeSecurity]
         delegate void InvokeDelegateDelegate(IntPtr del, IntPtr parameters);
 
         public CallbacksImpl(ICallbacks callbacks)
diff --git a/src/net/Qml.Net/Internal/Types/NetDelegate.cs b/src/net/Qml.Net/Internal/Types/NetDelegate.cs
index 5362cc64..08d29d77 100644
--- a/src/net/Qml.Net/Internal/Types/NetDelegate.cs
+++ b/src/net/Qml.Net/Internal/Types/NetDelegate.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Types
 {
@@ -40,17 +41,23 @@ namespace Qml.Net.Internal.Types
     {
         [NativeSymbol(Entrypoint = "delegate_create")]
         public CreateDel Create { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel(IntPtr handle);
-
+
         [NativeSymbol(Entrypoint = "delegate_destroy")]
         public DestroyDel Destroy { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr del);
 
         [NativeSymbol(Entrypoint = "delegate_getHandle")]
         public GetHandleDel GetHandle { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetHandleDel(IntPtr del);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Types/NetMethodInfo.cs b/src/net/Qml.Net/Internal/Types/NetMethodInfo.cs
index 2ebb3e49..7630973c 100644
--- a/src/net/Qml.Net/Internal/Types/NetMethodInfo.cs
+++ b/src/net/Qml.Net/Internal/Types/NetMethodInfo.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Types
 {
@@ -112,66 +113,92 @@ namespace Qml.Net.Internal.Types
         [NativeSymbol(Entrypoint = "method_info_parameter_destroy")]
         public DestroyParameterDel DestroyParameter { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyParameterDel(IntPtr parameter);
 
         [NativeSymbol(Entrypoint = "method_info_parameter_getName")]
         public GetParameterNameDel GetParameterName { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetParameterNameDel(IntPtr methodParameter);
 
         [NativeSymbol(Entrypoint = "method_info_parameter_getType")]
         public GetParameterTypeDel GetParameterType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetParameterTypeDel(IntPtr methodParameter);
 
         [NativeSymbol(Entrypoint = "method_info_create")]
         public CreateDel Create { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel(IntPtr parentTypeInfo, [MarshalAs(UnmanagedType.LPWStr)]string methodName, IntPtr returnTypeInfo, byte isStatic);
 
         [NativeSymbol(Entrypoint = "method_info_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetIdDel(IntPtr method);
 
         [NativeSymbol(Entrypoint = "method_info_getId")]
         public GetIdDel GetId { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetParentTypeDel(IntPtr method);
 
         [NativeSymbol(Entrypoint = "method_info_getParentType")]
         public GetParentTypeDel GetParentType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr methodInfo);
 
         [NativeSymbol(Entrypoint = "method_info_getMethodName")]
         public GetMethodNameDel GetMethodName { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetMethodNameDel(IntPtr method);
 
         [NativeSymbol(Entrypoint = "method_info_getReturnType")]
         public GetReturnTypeDel GetReturnType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetReturnTypeDel(IntPtr method);
 
         [NativeSymbol(Entrypoint = "method_info_isStatic")]
         public GetIsStaticDel GetIsStatic { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetIsStaticDel(IntPtr method);
 
         [NativeSymbol(Entrypoint = "method_info_addParameter")]
         public AddParameterDel AddParameter { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddParameterDel(IntPtr method, [MarshalAs(UnmanagedType.LPWStr)]string name, IntPtr type);
 
         [NativeSymbol(Entrypoint = "method_info_getParameterCount")]
         public GetParameterCountDel GetParameterCount { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetParameterCountDel(IntPtr method);
 
         [NativeSymbol(Entrypoint = "method_info_getParameter")]
         public GetParameterDel GetParameter { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetParameterDel(IntPtr method, int index);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Types/NetPropertyInfo.cs b/src/net/Qml.Net/Internal/Types/NetPropertyInfo.cs
index c8c85b60..d846c6b1 100644
--- a/src/net/Qml.Net/Internal/Types/NetPropertyInfo.cs
+++ b/src/net/Qml.Net/Internal/Types/NetPropertyInfo.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Types
 {
@@ -107,6 +108,8 @@ namespace Qml.Net.Internal.Types
         [NativeSymbol(Entrypoint = "property_info_create")]
         public CreateDel Create { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel(
             IntPtr parentType,
             [MarshalAs(UnmanagedType.LPWStr)]string methodName,
@@ -118,61 +121,85 @@ namespace Qml.Net.Internal.Types
         [NativeSymbol(Entrypoint = "property_info_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_getId")]
         public GetIdDel GetId { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetIdDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_getParentType")]
         public GetParentTypeDel GetParentType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetParentTypeDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_getPropertyName")]
         public GetPropertyNameDel GetPropertyName { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetPropertyNameDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_getReturnType")]
         public GetReturnTypeDel GetReturnType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetReturnTypeDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_canRead")]
         public GetCanReadDel GetCanRead { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetCanReadDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_canWrite")]
         public GetCanWriteDel GetCanWrite { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetCanWriteDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_getNotifySignal")]
         public GetNotifySignalDel GetNotifySignal { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetNotifySignalDel(IntPtr property);
 
         [NativeSymbol(Entrypoint = "property_info_setNotifySignal")]
         public SetNotifySignalDel SetNotifySignal { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetNotifySignalDel(IntPtr property, IntPtr signal);
 
         [NativeSymbol(Entrypoint = "property_info_addIndexParameter")]
         public AddIndexParameterDel AddIndexParameter { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddIndexParameterDel(IntPtr method, [MarshalAs(UnmanagedType.LPWStr)]string name, IntPtr type);
 
         [NativeSymbol(Entrypoint = "property_info_getIndexParameterCount")]
         public GetIndexParameterCountDel GetIndexParameterCount { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetIndexParameterCountDel(IntPtr method);
 
         [NativeSymbol(Entrypoint = "property_info_getIndexParameter")]
         public GetIndexParameterDel GetIndexParameter { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetIndexParameterDel(IntPtr method, int index);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Types/NetReference.cs b/src/net/Qml.Net/Internal/Types/NetReference.cs
index b39dcd51..67f3a65d 100644
--- a/src/net/Qml.Net/Internal/Types/NetReference.cs
+++ b/src/net/Qml.Net/Internal/Types/NetReference.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal.Qml;
 
 namespace Qml.Net.Internal.Types
@@ -111,26 +112,36 @@ namespace Qml.Net.Internal.Types
         [NativeSymbol(Entrypoint = "net_instance_create")]
         public CreateDel Create { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel(UInt64 objectId, IntPtr type);
 
         [NativeSymbol(Entrypoint = "net_instance_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr instance);
 
         [NativeSymbol(Entrypoint = "net_instance_clone")]
         public CloneDel Clone { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CloneDel(IntPtr instance);
 
         [NativeSymbol(Entrypoint = "net_instance_getObjectId")]
         public GetObjectIdDel GetObjectId { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate UInt64 GetObjectIdDel(IntPtr instance);
 
         [NativeSymbol(Entrypoint = "net_instance_activateSignal")]
         public ActivateSignalDel ActivateSignal { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte ActivateSignalDel(IntPtr instance, [MarshalAs(UnmanagedType.LPWStr)]string signalName, IntPtr variants);
     }
 
diff --git a/src/net/Qml.Net/Internal/Types/NetSignalInfo.cs b/src/net/Qml.Net/Internal/Types/NetSignalInfo.cs
index 234bb5fc..d620e1ce 100644
--- a/src/net/Qml.Net/Internal/Types/NetSignalInfo.cs
+++ b/src/net/Qml.Net/Internal/Types/NetSignalInfo.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Types
 {
@@ -41,37 +42,51 @@ namespace Qml.Net.Internal.Types
     {
         [NativeSymbol(Entrypoint = "signal_info_create")]
         public CreateDel Create { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel(IntPtr parentType, [MarshalAs(UnmanagedType.LPWStr)] string name);
-
+
         [NativeSymbol(Entrypoint = "signal_info_destroy")]
         public DestroyDel Destroy { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr signal);
 
         [NativeSymbol(Entrypoint = "signal_info_getParentType")]
         public GetParentTypeDel GetParentType { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetParentTypeDel(IntPtr signal);
-
+
         [NativeSymbol(Entrypoint = "signal_info_getName")]
         public GetNameDel GetName { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetNameDel(IntPtr signal);
 
         [NativeSymbol(Entrypoint = "signal_info_addParameter")]
         public AddParameterDel AddParameter { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddParameterDel(IntPtr signal, NetVariantType type);
-
+
         [NativeSymbol(Entrypoint = "signal_info_getParameterCount")]
         public GetParameterCountDel GetParameterCount { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetParameterCountDel(IntPtr signal);
-
+
         [NativeSymbol(Entrypoint = "signal_info_getParameter")]
         public GetParameterDel GetParameter { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate NetVariantType GetParameterDel(IntPtr signal, int index);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Types/NetTypeInfo.cs b/src/net/Qml.Net/Internal/Types/NetTypeInfo.cs
index cab87e17..5086c601 100644
--- a/src/net/Qml.Net/Internal/Types/NetTypeInfo.cs
+++ b/src/net/Qml.Net/Internal/Types/NetTypeInfo.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Types
 {
@@ -141,171 +142,239 @@ namespace Qml.Net.Internal.Types
         [NativeSymbol(Entrypoint = "type_info_create")]
         public CreateDel Create { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel([MarshalAs(UnmanagedType.LPWStr)]string fullTypeName);
 
         [NativeSymbol(Entrypoint = "type_info_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetIdDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getId")]
         public GetIdDel GetId { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getFullTypeName")]
         public GetFullTypeNameDel GetFullTypeName { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetFullTypeNameDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getBaseType")]
         public GetBaseTypeDel GetBaseType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetBaseTypeDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_setBaseType")]
         public SetBaseTypeDel SetBaseType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetBaseTypeDel(IntPtr netTypeInfo, [MarshalAs(UnmanagedType.LPWStr)]string baseType);
 
         [NativeSymbol(Entrypoint = "type_info_setClassName")]
         public SetClassNameDel SetClassName { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetClassNameDel(IntPtr netTypeInfo, [MarshalAs(UnmanagedType.LPWStr)]string className);
 
         [NativeSymbol(Entrypoint = "type_info_getClassName")]
         public GetClassNameDel GetClassName { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetClassNameDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_setPrefVariantType")]
         public SetPrefVariantTypeDel SetPrefVariantType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetPrefVariantTypeDel(IntPtr netTypeInfo, NetVariantType variantType);
 
         [NativeSymbol(Entrypoint = "type_info_getPrefVariantType")]
         public GetPrefVariantTypeDel GetPrefVariantType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate NetVariantType GetPrefVariantTypeDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getIsArray")]
         public GetIsArrayDel GetIsArray { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetIsArrayDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_setIsArray")]
         public SetIsArrayDel SetIsArray { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetIsArrayDel(IntPtr netTypeInfo, byte isArray);
 
         [NativeSymbol(Entrypoint = "type_info_getIsList")]
         public GetIsListDel GetIsList { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetIsListDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_setIsList")]
         public SetIsListDel SetIsList { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetIsListDel(IntPtr netTypeInfo, byte isList);
 
         [NativeSymbol(Entrypoint = "type_info_getHasComponentCompleted")]
         public GetHasComponentCompeltedDel GetHasComponentCompleted { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetHasComponentCompeltedDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_setHasComponentCompleted")]
         public SetHasComponentCompletedDel SetHasComponentCompleted { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetHasComponentCompletedDel(IntPtr netTypeInfo, byte isList);
 
         [NativeSymbol(Entrypoint = "type_info_getHasObjectDestroyed")]
         public GetHasObjectDestroyedDel GetHasObjectDestroyed { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte GetHasObjectDestroyedDel(IntPtr netTypeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_setHasObjectDestroyed")]
         public SetHasObjectDestroyedDel SetHasObjectDestroyed { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetHasObjectDestroyedDel(IntPtr netTypeInfo, byte isList);
 
         [NativeSymbol(Entrypoint = "type_info_addMethod")]
         public AddMethodDel AddMethod { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddMethodDel(IntPtr typeInfo, IntPtr methodInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getMethodCount")]
         public GetMethodCountDel GetMethodCount { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetMethodCountDel(IntPtr typeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getMethodInfo")]
         public GetMethodInfoDel GetMethodInfo { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetMethodInfoDel(IntPtr typeInfo, int index);
 
         [NativeSymbol(Entrypoint = "type_info_getLocalMethodCount")]
         public GetLocalMethodCountDel GetLocalMethodCount { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetLocalMethodCountDel(IntPtr typeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getLocalMethodInfo")]
         public GetLocalMethodInfoDel GetLocalMethodInfo { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetLocalMethodInfoDel(IntPtr typeInfo, int index);
 
         [NativeSymbol(Entrypoint = "type_info_getStaticMethodCount")]
         public GetStaticMethodCountDel GetStaticMethodCount { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetStaticMethodCountDel(IntPtr typeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getStaticMethodInfo")]
         public GetStaticMethodInfoDel GetStaticMethodInfo { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetStaticMethodInfoDel(IntPtr typeInfo, int index);
 
         [NativeSymbol(Entrypoint = "type_info_addProperty")]
         public AddPropertyDel AddProperty { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddPropertyDel(IntPtr typeInfo, IntPtr property);
 
         [NativeSymbol(Entrypoint = "type_info_getPropertyCount")]
         public GetPropertyCountDel GetPropertyCount { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetPropertyCountDel(IntPtr typeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getProperty")]
         public GetPropertyDel GetProperty { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetPropertyDel(IntPtr typeInfo, int index);
 
         [NativeSymbol(Entrypoint = "type_info_addSignal")]
         public AddSignalDel AddSignal { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddSignalDel(IntPtr typeInfo, IntPtr signal);
 
         [NativeSymbol(Entrypoint = "type_info_getSignalCount")]
         public GetSignalCountDel GetSignalCount { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetSignalCountDel(IntPtr typeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_getSignal")]
         public GetSignalDel GetSignal { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetSignalDel(IntPtr typeInfo, int index);
 
         [NativeSymbol(Entrypoint = "type_info_isLoaded")]
         public IsLoadedDel IsLoaded { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte IsLoadedDel(IntPtr typeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_isLoading")]
         public IsLoadingDel IsLoading { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte IsLoadingDel(IntPtr typeInfo);
 
         [NativeSymbol(Entrypoint = "type_info_ensureLoaded")]
         public EnsureLoadedDel EnsureLoaded { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void EnsureLoadedDel(IntPtr typeInfo);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Internal/Types/NetTypeManager.cs b/src/net/Qml.Net/Internal/Types/NetTypeManager.cs
index 4409d630..78262db4 100644
--- a/src/net/Qml.Net/Internal/Types/NetTypeManager.cs
+++ b/src/net/Qml.Net/Internal/Types/NetTypeManager.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 
 namespace Qml.Net.Internal.Types
 {
@@ -26,7 +27,9 @@ namespace Qml.Net.Internal.Types
     {
         [NativeSymbol(Entrypoint = "type_manager_getTypeInfo")]
         public GetTypeInfoDel GetTypeInfo { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetTypeInfoDel([MarshalAs(UnmanagedType.LPWStr)]string fullTypeName);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/QCoreApplication.cs b/src/net/Qml.Net/QCoreApplication.cs
index c072333c..4249eb54 100644
--- a/src/net/Qml.Net/QCoreApplication.cs
+++ b/src/net/Qml.Net/QCoreApplication.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
+using System.Security;
 using System.Threading;
 using System.Threading.Tasks;
 using Qml.Net.Internal;
@@ -338,86 +339,120 @@ namespace Qml.Net
         [NativeSymbol(Entrypoint = "qapp_fromExisting")]
         public FromExistingDel FromExisting { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr FromExistingDel(IntPtr rawPointer);
 
         [NativeSymbol(Entrypoint = "qapp_create")]
         public CreateDel Create { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel(IntPtr args, int flags, int type);
 
         [NativeSymbol(Entrypoint = "qapp_destroy")]
         public DestroyDel Destroy { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr container);
 
         [NativeSymbol(Entrypoint = "qapp_getType")]
         public GetAppTypeDel GetAppType { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int GetAppTypeDel(IntPtr container, IntPtr rawPointer);
 
         [NativeSymbol(Entrypoint = "qapp_processEvents")]
         public ProcessEventsDel ProcessEvents { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void ProcessEventsDel(int flags);
 
         [NativeSymbol(Entrypoint = "qapp_processEventsWithTimeout")]
         public ProcessEventsWithTimeoutDel ProcessEventsWithTimeout { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void ProcessEventsWithTimeoutDel(int flags, int timeout);
 
         [NativeSymbol(Entrypoint = "qapp_exec")]
         public ExecDel Exec { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int ExecDel();
 
         [NativeSymbol(Entrypoint = "qapp_addCallbacks")]
         public AddCallbacksDel AddCallbacks { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddCallbacksDel(IntPtr app, ref QCoreAppCallbacks callbacks);
 
         [NativeSymbol(Entrypoint = "qapp_requestTrigger")]
         public RequestTriggerDel RequestTrigger { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void RequestTriggerDel(IntPtr app);
 
         [NativeSymbol(Entrypoint = "qapp_exit")]
         public ExitDel Exit { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void ExitDel(int returnCode);
 
         [NativeSymbol(Entrypoint = "qapp_internalPointer")]
         public InternalPointerDel InternalPointer { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr InternalPointerDel(IntPtr app);
         
         [NativeSymbol(Entrypoint = "qapp_setOrganizationName")]
         public SetOrganizationNameDel SetOrganizationName { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetOrganizationNameDel([MarshalAs(UnmanagedType.LPWStr)]string organizationName);
         
         [NativeSymbol(Entrypoint = "qapp_getOrganizationName")]
         public GetOrganizationNameDel GetOrganizationName { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetOrganizationNameDel();
         
         [NativeSymbol(Entrypoint = "qapp_setOrganizationDomain")]
         public SetOrganizationDomainDel SetOrganizationDomain { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetOrganizationDomainDel([MarshalAs(UnmanagedType.LPWStr)]string organizationDomain);
         
         [NativeSymbol(Entrypoint = "qapp_getOrganizationDomain")]
         public GetOrganizationDomainDel GetOrganizationDomain { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetOrganizationDomainDel();
         
         [NativeSymbol(Entrypoint = "qapp_setAttribute")]
         public SetAttributeDel SetAttribute { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetAttributeDel(int attribute, bool on);
         
         [NativeSymbol(Entrypoint = "qapp_testAttribute")]
         public TestAttributeDel TestAttribute { get; set; }
         
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte TestAttributeDel(int attribute);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/QQmlApplicationEngine.cs b/src/net/Qml.Net/QQmlApplicationEngine.cs
index e6536e43..e0b4866f 100644
--- a/src/net/Qml.Net/QQmlApplicationEngine.cs
+++ b/src/net/Qml.Net/QQmlApplicationEngine.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal;
 using Qml.Net.Internal.Behaviors;
 using Qml.Net.Internal.Qml;
@@ -103,57 +104,79 @@ namespace Qml.Net
     {
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_create")]
         public CreateDel Create { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr CreateDel(IntPtr existingEngine);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_destroy")]
         public DestroyDel Destroy { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void DestroyDel(IntPtr engine);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_load")]
         public LoadDel Load { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int LoadDel(IntPtr engine, [MarshalAs(UnmanagedType.LPWStr)]string path);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_loadData")]
         public LoadDataDel LoadData { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int LoadDataDel(IntPtr engine, [MarshalAs(UnmanagedType.LPWStr)]string path);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_registerType")]
         public RegisterTypeDel RegisterType { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int RegisterTypeDel(IntPtr type, [MarshalAs(UnmanagedType.LPWStr)]string uri, int versionMajor, int versionMinor, [MarshalAs(UnmanagedType.LPWStr)]string qmlName);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_registerSingletonTypeQml")]
         public RegisterSingletonTypeQmlDel RegisterSingletonTypeQml { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int RegisterSingletonTypeQmlDel([MarshalAs(UnmanagedType.LPWStr)]string url, [MarshalAs(UnmanagedType.LPWStr)]string uri, int versionMajor, int versionMinor, [MarshalAs(UnmanagedType.LPWStr)]string qmlName);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_registerSingletonTypeNet")]
         public RegisterSingletonTypeNetDel RegisterSingletonTypeNet { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int RegisterSingletonTypeNetDel(IntPtr type, [MarshalAs(UnmanagedType.LPWStr)]string uri, int versionMajor, int versionMinor, [MarshalAs(UnmanagedType.LPWStr)]string typeName);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_addImportPath")]
         public AddImportPathDel AddImportPath { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void AddImportPathDel(IntPtr engine, [MarshalAs(UnmanagedType.LPWStr)]string path);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_internalPointer")]
         public InternalPointerDel InternalPointer { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr InternalPointerDel(IntPtr app);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_getContextProperty")]
         public GetContextPropertyDel GetContextProperty { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetContextPropertyDel(IntPtr app, [MarshalAs(UnmanagedType.LPWStr)]string name);
 
         [NativeSymbol(Entrypoint = "qqmlapplicationengine_setContextProperty")]
         public SetContextPropertyDel SetContextProperty { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetContextPropertyDel(IntPtr app, [MarshalAs(UnmanagedType.LPWStr)]string path, IntPtr value);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/QQuickStyle.cs b/src/net/Qml.Net/QQuickStyle.cs
index 9bec1fe6..d12d6dcc 100644
--- a/src/net/Qml.Net/QQuickStyle.cs
+++ b/src/net/Qml.Net/QQuickStyle.cs
@@ -1,4 +1,5 @@
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal;
 
 namespace Qml.Net
@@ -20,12 +21,16 @@ namespace Qml.Net
     {
         [NativeSymbol(Entrypoint = "qquickstyle_setFallbackStyle")]
         public SetFallbackStyleDel SetFallbackStyle { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetFallbackStyleDel([MarshalAs(UnmanagedType.LPWStr)]string style);
 
         [NativeSymbol(Entrypoint = "qquickstyle_setStyle")]
         public SetStyleDel SetStyle { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void SetStyleDel([MarshalAs(UnmanagedType.LPWStr)]string style);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/QResource.cs b/src/net/Qml.Net/QResource.cs
index 004d042a..b125ce9d 100644
--- a/src/net/Qml.Net/QResource.cs
+++ b/src/net/Qml.Net/QResource.cs
@@ -1,4 +1,5 @@
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal;
 
 namespace Qml.Net
@@ -21,11 +22,15 @@ namespace Qml.Net
         [NativeSymbol(Entrypoint = "qresource_registerResource")]
         public RegisterResourceDel RegisterResource { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte RegisterResourceDel([MarshalAs(UnmanagedType.LPWStr)]string rccFileName, [MarshalAs(UnmanagedType.LPWStr)]string resourceRoot);
 
         [NativeSymbol(Entrypoint = "qresource_unregisterResource")]
         public UnregisterResourceDel UnregisterResource { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte UnregisterResourceDel([MarshalAs(UnmanagedType.LPWStr)]string rccFileName, [MarshalAs(UnmanagedType.LPWStr)]string resourceRoot);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/QTest.cs b/src/net/Qml.Net/QTest.cs
index 324df92e..01b6a18f 100644
--- a/src/net/Qml.Net/QTest.cs
+++ b/src/net/Qml.Net/QTest.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal;
 
 namespace Qml.Net
@@ -33,14 +34,19 @@ namespace Qml.Net
         [NativeSymbol(Entrypoint = "qtest_qwait")]
         public QWaitDel QWait { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte QWaitDel(int ms);
 
+        [SuppressUnmanagedCodeSecurity]
         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int WaitForCb();
 
         [NativeSymbol(Entrypoint = "qtest_qWaitFor")]
         public QWaitForDel QWaitFor { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate int QWaitForDel(IntPtr cb, int ms);
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Qt.cs b/src/net/Qml.Net/Qt.cs
index 3c6072a3..2cba2e8b 100644
--- a/src/net/Qml.Net/Qt.cs
+++ b/src/net/Qml.Net/Qt.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal;
 using Qml.Net.Internal.Qml;
 
@@ -33,16 +34,22 @@ namespace Qml.Net
         [NativeSymbol(Entrypoint = "qt_putenv")]
         public PutEnvDel PutEnv { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate byte PutEnvDel([MarshalAs(UnmanagedType.LPStr)]string name, [MarshalAs(UnmanagedType.LPStr)]string value);
 
         [NativeSymbol(Entrypoint = "qt_getenv")]
         public GetEnvDel GetEnv { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr GetEnvDel(string name);
 
         [NativeSymbol(Entrypoint = "qt_version")]
         public QtVersionDel QtVersion { get; set; }
 
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate IntPtr QtVersionDel();
     }
 }
diff --git a/src/net/Qml.Net/QtWebEngine.cs b/src/net/Qml.Net/QtWebEngine.cs
index c148dfdc..4512c403 100644
--- a/src/net/Qml.Net/QtWebEngine.cs
+++ b/src/net/Qml.Net/QtWebEngine.cs
@@ -1,3 +1,5 @@
+using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal;
 
 namespace Qml.Net
@@ -14,7 +16,9 @@ namespace Qml.Net
     {
         [NativeSymbol(Entrypoint = "qtwebebengine_initialize")]
         public InitializeDel Initialize { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void InitializeDel();
     }
 }
\ No newline at end of file
diff --git a/src/net/Qml.Net/Utilities.cs b/src/net/Qml.Net/Utilities.cs
index 4e8248a7..2584460c 100644
--- a/src/net/Qml.Net/Utilities.cs
+++ b/src/net/Qml.Net/Utilities.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Security;
 using Qml.Net.Internal;
 
 namespace Qml.Net
@@ -31,7 +32,9 @@ namespace Qml.Net
     {
         [NativeSymbol(Entrypoint = "freeString")]
         public FreeStringDel FreeString { get; set; }
-
+
+        [SuppressUnmanagedCodeSecurity]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
         public delegate void FreeStringDel(IntPtr container);
     }
 }
\ No newline at end of file