xlua生成

Assets/XLua/Gen/BF_DZSDKManagerWrap.cs

@@ -0,0 +1,286 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class BFDZSDKManagerWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(BF.DZSDKManager);
+			Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "CSGetNotchScreenInfo", _m_CSGetNotchScreenInfo);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreen", _m_GetNotchScreen);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenInfo", _m_GetNotchScreenInfo);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenType", _m_GetNotchScreenType);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenEnable", _m_GetNotchScreenEnable);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenWidth", _m_GetNotchScreenWidth);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenHeight", _m_GetNotchScreenHeight);
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new BF.DZSDKManager();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to BF.DZSDKManager constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_CSGetNotchScreenInfo(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.CSGetNotchScreenInfo(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreen(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _content = LuaAPI.lua_tostring(L, 2);
+                    
+                    gen_to_be_invoked.GetNotchScreen( _content );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenInfo(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenInfo(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenType(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenType(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenEnable(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenEnable(  );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenWidth(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenWidth(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenHeight(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.DZSDKManager gen_to_be_invoked = (BF.DZSDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenHeight(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/BF_NotchScreenInfoWrap.cs

@@ -0,0 +1,238 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class BFNotchScreenInfoWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(BF.NotchScreenInfo);
+			Utils.BeginObjectRegister(type, L, translator, 0, 1, 4, 4);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "notchType", _g_get_notchType);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "notchType", _s_set_notchType);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "width", _s_set_width);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new BF.NotchScreenInfo();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to BF.NotchScreenInfo constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ToString(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.ToString(  );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_notchType(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.notchType);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_enabled(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enabled);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_width(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.width);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_height(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.height);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_notchType(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                BF.NotchType gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.notchType = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_enabled(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_width(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.width = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_height(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.NotchScreenInfo gen_to_be_invoked = (BF.NotchScreenInfo)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.height = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/BF_SDKManagerWrap.cs

@@ -21,12 +21,16 @@ namespace XLua.CSObjectWrap
         {
 			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
 			System.Type type = typeof(BF.SDKManager);
-			Utils.BeginObjectRegister(type, L, translator, 0, 4, 6, 0);
+			Utils.BeginObjectRegister(type, L, translator, 0, 8, 7, 0);
 			
 			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
 			Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy);
 			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLanguage", _m_GetLanguage);
 			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTimeZone", _m_GetTimeZone);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenType", _m_GetNotchScreenType);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenEnable", _m_GetNotchScreenEnable);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenWidth", _m_GetNotchScreenWidth);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenHeight", _m_GetNotchScreenHeight);
 			
 			
 			Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFLoginSDKMgr", _g_get_BFLoginSDKMgr);
@@ -35,6 +39,7 @@ namespace XLua.CSObjectWrap
             Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFIronSourceSDKMgr", _g_get_BFIronSourceSDKMgr);
             Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFNativeSDKMgr", _g_get_BFNativeSDKMgr);
             Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFThirdReportSDKMgr", _g_get_BFThirdReportSDKMgr);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DZSDKMgr", _g_get_DZSDKMgr);
             
 			
 			
@@ -201,6 +206,118 @@ namespace XLua.CSObjectWrap
             
         }
         
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenType(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenType(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenEnable(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenEnable(  );
+                        LuaAPI.lua_pushboolean(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenWidth(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenWidth(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetNotchScreenHeight(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.GetNotchScreenHeight(  );
+                        LuaAPI.xlua_pushinteger(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
         
         
         
@@ -288,6 +405,20 @@ namespace XLua.CSObjectWrap
             return 1;
         }
         
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_DZSDKMgr(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.DZSDKMgr);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
         
         
 		

Assets/XLua/Gen/BaseBehaviourWrap.cs

@@ -0,0 +1,82 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class BaseBehaviourWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(BaseBehaviour);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "CachedTransform", _g_get_CachedTransform);
+            
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "BaseBehaviour does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_CachedTransform(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                BaseBehaviour gen_to_be_invoked = (BaseBehaviour)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.CachedTransform);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/CodeGeneratedSingletonWrap.cs

@@ -0,0 +1,67 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class CodeGeneratedSingletonWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(CodeGeneratedSingleton);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "CodeGeneratedSingleton does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/EnumWrap.cs

@@ -74,6 +74,482 @@ namespace XLua.CSObjectWrap
 		}
 	}
     
+    public class ISAdQualityDeviceIdTypeWrap
+    {
+		public static void __Register(RealStatePtr L)
+        {
+		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+		    Utils.BeginObjectRegister(typeof(ISAdQualityDeviceIdType), L, translator, 0, 0, 0, 0);
+			Utils.EndObjectRegister(typeof(ISAdQualityDeviceIdType), L, translator, null, null, null, null, null);
+			
+			Utils.BeginClassRegister(typeof(ISAdQualityDeviceIdType), L, null, 4, 0, 0);
+
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NONE", ISAdQualityDeviceIdType.NONE);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GAID", ISAdQualityDeviceIdType.GAID);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IDFA", ISAdQualityDeviceIdType.IDFA);
+            
+
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+            
+            Utils.EndClassRegister(typeof(ISAdQualityDeviceIdType), L, translator);
+        }
+		
+		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CastFrom(RealStatePtr L)
+		{
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+            if (lua_type == LuaTypes.LUA_TNUMBER)
+            {
+                translator.PushISAdQualityDeviceIdType(L, (ISAdQualityDeviceIdType)LuaAPI.xlua_tointeger(L, 1));
+            }
+			
+            else if(lua_type == LuaTypes.LUA_TSTRING)
+            {
+
+			    if (LuaAPI.xlua_is_eq_str(L, 1, "NONE"))
+                {
+                    translator.PushISAdQualityDeviceIdType(L, ISAdQualityDeviceIdType.NONE);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "GAID"))
+                {
+                    translator.PushISAdQualityDeviceIdType(L, ISAdQualityDeviceIdType.GAID);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "IDFA"))
+                {
+                    translator.PushISAdQualityDeviceIdType(L, ISAdQualityDeviceIdType.IDFA);
+                }
+				else
+                {
+                    return LuaAPI.luaL_error(L, "invalid string for ISAdQualityDeviceIdType!");
+                }
+
+            }
+			
+            else
+            {
+                return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityDeviceIdType! Expect number or string, got + " + lua_type);
+            }
+
+            return 1;
+		}
+	}
+    
+    public class ISAdQualityAdTypeWrap
+    {
+		public static void __Register(RealStatePtr L)
+        {
+		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+		    Utils.BeginObjectRegister(typeof(ISAdQualityAdType), L, translator, 0, 0, 0, 0);
+			Utils.EndObjectRegister(typeof(ISAdQualityAdType), L, translator, null, null, null, null, null);
+			
+			Utils.BeginClassRegister(typeof(ISAdQualityAdType), L, null, 14, 0, 0);
+
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UNKNOWN", ISAdQualityAdType.UNKNOWN);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RICH_MEDIA", ISAdQualityAdType.RICH_MEDIA);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INTERSTITIAL", ISAdQualityAdType.INTERSTITIAL);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "APP_WALL", ISAdQualityAdType.APP_WALL);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VIDEO", ISAdQualityAdType.VIDEO);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REWARDED_VIDEO", ISAdQualityAdType.REWARDED_VIDEO);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NATIVE", ISAdQualityAdType.NATIVE);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BANNER", ISAdQualityAdType.BANNER);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OFFER_WALL", ISAdQualityAdType.OFFER_WALL);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NATIVE_HTML", ISAdQualityAdType.NATIVE_HTML);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EXTERNAL", ISAdQualityAdType.EXTERNAL);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REWARDED", ISAdQualityAdType.REWARDED);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INTERACTIVE", ISAdQualityAdType.INTERACTIVE);
+            
+
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+            
+            Utils.EndClassRegister(typeof(ISAdQualityAdType), L, translator);
+        }
+		
+		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CastFrom(RealStatePtr L)
+		{
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+            if (lua_type == LuaTypes.LUA_TNUMBER)
+            {
+                translator.PushISAdQualityAdType(L, (ISAdQualityAdType)LuaAPI.xlua_tointeger(L, 1));
+            }
+			
+            else if(lua_type == LuaTypes.LUA_TSTRING)
+            {
+
+			    if (LuaAPI.xlua_is_eq_str(L, 1, "UNKNOWN"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.UNKNOWN);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "RICH_MEDIA"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.RICH_MEDIA);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "INTERSTITIAL"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.INTERSTITIAL);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "APP_WALL"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.APP_WALL);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "VIDEO"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.VIDEO);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "REWARDED_VIDEO"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.REWARDED_VIDEO);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "NATIVE"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.NATIVE);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "BANNER"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.BANNER);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "OFFER_WALL"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.OFFER_WALL);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "NATIVE_HTML"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.NATIVE_HTML);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "EXTERNAL"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.EXTERNAL);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "REWARDED"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.REWARDED);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "INTERACTIVE"))
+                {
+                    translator.PushISAdQualityAdType(L, ISAdQualityAdType.INTERACTIVE);
+                }
+				else
+                {
+                    return LuaAPI.luaL_error(L, "invalid string for ISAdQualityAdType!");
+                }
+
+            }
+			
+            else
+            {
+                return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityAdType! Expect number or string, got + " + lua_type);
+            }
+
+            return 1;
+		}
+	}
+    
+    public class ISAdQualityInitErrorWrap
+    {
+		public static void __Register(RealStatePtr L)
+        {
+		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+		    Utils.BeginObjectRegister(typeof(ISAdQualityInitError), L, translator, 0, 0, 0, 0);
+			Utils.EndObjectRegister(typeof(ISAdQualityInitError), L, translator, null, null, null, null, null);
+			
+			Utils.BeginClassRegister(typeof(ISAdQualityInitError), L, null, 11, 0, 0);
+
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_QUALITY_SDK_WAS_SHUTDOWN", ISAdQualityInitError.AD_QUALITY_SDK_WAS_SHUTDOWN);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ILLEGAL_USER_ID", ISAdQualityInitError.ILLEGAL_USER_ID);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ILLEGAL_APP_KEY", ISAdQualityInitError.ILLEGAL_APP_KEY);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EXCEPTION_ON_INIT", ISAdQualityInitError.EXCEPTION_ON_INIT);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NO_NETWORK_CONNECTION", ISAdQualityInitError.NO_NETWORK_CONNECTION);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONFIG_LOAD_TIMEOUT", ISAdQualityInitError.CONFIG_LOAD_TIMEOUT);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONNECTOR_LOAD_TIMEOUT", ISAdQualityInitError.CONNECTOR_LOAD_TIMEOUT);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_NETWORK_VERSION_NOT_SUPPORTED_YET", ISAdQualityInitError.AD_NETWORK_VERSION_NOT_SUPPORTED_YET);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK", ISAdQualityInitError.AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_QUALITY_ALREADY_INITIALIZED", ISAdQualityInitError.AD_QUALITY_ALREADY_INITIALIZED);
+            
+
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+            
+            Utils.EndClassRegister(typeof(ISAdQualityInitError), L, translator);
+        }
+		
+		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CastFrom(RealStatePtr L)
+		{
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+            if (lua_type == LuaTypes.LUA_TNUMBER)
+            {
+                translator.PushISAdQualityInitError(L, (ISAdQualityInitError)LuaAPI.xlua_tointeger(L, 1));
+            }
+			
+            else if(lua_type == LuaTypes.LUA_TSTRING)
+            {
+
+			    if (LuaAPI.xlua_is_eq_str(L, 1, "AD_QUALITY_SDK_WAS_SHUTDOWN"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_QUALITY_SDK_WAS_SHUTDOWN);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "ILLEGAL_USER_ID"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.ILLEGAL_USER_ID);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "ILLEGAL_APP_KEY"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.ILLEGAL_APP_KEY);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "EXCEPTION_ON_INIT"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.EXCEPTION_ON_INIT);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "NO_NETWORK_CONNECTION"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.NO_NETWORK_CONNECTION);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "CONFIG_LOAD_TIMEOUT"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.CONFIG_LOAD_TIMEOUT);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "CONNECTOR_LOAD_TIMEOUT"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.CONNECTOR_LOAD_TIMEOUT);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "AD_NETWORK_VERSION_NOT_SUPPORTED_YET"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_NETWORK_VERSION_NOT_SUPPORTED_YET);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_NETWORK_SDK_REQUIRES_NEWER_AD_QUALITY_SDK);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "AD_QUALITY_ALREADY_INITIALIZED"))
+                {
+                    translator.PushISAdQualityInitError(L, ISAdQualityInitError.AD_QUALITY_ALREADY_INITIALIZED);
+                }
+				else
+                {
+                    return LuaAPI.luaL_error(L, "invalid string for ISAdQualityInitError!");
+                }
+
+            }
+			
+            else
+            {
+                return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityInitError! Expect number or string, got + " + lua_type);
+            }
+
+            return 1;
+		}
+	}
+    
+    public class ISAdQualityLogLevelWrap
+    {
+		public static void __Register(RealStatePtr L)
+        {
+		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+		    Utils.BeginObjectRegister(typeof(ISAdQualityLogLevel), L, translator, 0, 0, 0, 0);
+			Utils.EndObjectRegister(typeof(ISAdQualityLogLevel), L, translator, null, null, null, null, null);
+			
+			Utils.BeginClassRegister(typeof(ISAdQualityLogLevel), L, null, 7, 0, 0);
+
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NONE", ISAdQualityLogLevel.NONE);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ERROR", ISAdQualityLogLevel.ERROR);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WARNING", ISAdQualityLogLevel.WARNING);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INFO", ISAdQualityLogLevel.INFO);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEBUG", ISAdQualityLogLevel.DEBUG);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VERBOSE", ISAdQualityLogLevel.VERBOSE);
+            
+
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+            
+            Utils.EndClassRegister(typeof(ISAdQualityLogLevel), L, translator);
+        }
+		
+		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CastFrom(RealStatePtr L)
+		{
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+            if (lua_type == LuaTypes.LUA_TNUMBER)
+            {
+                translator.PushISAdQualityLogLevel(L, (ISAdQualityLogLevel)LuaAPI.xlua_tointeger(L, 1));
+            }
+			
+            else if(lua_type == LuaTypes.LUA_TSTRING)
+            {
+
+			    if (LuaAPI.xlua_is_eq_str(L, 1, "NONE"))
+                {
+                    translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.NONE);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "ERROR"))
+                {
+                    translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.ERROR);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "WARNING"))
+                {
+                    translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.WARNING);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "INFO"))
+                {
+                    translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.INFO);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "DEBUG"))
+                {
+                    translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.DEBUG);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "VERBOSE"))
+                {
+                    translator.PushISAdQualityLogLevel(L, ISAdQualityLogLevel.VERBOSE);
+                }
+				else
+                {
+                    return LuaAPI.luaL_error(L, "invalid string for ISAdQualityLogLevel!");
+                }
+
+            }
+			
+            else
+            {
+                return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityLogLevel! Expect number or string, got + " + lua_type);
+            }
+
+            return 1;
+		}
+	}
+    
+    public class ISAdQualityMediationNetworkWrap
+    {
+		public static void __Register(RealStatePtr L)
+        {
+		    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+		    Utils.BeginObjectRegister(typeof(ISAdQualityMediationNetwork), L, translator, 0, 0, 0, 0);
+			Utils.EndObjectRegister(typeof(ISAdQualityMediationNetwork), L, translator, null, null, null, null, null);
+			
+			Utils.BeginClassRegister(typeof(ISAdQualityMediationNetwork), L, null, 10, 0, 0);
+
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UNKNOWN", ISAdQualityMediationNetwork.UNKNOWN);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB", ISAdQualityMediationNetwork.ADMOB);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DT_FAIR_BID", ISAdQualityMediationNetwork.DT_FAIR_BID);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HELIUM", ISAdQualityMediationNetwork.HELIUM);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LEVEL_PLAY", ISAdQualityMediationNetwork.LEVEL_PLAY);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAX", ISAdQualityMediationNetwork.MAX);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UNITY", ISAdQualityMediationNetwork.UNITY);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SELF_MEDIATED", ISAdQualityMediationNetwork.SELF_MEDIATED);
+            
+            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OTHER", ISAdQualityMediationNetwork.OTHER);
+            
+
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+            
+            Utils.EndClassRegister(typeof(ISAdQualityMediationNetwork), L, translator);
+        }
+		
+		[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CastFrom(RealStatePtr L)
+		{
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+            if (lua_type == LuaTypes.LUA_TNUMBER)
+            {
+                translator.PushISAdQualityMediationNetwork(L, (ISAdQualityMediationNetwork)LuaAPI.xlua_tointeger(L, 1));
+            }
+			
+            else if(lua_type == LuaTypes.LUA_TSTRING)
+            {
+
+			    if (LuaAPI.xlua_is_eq_str(L, 1, "UNKNOWN"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.UNKNOWN);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "ADMOB"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.ADMOB);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "DT_FAIR_BID"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.DT_FAIR_BID);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "HELIUM"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.HELIUM);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "LEVEL_PLAY"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.LEVEL_PLAY);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "MAX"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.MAX);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "UNITY"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.UNITY);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "SELF_MEDIATED"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.SELF_MEDIATED);
+                }
+				else if (LuaAPI.xlua_is_eq_str(L, 1, "OTHER"))
+                {
+                    translator.PushISAdQualityMediationNetwork(L, ISAdQualityMediationNetwork.OTHER);
+                }
+				else
+                {
+                    return LuaAPI.luaL_error(L, "invalid string for ISAdQualityMediationNetwork!");
+                }
+
+            }
+			
+            else
+            {
+                return LuaAPI.luaL_error(L, "invalid lua type for ISAdQualityMediationNetwork! Expect number or string, got + " + lua_type);
+            }
+
+            return 1;
+		}
+	}
+    
     public class UIImageSheetAnimationAnimationTypeWrap
     {
 		public static void __Register(RealStatePtr L)

Assets/XLua/Gen/ISAdQualityConfigWrap.cs

@@ -0,0 +1,303 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ISAdQualityConfigWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ISAdQualityConfig);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 7);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "UserId", _g_get_UserId);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "TestMode", _g_get_TestMode);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "LogLevel", _g_get_LogLevel);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdQualityInitCallback", _g_get_AdQualityInitCallback);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "InitializationSource", _g_get_InitializationSource);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Coppa", _g_get_Coppa);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DeviceIdType", _g_get_DeviceIdType);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "UserId", _s_set_UserId);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "TestMode", _s_set_TestMode);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "LogLevel", _s_set_LogLevel);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdQualityInitCallback", _s_set_AdQualityInitCallback);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "InitializationSource", _s_set_InitializationSource);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Coppa", _s_set_Coppa);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "DeviceIdType", _s_set_DeviceIdType);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new ISAdQualityConfig();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityConfig constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_UserId(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.UserId);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_TestMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.TestMode);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_LogLevel(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                translator.PushISAdQualityLogLevel(L, gen_to_be_invoked.LogLevel);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_AdQualityInitCallback(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.AdQualityInitCallback);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_InitializationSource(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.InitializationSource);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Coppa(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Coppa);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_DeviceIdType(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                translator.PushISAdQualityDeviceIdType(L, gen_to_be_invoked.DeviceIdType);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_UserId(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.UserId = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_TestMode(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.TestMode = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_LogLevel(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                ISAdQualityLogLevel gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.LogLevel = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_AdQualityInitCallback(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.AdQualityInitCallback = (ISAdQualityInitCallback)translator.GetObject(L, 2, typeof(ISAdQualityInitCallback));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_InitializationSource(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.InitializationSource = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_Coppa(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.Coppa = LuaAPI.lua_toboolean(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_DeviceIdType(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityConfig gen_to_be_invoked = (ISAdQualityConfig)translator.FastGetCSObj(L, 1);
+                ISAdQualityDeviceIdType gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.DeviceIdType = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ISAdQualityCustomMediationRevenueWrap.cs

@@ -0,0 +1,210 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ISAdQualityCustomMediationRevenueWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ISAdQualityCustomMediationRevenue);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 4);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "MediationNetwork", _g_get_MediationNetwork);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdType", _g_get_AdType);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Revenue", _g_get_Revenue);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Placement", _g_get_Placement);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "MediationNetwork", _s_set_MediationNetwork);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdType", _s_set_AdType);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Revenue", _s_set_Revenue);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "Placement", _s_set_Placement);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new ISAdQualityCustomMediationRevenue();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityCustomMediationRevenue constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_MediationNetwork(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                translator.PushISAdQualityMediationNetwork(L, gen_to_be_invoked.MediationNetwork);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_AdType(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                translator.PushISAdQualityAdType(L, gen_to_be_invoked.AdType);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Revenue(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Revenue);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Placement(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.Placement);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_MediationNetwork(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                ISAdQualityMediationNetwork gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.MediationNetwork = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_AdType(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                ISAdQualityAdType gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.AdType = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_Revenue(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.Revenue = LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_Placement(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityCustomMediationRevenue gen_to_be_invoked = (ISAdQualityCustomMediationRevenue)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.Placement = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ISAdQualityEditorScriptWrap.cs

@@ -15,12 +15,12 @@ using System.Collections.Generic;
 namespace XLua.CSObjectWrap
 {
     using Utils = XLua.Utils;
-    public class AFAdRevenueEventWrap 
+    public class ISAdQualityEditorScriptWrap 
     {
         public static void __Register(RealStatePtr L)
         {
 			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
-			System.Type type = typeof(AFAdRevenueEvent);
+			System.Type type = typeof(ISAdQualityEditorScript);
 			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
 			
 			
@@ -31,14 +31,9 @@ namespace XLua.CSObjectWrap
 			Utils.EndObjectRegister(type, L, translator, null, null,
 			    null, null, null);
 
-		    Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0);
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
 			
 			
-            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COUNTRY", AFAdRevenueEvent.COUNTRY);
-            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_UNIT", AFAdRevenueEvent.AD_UNIT);
-            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_TYPE", AFAdRevenueEvent.AD_TYPE);
-            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PLACEMENT", AFAdRevenueEvent.PLACEMENT);
-            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ECPM_PAYLOAD", AFAdRevenueEvent.ECPM_PAYLOAD);
             
 			
 			
@@ -55,7 +50,7 @@ namespace XLua.CSObjectWrap
 				if(LuaAPI.lua_gettop(L) == 1)
 				{
 					
-					var gen_ret = new AFAdRevenueEvent();
+					var gen_ret = new ISAdQualityEditorScript();
 					translator.Push(L, gen_ret);
                     
 					return 1;
@@ -65,7 +60,7 @@ namespace XLua.CSObjectWrap
 			catch(System.Exception gen_e) {
 				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
 			}
-            return LuaAPI.luaL_error(L, "invalid arguments to AFAdRevenueEvent constructor!");
+            return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityEditorScript constructor!");
             
         }
         

Assets/XLua/Gen/ISAdQualityInitCallbackWrap.cs

@@ -0,0 +1,125 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ISAdQualityInitCallbackWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ISAdQualityInitCallback);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "adQualitySdkInitSuccess", _m_adQualitySdkInitSuccess);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "adQualitySdkInitFailed", _m_adQualitySdkInitFailed);
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "ISAdQualityInitCallback does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_adQualitySdkInitSuccess(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                ISAdQualityInitCallback gen_to_be_invoked = (ISAdQualityInitCallback)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                    gen_to_be_invoked.adQualitySdkInitSuccess(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_adQualitySdkInitFailed(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                ISAdQualityInitCallback gen_to_be_invoked = (ISAdQualityInitCallback)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    ISAdQualityInitError _adQualityInitError;translator.Get(L, 2, out _adQualityInitError);
+                    string _errorMessage = LuaAPI.lua_tostring(L, 3);
+                    
+                    gen_to_be_invoked.adQualitySdkInitFailed( _adQualityInitError, _errorMessage );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ISAdQualityInitCallbackWrapperWrap.cs

@@ -0,0 +1,115 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ISAdQualityInitCallbackWrapperWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ISAdQualityInitCallbackWrapper);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdQualityInitCallback", _g_get_AdQualityInitCallback);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdQualityInitCallback", _s_set_AdQualityInitCallback);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new ISAdQualityInitCallbackWrapper();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualityInitCallbackWrapper constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_AdQualityInitCallback(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityInitCallbackWrapper gen_to_be_invoked = (ISAdQualityInitCallbackWrapper)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.AdQualityInitCallback);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_AdQualityInitCallback(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualityInitCallbackWrapper gen_to_be_invoked = (ISAdQualityInitCallbackWrapper)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.AdQualityInitCallback = (ISAdQualityInitCallback)translator.GetObject(L, 2, typeof(ISAdQualityInitCallback));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ISAdQualityJSON_JsonWrap.cs

@@ -0,0 +1,123 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ISAdQualityJSONJsonWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ISAdQualityJSON.Json);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "Deserialize", _m_Deserialize_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "Serialize", _m_Serialize_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "ISAdQualityJSON.Json does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Deserialize_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _json = LuaAPI.lua_tostring(L, 1);
+                    
+                        var gen_ret = ISAdQualityJSON.Json.Deserialize( _json );
+                        translator.PushAny(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Serialize_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    object _obj = translator.GetObject(L, 1, typeof(object));
+                    
+                        var gen_ret = ISAdQualityJSON.Json.Serialize( _obj );
+                        LuaAPI.lua_pushstring(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ISAdQualitySegmentWrap.cs

@@ -0,0 +1,391 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ISAdQualitySegmentWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ISAdQualitySegment);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 8, 8);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "setCustom", _m_setCustom);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "getSegmentAsDict", _m_getSegmentAsDict);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "name", _g_get_name);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "age", _g_get_age);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "gender", _g_get_gender);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "level", _g_get_level);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPaying", _g_get_isPaying);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "inAppPurchasesTotal", _g_get_inAppPurchasesTotal);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "userCreationDate", _g_get_userCreationDate);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "customs", _g_get_customs);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "name", _s_set_name);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "age", _s_set_age);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "gender", _s_set_gender);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "level", _s_set_level);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isPaying", _s_set_isPaying);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "inAppPurchasesTotal", _s_set_inAppPurchasesTotal);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "userCreationDate", _s_set_userCreationDate);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "customs", _s_set_customs);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new ISAdQualitySegment();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to ISAdQualitySegment constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_setCustom(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    string _key = LuaAPI.lua_tostring(L, 2);
+                    string _value = LuaAPI.lua_tostring(L, 3);
+                    
+                    gen_to_be_invoked.setCustom( _key, _value );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_getSegmentAsDict(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    
+                        var gen_ret = gen_to_be_invoked.getSegmentAsDict(  );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_name(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.name);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_age(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.age);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_gender(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.gender);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_level(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.level);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_isPaying(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.isPaying);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_inAppPurchasesTotal(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.inAppPurchasesTotal);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_userCreationDate(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushint64(L, gen_to_be_invoked.userCreationDate);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_customs(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.customs);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_name(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.name = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_age(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.age = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_gender(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.gender = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_level(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.level = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_isPaying(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.isPaying = LuaAPI.xlua_tointeger(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_inAppPurchasesTotal(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.inAppPurchasesTotal = LuaAPI.lua_tonumber(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_userCreationDate(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.userCreationDate = LuaAPI.lua_toint64(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_customs(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ISAdQualitySegment gen_to_be_invoked = (ISAdQualitySegment)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.customs = (System.Collections.Generic.Dictionary<string, string>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<string, string>));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ISAdQualityUtilsWrap.cs

@@ -15,12 +15,12 @@ using System.Collections.Generic;
 namespace XLua.CSObjectWrap
 {
     using Utils = XLua.Utils;
-    public class AppsFlyerSDKAppsFlyerAdRevenueWrap 
+    public class ISAdQualityUtilsWrap 
     {
         public static void __Register(RealStatePtr L)
         {
 			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
-			System.Type type = typeof(AppsFlyerSDK.AppsFlyerAdRevenue);
+			System.Type type = typeof(ISAdQualityUtils);
 			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
 			
 			
@@ -32,12 +32,12 @@ namespace XLua.CSObjectWrap
 			    null, null, null);
 
 		    Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0);
-			Utils.RegisterFunc(L, Utils.CLS_IDX, "start", _m_start_xlua_st_);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "LogDebug", _m_LogDebug_xlua_st_);
-            Utils.RegisterFunc(L, Utils.CLS_IDX, "setIsDebug", _m_setIsDebug_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogError", _m_LogError_xlua_st_);
-            Utils.RegisterFunc(L, Utils.CLS_IDX, "logAdRevenue", _m_logAdRevenue_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "LogWarning", _m_LogWarning_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetClassName", _m_GetClassName_xlua_st_);
             
 			
-            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kAppsFlyerAdRevenueVersion", AppsFlyerSDK.AppsFlyerAdRevenue.kAppsFlyerAdRevenueVersion);
             
 			
 			
@@ -48,24 +48,7 @@ namespace XLua.CSObjectWrap
         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
         static int __CreateInstance(RealStatePtr L)
         {
-            
+            return LuaAPI.luaL_error(L, "ISAdQualityUtils does not have a constructor!");
-			try {
-                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
-				if(LuaAPI.lua_gettop(L) == 1)
-				{
-					
-					var gen_ret = new AppsFlyerSDK.AppsFlyerAdRevenue();
-					translator.Push(L, gen_ret);
-                    
-					return 1;
-				}
-				
-			}
-			catch(System.Exception gen_e) {
-				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
-			}
-            return LuaAPI.luaL_error(L, "invalid arguments to AppsFlyerSDK.AppsFlyerAdRevenue constructor!");
-            
         }
         
 		
@@ -76,7 +59,7 @@ namespace XLua.CSObjectWrap
         
         
         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
-        static int _m_start_xlua_st_(RealStatePtr L)
+        static int _m_LogDebug_xlua_st_(RealStatePtr L)
         {
 		    try {
             
@@ -84,8 +67,10 @@ namespace XLua.CSObjectWrap
             
                 
                 {
+                    string _tag = LuaAPI.lua_tostring(L, 1);
+                    string _message = LuaAPI.lua_tostring(L, 2);
                     
-                    AppsFlyerSDK.AppsFlyerAdRevenue.start(  );
+                    ISAdQualityUtils.LogDebug( _tag, _message );
                     
                     
                     
@@ -99,7 +84,7 @@ namespace XLua.CSObjectWrap
         }
         
         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
-        static int _m_setIsDebug_xlua_st_(RealStatePtr L)
+        static int _m_LogError_xlua_st_(RealStatePtr L)
         {
 		    try {
             
@@ -107,9 +92,10 @@ namespace XLua.CSObjectWrap
             
                 
                 {
-                    bool _isDebug = LuaAPI.lua_toboolean(L, 1);
+                    string _tag = LuaAPI.lua_tostring(L, 1);
+                    string _message = LuaAPI.lua_tostring(L, 2);
                     
-                    AppsFlyerSDK.AppsFlyerAdRevenue.setIsDebug( _isDebug );
+                    ISAdQualityUtils.LogError( _tag, _message );
                     
                     
                     
@@ -123,7 +109,32 @@ namespace XLua.CSObjectWrap
         }
         
         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
-        static int _m_logAdRevenue_xlua_st_(RealStatePtr L)
+        static int _m_LogWarning_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    string _tag = LuaAPI.lua_tostring(L, 1);
+                    string _message = LuaAPI.lua_tostring(L, 2);
+                    
+                    ISAdQualityUtils.LogWarning( _tag, _message );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GetClassName_xlua_st_(RealStatePtr L)
         {
 		    try {
             
@@ -133,17 +144,14 @@ namespace XLua.CSObjectWrap
             
                 
                 {
-                    string _monetizationNetwork = LuaAPI.lua_tostring(L, 1);
+                    object _target = translator.GetObject(L, 1, typeof(object));
-                    AppsFlyerSDK.AppsFlyerAdRevenueMediationNetworkType _mediationNetwork;translator.Get(L, 2, out _mediationNetwork);
-                    double _eventRevenue = LuaAPI.lua_tonumber(L, 3);
-                    string _revenueCurrency = LuaAPI.lua_tostring(L, 4);
-                    System.Collections.Generic.Dictionary<string, string> _additionalParameters = (System.Collections.Generic.Dictionary<string, string>)translator.GetObject(L, 5, typeof(System.Collections.Generic.Dictionary<string, string>));
                     
-                    AppsFlyerSDK.AppsFlyerAdRevenue.logAdRevenue( _monetizationNetwork, _mediationNetwork, _eventRevenue, _revenueCurrency, _additionalParameters );
+                        var gen_ret = ISAdQualityUtils.GetClassName( _target );
+                        LuaAPI.lua_pushstring(L, gen_ret);
                     
                     
                     
-                    return 0;
+                    return 1;
                 }
                 
             } catch(System.Exception gen_e) {

Assets/XLua/Gen/IronSourceAdQualityManifestToolsWrap.cs

@@ -0,0 +1,554 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class IronSourceAdQualityManifestToolsWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(IronSourceAdQualityManifestTools);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 18, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "GenerateManifest", _m_GenerateManifest_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateManifest", _m_UpdateManifest_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddActivity", _m_AddActivity_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveActivity", _m_RemoveActivity_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPermission", _m_SetPermission_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "RemovePermission", _m_RemovePermission_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendApplicationElement", _m_AppendApplicationElement_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveApplicationElement", _m_RemoveApplicationElement_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "PrependManifestElement", _m_PrependManifestElement_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveManifestElement", _m_RemoveManifestElement_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddMetaDataTag", _m_AddMetaDataTag_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendElementIfMissing", _m_AppendElementIfMissing_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "PrependElementIfMissing", _m_PrependElementIfMissing_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveElement", _m_RemoveElement_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "FindChildNode", _m_FindChildNode_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "FindChildElement", _m_FindChildElement_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "FindElementWithTagAndName", _m_FindElementWithTagAndName_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new IronSourceAdQualityManifestTools();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to IronSourceAdQualityManifestTools constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_GenerateManifest_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                    IronSourceAdQualityManifestTools.GenerateManifest(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_UpdateManifest_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    
+                    IronSourceAdQualityManifestTools.UpdateManifest(  );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AddActivity_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _activityName = LuaAPI.lua_tostring(L, 1);
+                    System.Collections.Generic.Dictionary<string, string> _attributes = (System.Collections.Generic.Dictionary<string, string>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<string, string>));
+                    
+                    IronSourceAdQualityManifestTools.AddActivity( _activityName, _attributes );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RemoveActivity_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    string _activityName = LuaAPI.lua_tostring(L, 1);
+                    
+                    IronSourceAdQualityManifestTools.RemoveActivity( _activityName );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SetPermission_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    string _permissionName = LuaAPI.lua_tostring(L, 1);
+                    
+                    IronSourceAdQualityManifestTools.SetPermission( _permissionName );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RemovePermission_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    string _permissionName = LuaAPI.lua_tostring(L, 1);
+                    
+                    IronSourceAdQualityManifestTools.RemovePermission( _permissionName );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AppendApplicationElement_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    System.Collections.Generic.Dictionary<string, string> _attributes = (System.Collections.Generic.Dictionary<string, string>)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary<string, string>));
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.AppendApplicationElement( _tagName, _name, _attributes );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RemoveApplicationElement_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    
+                    IronSourceAdQualityManifestTools.RemoveApplicationElement( _tagName, _name );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_PrependManifestElement_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.PrependManifestElement( _tagName, _name );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RemoveManifestElement_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    
+                    IronSourceAdQualityManifestTools.RemoveManifestElement( _tagName, _name );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AddMetaDataTag_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _mdName = LuaAPI.lua_tostring(L, 1);
+                    string _mdValue = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.AddMetaDataTag( _mdName, _mdValue );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_AppendElementIfMissing_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    System.Collections.Generic.Dictionary<string, string> _otherAttributes = (System.Collections.Generic.Dictionary<string, string>)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary<string, string>));
+                    System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 4, typeof(System.Xml.XmlNode));
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.AppendElementIfMissing( _tagName, _name, _otherAttributes, _parent );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_PrependElementIfMissing_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    System.Collections.Generic.Dictionary<string, string> _otherAttributes = (System.Collections.Generic.Dictionary<string, string>)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary<string, string>));
+                    System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 4, typeof(System.Xml.XmlNode));
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.PrependElementIfMissing( _tagName, _name, _otherAttributes, _parent );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_RemoveElement_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 3, typeof(System.Xml.XmlNode));
+                    
+                    IronSourceAdQualityManifestTools.RemoveElement( _tagName, _name, _parent );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_FindChildNode_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 1, typeof(System.Xml.XmlNode));
+                    string _tagName = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.FindChildNode( _parent, _tagName );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_FindChildElement_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 1, typeof(System.Xml.XmlNode));
+                    string _tagName = LuaAPI.lua_tostring(L, 2);
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.FindChildElement( _parent, _tagName );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_FindElementWithTagAndName_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    string _tagName = LuaAPI.lua_tostring(L, 1);
+                    string _name = LuaAPI.lua_tostring(L, 2);
+                    System.Xml.XmlNode _parent = (System.Xml.XmlNode)translator.GetObject(L, 3, typeof(System.Xml.XmlNode));
+                    
+                        var gen_ret = IronSourceAdQualityManifestTools.FindElementWithTagAndName( _tagName, _name, _parent );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/IronSourceAdQualityWrap.cs

@@ -0,0 +1,205 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class IronSourceAdQualityWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(IronSourceAdQuality);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "Initialize", _m_Initialize_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "ChangeUserId", _m_ChangeUserId_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "SendCustomMediationRevenue", _m_SendCustomMediationRevenue_xlua_st_);
+            Utils.RegisterFunc(L, Utils.CLS_IDX, "setSegment", _m_setSegment_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new IronSourceAdQuality();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to IronSourceAdQuality constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_Initialize_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+			    int gen_param_count = LuaAPI.lua_gettop(L);
+            
+                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
+                {
+                    string _appKey = LuaAPI.lua_tostring(L, 1);
+                    
+                    IronSourceAdQuality.Initialize( _appKey );
+                    
+                    
+                    
+                    return 0;
+                }
+                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable<ISAdQualityConfig>(L, 2)) 
+                {
+                    string _appKey = LuaAPI.lua_tostring(L, 1);
+                    ISAdQualityConfig _adQualityConfig = (ISAdQualityConfig)translator.GetObject(L, 2, typeof(ISAdQualityConfig));
+                    
+                    IronSourceAdQuality.Initialize( _appKey, _adQualityConfig );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+            return LuaAPI.luaL_error(L, "invalid arguments to IronSourceAdQuality.Initialize!");
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ChangeUserId_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+            
+            
+                
+                {
+                    string _userId = LuaAPI.lua_tostring(L, 1);
+                    
+                    IronSourceAdQuality.ChangeUserId( _userId );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SendCustomMediationRevenue_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    ISAdQualityCustomMediationRevenue _customMediationRevenue = (ISAdQualityCustomMediationRevenue)translator.GetObject(L, 1, typeof(ISAdQualityCustomMediationRevenue));
+                    
+                    IronSourceAdQuality.SendCustomMediationRevenue( _customMediationRevenue );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_setSegment_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    ISAdQualitySegment _segment = (ISAdQualitySegment)translator.GetObject(L, 1, typeof(ISAdQualitySegment));
+                    
+                    IronSourceAdQuality.setSegment( _segment );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/MolocoSdk_MolocoSDKWrap.cs

@@ -0,0 +1,94 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class MolocoSdkMolocoSDKWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(MolocoSdk.MolocoSDK);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0);
+			Utils.RegisterFunc(L, Utils.CLS_IDX, "SetPrivacy", _m_SetPrivacy_xlua_st_);
+            
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "MolocoSdk.MolocoSDK does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_SetPrivacy_xlua_st_(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+            
+                
+                {
+                    MolocoSdk.PrivacySettings _privacySettings = (MolocoSdk.PrivacySettings)translator.GetObject(L, 1, typeof(MolocoSdk.PrivacySettings));
+                    
+                    MolocoSdk.MolocoSDK.SetPrivacy( _privacySettings );
+                    
+                    
+                    
+                    return 0;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/MolocoSdk_PrivacySettingsWrap.cs

@@ -0,0 +1,180 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class MolocoSdkPrivacySettingsWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(MolocoSdk.PrivacySettings);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsUserConsent", _g_get_IsUserConsent);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsAgeRestrictedUser", _g_get_IsAgeRestrictedUser);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsDoNotSell", _g_get_IsDoNotSell);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsUserConsent", _s_set_IsUserConsent);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsAgeRestrictedUser", _s_set_IsAgeRestrictedUser);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsDoNotSell", _s_set_IsDoNotSell);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new MolocoSdk.PrivacySettings();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to MolocoSdk.PrivacySettings constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_IsUserConsent(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.IsUserConsent);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_IsAgeRestrictedUser(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.IsAgeRestrictedUser);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_IsDoNotSell(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1);
+                translator.PushAny(L, gen_to_be_invoked.IsDoNotSell);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_IsUserConsent(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1);
+                System.Nullable<bool> gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.IsUserConsent = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_IsAgeRestrictedUser(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1);
+                System.Nullable<bool> gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.IsAgeRestrictedUser = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_IsDoNotSell(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                MolocoSdk.PrivacySettings gen_to_be_invoked = (MolocoSdk.PrivacySettings)translator.FastGetCSObj(L, 1);
+                System.Nullable<bool> gen_value;translator.Get(L, 2, out gen_value);
+				gen_to_be_invoked.IsDoNotSell = gen_value;
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ObjectDictionaryWrap.cs

@@ -0,0 +1,175 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ObjectDictionaryWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ObjectDictionary);
+			Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 1);
+			
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConvertUkvp", _m_ConvertUkvp);
+			Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConvertOkvp", _m_ConvertOkvp);
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "values", _g_get_values);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "values", _s_set_values);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 1)
+				{
+					
+					var gen_ret = new ObjectDictionary();
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to ObjectDictionary constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ConvertUkvp(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    UnityKeyValuePair<string, string> _ukvp = (UnityKeyValuePair<string, string>)translator.GetObject(L, 2, typeof(UnityKeyValuePair<string, string>));
+                    
+                        var gen_ret = gen_to_be_invoked.ConvertUkvp( _ukvp );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _m_ConvertOkvp(RealStatePtr L)
+        {
+		    try {
+            
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+            
+            
+                ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1);
+            
+            
+                
+                {
+                    ObjectKvp _okvp = (ObjectKvp)translator.GetObject(L, 2, typeof(ObjectKvp));
+                    
+                        var gen_ret = gen_to_be_invoked.ConvertOkvp( _okvp );
+                        translator.Push(L, gen_ret);
+                    
+                    
+                    
+                    return 1;
+                }
+                
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            
+        }
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_values(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1);
+                translator.Push(L, gen_to_be_invoked.values);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_values(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ObjectDictionary gen_to_be_invoked = (ObjectDictionary)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.values = (System.Collections.Generic.List<ObjectKvp>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<ObjectKvp>));
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/ObjectKvpWrap.cs

@@ -0,0 +1,148 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class ObjectKvpWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(ObjectKvp);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2);
+			
+			
+			
+			Utils.RegisterFunc(L, Utils.GETTER_IDX, "Value", _g_get_Value);
+            Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value);
+            
+			Utils.RegisterFunc(L, Utils.SETTER_IDX, "Value", _s_set_Value);
+            Utils.RegisterFunc(L, Utils.SETTER_IDX, "value", _s_set_value);
+            
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            
+			try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+				if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))
+				{
+					string _key = LuaAPI.lua_tostring(L, 2);
+					string _value = LuaAPI.lua_tostring(L, 3);
+					
+					var gen_ret = new ObjectKvp(_key, _value);
+					translator.Push(L, gen_ret);
+                    
+					return 1;
+				}
+				
+			}
+			catch(System.Exception gen_e) {
+				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+			}
+            return LuaAPI.luaL_error(L, "invalid arguments to ObjectKvp constructor!");
+            
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_Value(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.Value);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _g_get_value(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1);
+                LuaAPI.lua_pushstring(L, gen_to_be_invoked.value);
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 1;
+        }
+        
+        
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_Value(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.Value = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int _s_set_value(RealStatePtr L)
+        {
+		    try {
+                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			
+                ObjectKvp gen_to_be_invoked = (ObjectKvp)translator.FastGetCSObj(L, 1);
+                gen_to_be_invoked.value = LuaAPI.lua_tostring(L, 2);
+            
+            } catch(System.Exception gen_e) {
+                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
+            }
+            return 0;
+        }
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/SceneSingletonWrap.cs

@@ -0,0 +1,67 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class SceneSingletonWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(SceneSingleton);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "SceneSingleton does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/UnitySingletonWrap.cs

@@ -0,0 +1,67 @@
+#if USE_UNI_LUA
+using LuaAPI = UniLua.Lua;
+using RealStatePtr = UniLua.ILuaState;
+using LuaCSFunction = UniLua.CSharpFunctionDelegate;
+#else
+using LuaAPI = XLua.LuaDLL.Lua;
+using RealStatePtr = System.IntPtr;
+using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
+#endif
+
+using XLua;
+using System.Collections.Generic;
+
+
+namespace XLua.CSObjectWrap
+{
+    using Utils = XLua.Utils;
+    public class UnitySingletonWrap 
+    {
+        public static void __Register(RealStatePtr L)
+        {
+			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+			System.Type type = typeof(UnitySingleton);
+			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
+			
+			
+			
+			
+			
+			
+			Utils.EndObjectRegister(type, L, translator, null, null,
+			    null, null, null);
+
+		    Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
+			
+			
+            
+			
+			
+			
+			Utils.EndClassRegister(type, L, translator);
+        }
+        
+        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+        static int __CreateInstance(RealStatePtr L)
+        {
+            return LuaAPI.luaL_error(L, "UnitySingleton does not have a constructor!");
+        }
+        
+		
+        
+		
+        
+        
+        
+        
+        
+        
+        
+        
+        
+		
+		
+		
+		
+    }
+}

Assets/XLua/Gen/WrapPusher.cs

@@ -35,6 +35,11 @@ namespace XLua
 				translator.RegisterPushAndGetAndUpdate<UnityEngine.Bounds>(translator.PushUnityEngineBounds, translator.Get, translator.UpdateUnityEngineBounds);
 				translator.RegisterPushAndGetAndUpdate<UnityEngine.Ray2D>(translator.PushUnityEngineRay2D, translator.Get, translator.UpdateUnityEngineRay2D);
 				translator.RegisterPushAndGetAndUpdate<IronSourceBannerPosition>(translator.PushIronSourceBannerPosition, translator.Get, translator.UpdateIronSourceBannerPosition);
+				translator.RegisterPushAndGetAndUpdate<ISAdQualityDeviceIdType>(translator.PushISAdQualityDeviceIdType, translator.Get, translator.UpdateISAdQualityDeviceIdType);
+				translator.RegisterPushAndGetAndUpdate<ISAdQualityAdType>(translator.PushISAdQualityAdType, translator.Get, translator.UpdateISAdQualityAdType);
+				translator.RegisterPushAndGetAndUpdate<ISAdQualityInitError>(translator.PushISAdQualityInitError, translator.Get, translator.UpdateISAdQualityInitError);
+				translator.RegisterPushAndGetAndUpdate<ISAdQualityLogLevel>(translator.PushISAdQualityLogLevel, translator.Get, translator.UpdateISAdQualityLogLevel);
+				translator.RegisterPushAndGetAndUpdate<ISAdQualityMediationNetwork>(translator.PushISAdQualityMediationNetwork, translator.Get, translator.UpdateISAdQualityMediationNetwork);
 				translator.RegisterPushAndGetAndUpdate<UIImageSheetAnimation.AnimationType>(translator.PushUIImageSheetAnimationAnimationType, translator.Get, translator.UpdateUIImageSheetAnimationAnimationType);
 				translator.RegisterPushAndGetAndUpdate<UIImageSheetAnimation.TimeType>(translator.PushUIImageSheetAnimationTimeType, translator.Get, translator.UpdateUIImageSheetAnimationTimeType);
 				translator.RegisterPushAndGetAndUpdate<UIImageSheetAnimation.StartFrameType>(translator.PushUIImageSheetAnimationStartFrameType, translator.Get, translator.UpdateUIImageSheetAnimationStartFrameType);
@@ -732,6 +737,426 @@ namespace XLua
             }
         }
         
+        int ISAdQualityDeviceIdType_TypeID = -1;
+		int ISAdQualityDeviceIdType_EnumRef = -1;
+        
+        public void PushISAdQualityDeviceIdType(RealStatePtr L, ISAdQualityDeviceIdType val)
+        {
+            if (ISAdQualityDeviceIdType_TypeID == -1)
+            {
+			    bool is_first;
+                ISAdQualityDeviceIdType_TypeID = getTypeId(L, typeof(ISAdQualityDeviceIdType), out is_first);
+				
+				if (ISAdQualityDeviceIdType_EnumRef == -1)
+				{
+				    Utils.LoadCSTable(L, typeof(ISAdQualityDeviceIdType));
+				    ISAdQualityDeviceIdType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+				}
+				
+            }
+			
+			if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityDeviceIdType_EnumRef) == 1)
+            {
+			    return;
+			}
+			
+            IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityDeviceIdType_TypeID);
+            if (!CopyByValue.Pack(buff, 0, (int)val))
+            {
+                throw new Exception("pack fail fail for ISAdQualityDeviceIdType ,value="+val);
+            }
+			
+			LuaAPI.lua_getref(L, ISAdQualityDeviceIdType_EnumRef);
+			LuaAPI.lua_pushvalue(L, -2);
+			LuaAPI.xlua_rawseti(L, -2, (int)val);
+			LuaAPI.lua_pop(L, 1);
+			
+        }
+		
+        public void Get(RealStatePtr L, int index, out ISAdQualityDeviceIdType val)
+        {
+		    LuaTypes type = LuaAPI.lua_type(L, index);
+            if (type == LuaTypes.LUA_TUSERDATA )
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityDeviceIdType_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityDeviceIdType");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+				int e;
+                if (!CopyByValue.UnPack(buff, 0, out e))
+                {
+                    throw new Exception("unpack fail for ISAdQualityDeviceIdType");
+                }
+				val = (ISAdQualityDeviceIdType)e;
+                
+            }
+            else
+            {
+                val = (ISAdQualityDeviceIdType)objectCasters.GetCaster(typeof(ISAdQualityDeviceIdType))(L, index, null);
+            }
+        }
+		
+        public void UpdateISAdQualityDeviceIdType(RealStatePtr L, int index, ISAdQualityDeviceIdType val)
+        {
+		    
+            if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityDeviceIdType_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityDeviceIdType");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+                if (!CopyByValue.Pack(buff, 0,  (int)val))
+                {
+                    throw new Exception("pack fail for ISAdQualityDeviceIdType ,value="+val);
+                }
+            }
+			
+            else
+            {
+                throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+            }
+        }
+        
+        int ISAdQualityAdType_TypeID = -1;
+		int ISAdQualityAdType_EnumRef = -1;
+        
+        public void PushISAdQualityAdType(RealStatePtr L, ISAdQualityAdType val)
+        {
+            if (ISAdQualityAdType_TypeID == -1)
+            {
+			    bool is_first;
+                ISAdQualityAdType_TypeID = getTypeId(L, typeof(ISAdQualityAdType), out is_first);
+				
+				if (ISAdQualityAdType_EnumRef == -1)
+				{
+				    Utils.LoadCSTable(L, typeof(ISAdQualityAdType));
+				    ISAdQualityAdType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+				}
+				
+            }
+			
+			if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityAdType_EnumRef) == 1)
+            {
+			    return;
+			}
+			
+            IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityAdType_TypeID);
+            if (!CopyByValue.Pack(buff, 0, (int)val))
+            {
+                throw new Exception("pack fail fail for ISAdQualityAdType ,value="+val);
+            }
+			
+			LuaAPI.lua_getref(L, ISAdQualityAdType_EnumRef);
+			LuaAPI.lua_pushvalue(L, -2);
+			LuaAPI.xlua_rawseti(L, -2, (int)val);
+			LuaAPI.lua_pop(L, 1);
+			
+        }
+		
+        public void Get(RealStatePtr L, int index, out ISAdQualityAdType val)
+        {
+		    LuaTypes type = LuaAPI.lua_type(L, index);
+            if (type == LuaTypes.LUA_TUSERDATA )
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityAdType_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityAdType");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+				int e;
+                if (!CopyByValue.UnPack(buff, 0, out e))
+                {
+                    throw new Exception("unpack fail for ISAdQualityAdType");
+                }
+				val = (ISAdQualityAdType)e;
+                
+            }
+            else
+            {
+                val = (ISAdQualityAdType)objectCasters.GetCaster(typeof(ISAdQualityAdType))(L, index, null);
+            }
+        }
+		
+        public void UpdateISAdQualityAdType(RealStatePtr L, int index, ISAdQualityAdType val)
+        {
+		    
+            if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityAdType_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityAdType");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+                if (!CopyByValue.Pack(buff, 0,  (int)val))
+                {
+                    throw new Exception("pack fail for ISAdQualityAdType ,value="+val);
+                }
+            }
+			
+            else
+            {
+                throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+            }
+        }
+        
+        int ISAdQualityInitError_TypeID = -1;
+		int ISAdQualityInitError_EnumRef = -1;
+        
+        public void PushISAdQualityInitError(RealStatePtr L, ISAdQualityInitError val)
+        {
+            if (ISAdQualityInitError_TypeID == -1)
+            {
+			    bool is_first;
+                ISAdQualityInitError_TypeID = getTypeId(L, typeof(ISAdQualityInitError), out is_first);
+				
+				if (ISAdQualityInitError_EnumRef == -1)
+				{
+				    Utils.LoadCSTable(L, typeof(ISAdQualityInitError));
+				    ISAdQualityInitError_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+				}
+				
+            }
+			
+			if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityInitError_EnumRef) == 1)
+            {
+			    return;
+			}
+			
+            IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityInitError_TypeID);
+            if (!CopyByValue.Pack(buff, 0, (int)val))
+            {
+                throw new Exception("pack fail fail for ISAdQualityInitError ,value="+val);
+            }
+			
+			LuaAPI.lua_getref(L, ISAdQualityInitError_EnumRef);
+			LuaAPI.lua_pushvalue(L, -2);
+			LuaAPI.xlua_rawseti(L, -2, (int)val);
+			LuaAPI.lua_pop(L, 1);
+			
+        }
+		
+        public void Get(RealStatePtr L, int index, out ISAdQualityInitError val)
+        {
+		    LuaTypes type = LuaAPI.lua_type(L, index);
+            if (type == LuaTypes.LUA_TUSERDATA )
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityInitError_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityInitError");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+				int e;
+                if (!CopyByValue.UnPack(buff, 0, out e))
+                {
+                    throw new Exception("unpack fail for ISAdQualityInitError");
+                }
+				val = (ISAdQualityInitError)e;
+                
+            }
+            else
+            {
+                val = (ISAdQualityInitError)objectCasters.GetCaster(typeof(ISAdQualityInitError))(L, index, null);
+            }
+        }
+		
+        public void UpdateISAdQualityInitError(RealStatePtr L, int index, ISAdQualityInitError val)
+        {
+		    
+            if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityInitError_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityInitError");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+                if (!CopyByValue.Pack(buff, 0,  (int)val))
+                {
+                    throw new Exception("pack fail for ISAdQualityInitError ,value="+val);
+                }
+            }
+			
+            else
+            {
+                throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+            }
+        }
+        
+        int ISAdQualityLogLevel_TypeID = -1;
+		int ISAdQualityLogLevel_EnumRef = -1;
+        
+        public void PushISAdQualityLogLevel(RealStatePtr L, ISAdQualityLogLevel val)
+        {
+            if (ISAdQualityLogLevel_TypeID == -1)
+            {
+			    bool is_first;
+                ISAdQualityLogLevel_TypeID = getTypeId(L, typeof(ISAdQualityLogLevel), out is_first);
+				
+				if (ISAdQualityLogLevel_EnumRef == -1)
+				{
+				    Utils.LoadCSTable(L, typeof(ISAdQualityLogLevel));
+				    ISAdQualityLogLevel_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+				}
+				
+            }
+			
+			if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityLogLevel_EnumRef) == 1)
+            {
+			    return;
+			}
+			
+            IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityLogLevel_TypeID);
+            if (!CopyByValue.Pack(buff, 0, (int)val))
+            {
+                throw new Exception("pack fail fail for ISAdQualityLogLevel ,value="+val);
+            }
+			
+			LuaAPI.lua_getref(L, ISAdQualityLogLevel_EnumRef);
+			LuaAPI.lua_pushvalue(L, -2);
+			LuaAPI.xlua_rawseti(L, -2, (int)val);
+			LuaAPI.lua_pop(L, 1);
+			
+        }
+		
+        public void Get(RealStatePtr L, int index, out ISAdQualityLogLevel val)
+        {
+		    LuaTypes type = LuaAPI.lua_type(L, index);
+            if (type == LuaTypes.LUA_TUSERDATA )
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityLogLevel_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityLogLevel");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+				int e;
+                if (!CopyByValue.UnPack(buff, 0, out e))
+                {
+                    throw new Exception("unpack fail for ISAdQualityLogLevel");
+                }
+				val = (ISAdQualityLogLevel)e;
+                
+            }
+            else
+            {
+                val = (ISAdQualityLogLevel)objectCasters.GetCaster(typeof(ISAdQualityLogLevel))(L, index, null);
+            }
+        }
+		
+        public void UpdateISAdQualityLogLevel(RealStatePtr L, int index, ISAdQualityLogLevel val)
+        {
+		    
+            if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityLogLevel_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityLogLevel");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+                if (!CopyByValue.Pack(buff, 0,  (int)val))
+                {
+                    throw new Exception("pack fail for ISAdQualityLogLevel ,value="+val);
+                }
+            }
+			
+            else
+            {
+                throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+            }
+        }
+        
+        int ISAdQualityMediationNetwork_TypeID = -1;
+		int ISAdQualityMediationNetwork_EnumRef = -1;
+        
+        public void PushISAdQualityMediationNetwork(RealStatePtr L, ISAdQualityMediationNetwork val)
+        {
+            if (ISAdQualityMediationNetwork_TypeID == -1)
+            {
+			    bool is_first;
+                ISAdQualityMediationNetwork_TypeID = getTypeId(L, typeof(ISAdQualityMediationNetwork), out is_first);
+				
+				if (ISAdQualityMediationNetwork_EnumRef == -1)
+				{
+				    Utils.LoadCSTable(L, typeof(ISAdQualityMediationNetwork));
+				    ISAdQualityMediationNetwork_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+				}
+				
+            }
+			
+			if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ISAdQualityMediationNetwork_EnumRef) == 1)
+            {
+			    return;
+			}
+			
+            IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ISAdQualityMediationNetwork_TypeID);
+            if (!CopyByValue.Pack(buff, 0, (int)val))
+            {
+                throw new Exception("pack fail fail for ISAdQualityMediationNetwork ,value="+val);
+            }
+			
+			LuaAPI.lua_getref(L, ISAdQualityMediationNetwork_EnumRef);
+			LuaAPI.lua_pushvalue(L, -2);
+			LuaAPI.xlua_rawseti(L, -2, (int)val);
+			LuaAPI.lua_pop(L, 1);
+			
+        }
+		
+        public void Get(RealStatePtr L, int index, out ISAdQualityMediationNetwork val)
+        {
+		    LuaTypes type = LuaAPI.lua_type(L, index);
+            if (type == LuaTypes.LUA_TUSERDATA )
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityMediationNetwork_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityMediationNetwork");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+				int e;
+                if (!CopyByValue.UnPack(buff, 0, out e))
+                {
+                    throw new Exception("unpack fail for ISAdQualityMediationNetwork");
+                }
+				val = (ISAdQualityMediationNetwork)e;
+                
+            }
+            else
+            {
+                val = (ISAdQualityMediationNetwork)objectCasters.GetCaster(typeof(ISAdQualityMediationNetwork))(L, index, null);
+            }
+        }
+		
+        public void UpdateISAdQualityMediationNetwork(RealStatePtr L, int index, ISAdQualityMediationNetwork val)
+        {
+		    
+            if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+            {
+			    if (LuaAPI.xlua_gettypeid(L, index) != ISAdQualityMediationNetwork_TypeID)
+				{
+				    throw new Exception("invalid userdata for ISAdQualityMediationNetwork");
+				}
+				
+                IntPtr buff = LuaAPI.lua_touserdata(L, index);
+                if (!CopyByValue.Pack(buff, 0,  (int)val))
+                {
+                    throw new Exception("pack fail for ISAdQualityMediationNetwork ,value="+val);
+                }
+            }
+			
+            else
+            {
+                throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+            }
+        }
+        
         int UIImageSheetAnimationAnimationType_TypeID = -1;
 		int UIImageSheetAnimationAnimationType_EnumRef = -1;
         
@@ -7265,6 +7690,36 @@ namespace XLua
 				translator.PushIronSourceBannerPosition(L, array[index]);
 				return true;
 			}
+			else if (type == typeof(ISAdQualityDeviceIdType[]))
+			{
+			    ISAdQualityDeviceIdType[] array = obj as ISAdQualityDeviceIdType[];
+				translator.PushISAdQualityDeviceIdType(L, array[index]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityAdType[]))
+			{
+			    ISAdQualityAdType[] array = obj as ISAdQualityAdType[];
+				translator.PushISAdQualityAdType(L, array[index]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityInitError[]))
+			{
+			    ISAdQualityInitError[] array = obj as ISAdQualityInitError[];
+				translator.PushISAdQualityInitError(L, array[index]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityLogLevel[]))
+			{
+			    ISAdQualityLogLevel[] array = obj as ISAdQualityLogLevel[];
+				translator.PushISAdQualityLogLevel(L, array[index]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityMediationNetwork[]))
+			{
+			    ISAdQualityMediationNetwork[] array = obj as ISAdQualityMediationNetwork[];
+				translator.PushISAdQualityMediationNetwork(L, array[index]);
+				return true;
+			}
 			else if (type == typeof(UIImageSheetAnimation.AnimationType[]))
 			{
 			    UIImageSheetAnimation.AnimationType[] array = obj as UIImageSheetAnimation.AnimationType[];
@@ -7787,6 +8242,36 @@ namespace XLua
 				translator.Get(L, obj_idx, out array[array_idx]);
 				return true;
 			}
+			else if (type == typeof(ISAdQualityDeviceIdType[]))
+			{
+			    ISAdQualityDeviceIdType[] array = obj as ISAdQualityDeviceIdType[];
+				translator.Get(L, obj_idx, out array[array_idx]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityAdType[]))
+			{
+			    ISAdQualityAdType[] array = obj as ISAdQualityAdType[];
+				translator.Get(L, obj_idx, out array[array_idx]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityInitError[]))
+			{
+			    ISAdQualityInitError[] array = obj as ISAdQualityInitError[];
+				translator.Get(L, obj_idx, out array[array_idx]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityLogLevel[]))
+			{
+			    ISAdQualityLogLevel[] array = obj as ISAdQualityLogLevel[];
+				translator.Get(L, obj_idx, out array[array_idx]);
+				return true;
+			}
+			else if (type == typeof(ISAdQualityMediationNetwork[]))
+			{
+			    ISAdQualityMediationNetwork[] array = obj as ISAdQualityMediationNetwork[];
+				translator.Get(L, obj_idx, out array[array_idx]);
+				return true;
+			}
 			else if (type == typeof(UIImageSheetAnimation.AnimationType[]))
 			{
 			    UIImageSheetAnimation.AnimationType[] array = obj as UIImageSheetAnimation.AnimationType[];

Assets/XLua/Gen/XLuaGenAutoRegister.cs

@@ -1386,6 +1386,12 @@ namespace XLua.CSObjectWrap
             translator.DelayWrapLoader(typeof(BF.BFThirdReportSDKManager), BFBFThirdReportSDKManagerWrap.__Register);
         
         
+            translator.DelayWrapLoader(typeof(BF.NotchScreenInfo), BFNotchScreenInfoWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(BF.DZSDKManager), BFDZSDKManagerWrap.__Register);
+        
+        
             translator.DelayWrapLoader(typeof(BF.NativeUtils), BFNativeUtilsWrap.__Register);
         
         
@@ -1424,16 +1430,16 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(BF.SoundManager), BFSoundManagerWrap.__Register);
         
+        }
+        
+        static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(BF.Task), BFTaskWrap.__Register);
         
         
             translator.DelayWrapLoader(typeof(BF.Delayed), BFDelayedWrap.__Register);
         
-        }
-        
-        static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(BF.TaskManager), BFTaskManagerWrap.__Register);
         
@@ -1581,16 +1587,16 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(BF.BFLayoutBase), BFBFLayoutBaseWrap.__Register);
         
+        }
+        
+        static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(BF.BFCell), BFBFCellWrap.__Register);
         
         
             translator.DelayWrapLoader(typeof(BF.BFScrollRectBase), BFBFScrollRectBaseWrap.__Register);
         
-        }
-        
-        static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(BF.BFScrollRectCommon), BFBFScrollRectCommonWrap.__Register);
         
@@ -1738,16 +1744,16 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(TMPro.TMP_MaterialReference), TMProTMP_MaterialReferenceWrap.__Register);
         
+        }
+        
+        static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(TMPro.MaterialReference), TMProMaterialReferenceWrap.__Register);
         
         
             translator.DelayWrapLoader(typeof(TMPro.TMP_Asset), TMProTMP_AssetWrap.__Register);
         
-        }
-        
-        static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(TMPro.TMP_Character), TMProTMP_CharacterWrap.__Register);
         
@@ -1895,16 +1901,16 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(TMPro.TMP_TextParsingUtilities), TMProTMP_TextParsingUtilitiesWrap.__Register);
         
+        }
+        
+        static void wrapInit12(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(TMPro.CaretInfo), TMProCaretInfoWrap.__Register);
         
         
             translator.DelayWrapLoader(typeof(TMPro.TMP_TextUtilities), TMProTMP_TextUtilitiesWrap.__Register);
         
-        }
-        
-        static void wrapInit12(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(TMPro.TMP_UpdateManager), TMProTMP_UpdateManagerWrap.__Register);
         
@@ -2052,16 +2058,16 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(UnityEngine.UI.LayoutUtility), UnityEngineUILayoutUtilityWrap.__Register);
         
+        }
+        
+        static void wrapInit13(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(UnityEngine.UI.VerticalLayoutGroup), UnityEngineUIVerticalLayoutGroupWrap.__Register);
         
         
             translator.DelayWrapLoader(typeof(UnityEngine.UI.Mask), UnityEngineUIMaskWrap.__Register);
         
-        }
-        
-        static void wrapInit13(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(UnityEngine.UI.MaskUtilities), UnityEngineUIMaskUtilitiesWrap.__Register);
         
@@ -2209,16 +2215,16 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(DG.Tweening.Core.DOTweenSettings.ModulesSetup), DGTweeningCoreDOTweenSettingsModulesSetupWrap.__Register);
         
+        }
+        
+        static void wrapInit14(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(CloudControl), CloudControlWrap.__Register);
         
         
             translator.DelayWrapLoader(typeof(AFInAppEventParameterName), AFInAppEventParameterNameWrap.__Register);
         
-        }
-        
-        static void wrapInit14(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(AFInAppEventType), AFInAppEventTypeWrap.__Register);
         
@@ -2271,9 +2277,6 @@ namespace XLua.CSObjectWrap
             translator.DelayWrapLoader(typeof(MonkeyPost), MonkeyPostWrap.__Register);
         
         
-            translator.DelayWrapLoader(typeof(AFAdRevenueEvent), AFAdRevenueEventWrap.__Register);
-        
-        
             translator.DelayWrapLoader(typeof(UIInputHelper), UIInputHelperWrap.__Register);
         
         
@@ -2369,14 +2372,14 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(IronSourceConfig), IronSourceConfigWrap.__Register);
         
-        
-            translator.DelayWrapLoader(typeof(IronSourceConstants), IronSourceConstantsWrap.__Register);
-        
         }
         
         static void wrapInit15(LuaEnv luaenv, ObjectTranslator translator)
         {
         
+            translator.DelayWrapLoader(typeof(IronSourceConstants), IronSourceConstantsWrap.__Register);
+        
+        
             translator.DelayWrapLoader(typeof(IronSourceError), IronSourceErrorWrap.__Register);
         
         
@@ -2431,6 +2434,66 @@ namespace XLua.CSObjectWrap
             translator.DelayWrapLoader(typeof(UnsupportedPlatformAgent), UnsupportedPlatformAgentWrap.__Register);
         
         
+            translator.DelayWrapLoader(typeof(ISAdQualityDeviceIdType), ISAdQualityDeviceIdTypeWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityAdType), ISAdQualityAdTypeWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityConfig), ISAdQualityConfigWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityCustomMediationRevenue), ISAdQualityCustomMediationRevenueWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityInitCallback), ISAdQualityInitCallbackWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityInitCallbackWrapper), ISAdQualityInitCallbackWrapperWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityInitError), ISAdQualityInitErrorWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityLogLevel), ISAdQualityLogLevelWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityMediationNetwork), ISAdQualityMediationNetworkWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualitySegment), ISAdQualitySegmentWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityUtils), ISAdQualityUtilsWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(IronSourceAdQuality), IronSourceAdQualityWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ISAdQualityEditorScript), ISAdQualityEditorScriptWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(IronSourceAdQualityManifestTools), IronSourceAdQualityManifestToolsWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ObjectKvp), ObjectKvpWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(ObjectDictionary), ObjectDictionaryWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(BaseBehaviour), BaseBehaviourWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(CodeGeneratedSingleton), CodeGeneratedSingletonWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(SceneSingleton), SceneSingletonWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(UnitySingleton), UnitySingletonWrap.__Register);
+        
+        
             translator.DelayWrapLoader(typeof(TAExample), TAExampleWrap.__Register);
         
         
@@ -2466,6 +2529,10 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper), ThinkingAnalyticsWrapperThinkingAnalyticsWrapperWrap.__Register);
         
+        }
+        
+        static void wrapInit16(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(ThinkingAnalytics.Utils.TD_Log), ThinkingAnalyticsUtilsTD_LogWrap.__Register);
         
@@ -2479,10 +2546,16 @@ namespace XLua.CSObjectWrap
             translator.DelayWrapLoader(typeof(ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler), ThinkingAnalyticsTaExceptionThinkingSDKExceptionHandlerWrap.__Register);
         
         
+            translator.DelayWrapLoader(typeof(ISAdQualityJSON.Json), ISAdQualityJSONJsonWrap.__Register);
+        
+        
             translator.DelayWrapLoader(typeof(IronSourceJSON.Json), IronSourceJSONJsonWrap.__Register);
         
         
-            translator.DelayWrapLoader(typeof(AppsFlyerSDK.AppsFlyerAdRevenue), AppsFlyerSDKAppsFlyerAdRevenueWrap.__Register);
+            translator.DelayWrapLoader(typeof(MolocoSdk.MolocoSDK), MolocoSdkMolocoSDKWrap.__Register);
+        
+        
+            translator.DelayWrapLoader(typeof(MolocoSdk.PrivacySettings), MolocoSdkPrivacySettingsWrap.__Register);
         
         
             translator.DelayWrapLoader(typeof(com.adjust.sdk.JSONNode), comadjustsdkJSONNodeWrap.__Register);
@@ -2529,10 +2602,6 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustLogLevelExtension), comadjustsdkAdjustLogLevelExtensionWrap.__Register);
         
-        }
-        
-        static void wrapInit16(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustPlayStoreSubscription), comadjustsdkAdjustPlayStoreSubscriptionWrap.__Register);
         
@@ -2617,6 +2686,10 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(System.DateTime), SystemDateTimeWrap.__Register);
         
+        }
+        
+        static void wrapInit17(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(System.DateTimeOffset), SystemDateTimeOffsetWrap.__Register);
         
@@ -2686,10 +2759,6 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(UnityEngine.Camera.RenderRequestOutputSpace), UnityEngineCameraRenderRequestOutputSpaceWrap.__Register);
         
-        }
-        
-        static void wrapInit17(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(UnityEngine.TextCore.FaceInfo), UnityEngineTextCoreFaceInfoWrap.__Register);
         
@@ -2774,6 +2843,10 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(UnityEngine.Camera.GateFitMode), UnityEngineCameraGateFitModeWrap.__Register);
         
+        }
+        
+        static void wrapInit18(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(UnityEngine.Camera.StereoscopicEye), UnityEngineCameraStereoscopicEyeWrap.__Register);
         
@@ -2843,10 +2916,6 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect.MovementType), UnityEngineUIScrollRectMovementTypeWrap.__Register);
         
-        }
-        
-        static void wrapInit18(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), UnityEngineUIScrollRectScrollbarVisibilityWrap.__Register);
         
@@ -2931,6 +3000,10 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(TMPro.TextAlignmentOptions), TMProTextAlignmentOptionsWrap.__Register);
         
+        }
+        
+        static void wrapInit19(LuaEnv luaenv, ObjectTranslator translator)
+        {
         
             translator.DelayWrapLoader(typeof(TMPro.TextMeshProUGUI), TMProTextMeshProUGUIWrap.__Register);
         
@@ -3000,10 +3073,6 @@ namespace XLua.CSObjectWrap
         
             translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), ThinkingAnalyticsThinkingAnalyticsAPITATimeZoneWrap.__Register);
         
-        }
-        
-        static void wrapInit19(LuaEnv luaenv, ObjectTranslator translator)
-        {
         
             translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), ThinkingAnalyticsThinkingAnalyticsAPITAModeWrap.__Register);
         

Assets/XLua/Gen/link.xml

@@ -70,6 +70,8 @@
 		<type fullname="BF.BFNativeSDKManager" preserve="all"/>
 		<type fullname="BF.BFPaySDKManager" preserve="all"/>
 		<type fullname="BF.BFThirdReportSDKManager" preserve="all"/>
+		<type fullname="BF.NotchScreenInfo" preserve="all"/>
+		<type fullname="BF.DZSDKManager" preserve="all"/>
 		<type fullname="BF.NativeUtils" preserve="all"/>
 		<type fullname="BF.BFParseClientManager" preserve="all"/>
 		<type fullname="BF.SDKManager" preserve="all"/>
@@ -201,7 +203,6 @@
 		<type fullname="UIOutlineEffect" preserve="all"/>
 		<type fullname="UIResGhostTweenEffect" preserve="all"/>
 		<type fullname="MonkeyPost" preserve="all"/>
-		<type fullname="AFAdRevenueEvent" preserve="all"/>
 		<type fullname="UIInputHelper" preserve="all"/>
 		<type fullname="FBWindowsA2UNotificationsManager" preserve="all"/>
 		<type fullname="FBWindowsADSManager" preserve="all"/>
@@ -253,6 +254,26 @@
 		<type fullname="IronSourceSegmentAndroid" preserve="all"/>
 		<type fullname="IronSourceUtils" preserve="all"/>
 		<type fullname="UnsupportedPlatformAgent" preserve="all"/>
+		<type fullname="ISAdQualityDeviceIdType" preserve="all"/>
+		<type fullname="ISAdQualityAdType" preserve="all"/>
+		<type fullname="ISAdQualityConfig" preserve="all"/>
+		<type fullname="ISAdQualityCustomMediationRevenue" preserve="all"/>
+		<type fullname="ISAdQualityInitCallback" preserve="all"/>
+		<type fullname="ISAdQualityInitCallbackWrapper" preserve="all"/>
+		<type fullname="ISAdQualityInitError" preserve="all"/>
+		<type fullname="ISAdQualityLogLevel" preserve="all"/>
+		<type fullname="ISAdQualityMediationNetwork" preserve="all"/>
+		<type fullname="ISAdQualitySegment" preserve="all"/>
+		<type fullname="ISAdQualityUtils" preserve="all"/>
+		<type fullname="IronSourceAdQuality" preserve="all"/>
+		<type fullname="ISAdQualityEditorScript" preserve="all"/>
+		<type fullname="IronSourceAdQualityManifestTools" preserve="all"/>
+		<type fullname="ObjectKvp" preserve="all"/>
+		<type fullname="ObjectDictionary" preserve="all"/>
+		<type fullname="BaseBehaviour" preserve="all"/>
+		<type fullname="CodeGeneratedSingleton" preserve="all"/>
+		<type fullname="SceneSingleton" preserve="all"/>
+		<type fullname="UnitySingleton" preserve="all"/>
 		<type fullname="TAExample" preserve="all"/>
 		<type fullname="SignInWithAppleTest_Callbacks" preserve="all"/>
 		<type fullname="SignInWithAppleTest_EventSystem" preserve="all"/>
@@ -269,8 +290,10 @@
 		<type fullname="ThinkingAnalytics.Utils.TD_MiniJSON" preserve="all"/>
 		<type fullname="ThinkingAnalytics.Utils.TD_PropertiesChecker" preserve="all"/>
 		<type fullname="ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler" preserve="all"/>
+		<type fullname="ISAdQualityJSON.Json" preserve="all"/>
 		<type fullname="IronSourceJSON.Json" preserve="all"/>
-		<type fullname="AppsFlyerSDK.AppsFlyerAdRevenue" preserve="all"/>
+		<type fullname="MolocoSdk.MolocoSDK" preserve="all"/>
+		<type fullname="MolocoSdk.PrivacySettings" preserve="all"/>
 		<type fullname="com.adjust.sdk.JSONNode" preserve="all"/>
 		<type fullname="com.adjust.sdk.JSONArray" preserve="all"/>
 		<type fullname="com.adjust.sdk.JSONClass" preserve="all"/>