snxxz_scripts.git

			@@ -16,4 +16,9184 @@
			{
			using Utils = XLua.Utils;

			public class E_ActorClassTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_ActorClassType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_ActorClassType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_ActorClassType), L, null, 23, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnDefine", E_ActorClassType.UnDefine);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hero", E_ActorClassType.Hero);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Player", E_ActorClassType.Player);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard", E_ActorClassType.Guard);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFightNorm", E_ActorClassType.NpcFightNorm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFightBoss", E_ActorClassType.NpcFightBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcSummonFunc", E_ActorClassType.NpcSummonFunc);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcCollect", E_ActorClassType.NpcCollect);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcSummonFight", E_ActorClassType.NpcSummonFight);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFunc", E_ActorClassType.NpcFunc);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", E_ActorClassType.Pet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcTouchKilled", E_ActorClassType.NpcTouchKilled);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientFightNorm", E_ActorClassType.NpcClientFightNorm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientFightBoss", E_ActorClassType.NpcClientFightBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientFunc", E_ActorClassType.NpcClientFunc);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFightVirtualPlayer", E_ActorClassType.NpcFightVirtualPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerXmzz", E_ActorClassType.PlayerXmzz);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClientPlayer", E_ActorClassType.ClientPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerZZ", E_ActorClassType.PlayerZZ);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerSgzcRobot", E_ActorClassType.PlayerSgzcRobot);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPClientPlayer", E_ActorClassType.PVPClientPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientCollect", E_ActorClassType.NpcClientCollect);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_ActorClassType), 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.PushE_ActorClassType(L, (E_ActorClassType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "UnDefine"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.UnDefine);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Hero"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.Hero);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Player"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.Player);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.Guard);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFightNorm"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcFightNorm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFightBoss"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcFightBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcSummonFunc"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcSummonFunc);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcCollect"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcCollect);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcSummonFight"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcSummonFight);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFunc"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcFunc);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.Pet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcTouchKilled"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcTouchKilled);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientFightNorm"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientFightNorm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientFightBoss"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientFightBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientFunc"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientFunc);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFightVirtualPlayer"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcFightVirtualPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerXmzz"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.PlayerXmzz);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ClientPlayer"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.ClientPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerZZ"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.PlayerZZ);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerSgzcRobot"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.PlayerSgzcRobot);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPClientPlayer"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.PVPClientPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientCollect"))
			{
			translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientCollect);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_ActorClassType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_ActorClassType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_ActorStateWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_ActorState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_ActorState), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_ActorState), L, null, 11, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Idle", E_ActorState.Idle);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CtrlRun", E_ActorState.CtrlRun);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoRun", E_ActorState.AutoRun);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hurt", E_ActorState.Hurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Die", E_ActorState.Die);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CommonAtk", E_ActorState.CommonAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CastSkill", E_ActorState.CastSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DaZuo", E_ActorState.DaZuo);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Roll", E_ActorState.Roll);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mocked", E_ActorState.Mocked);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_ActorState), 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.PushE_ActorState(L, (E_ActorState)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Idle"))
			{
			translator.PushE_ActorState(L, E_ActorState.Idle);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CtrlRun"))
			{
			translator.PushE_ActorState(L, E_ActorState.CtrlRun);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoRun"))
			{
			translator.PushE_ActorState(L, E_ActorState.AutoRun);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Hurt"))
			{
			translator.PushE_ActorState(L, E_ActorState.Hurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Die"))
			{
			translator.PushE_ActorState(L, E_ActorState.Die);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CommonAtk"))
			{
			translator.PushE_ActorState(L, E_ActorState.CommonAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CastSkill"))
			{
			translator.PushE_ActorState(L, E_ActorState.CastSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DaZuo"))
			{
			translator.PushE_ActorState(L, E_ActorState.DaZuo);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Roll"))
			{
			translator.PushE_ActorState(L, E_ActorState.Roll);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mocked"))
			{
			translator.PushE_ActorState(L, E_ActorState.Mocked);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_ActorState!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_ActorState! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_BuffTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_BuffType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_BuffType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_BuffType), L, null, 12, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfBuff", E_BuffType.bfBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfDeBuff", E_BuffType.bfDeBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfAura", E_BuffType.bfAura);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfIncBuff", E_BuffType.bfIncBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "btPassiveBuf", E_BuffType.btPassiveBuf);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfEquipBuff", E_BuffType.bfEquipBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfMapBuff", E_BuffType.bfMapBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfActionBuff", E_BuffType.bfActionBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfProcessBuff", E_BuffType.bfProcessBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfProcessDeBuff", E_BuffType.bfProcessDeBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "btBufMax", E_BuffType.btBufMax);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_BuffType), 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.PushE_BuffType(L, (E_BuffType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "bfBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfDeBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfDeBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfAura"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfAura);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfIncBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfIncBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "btPassiveBuf"))
			{
			translator.PushE_BuffType(L, E_BuffType.btPassiveBuf);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfEquipBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfEquipBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfMapBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfMapBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfActionBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfActionBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfProcessBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfProcessBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "bfProcessDeBuff"))
			{
			translator.PushE_BuffType(L, E_BuffType.bfProcessDeBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "btBufMax"))
			{
			translator.PushE_BuffType(L, E_BuffType.btBufMax);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_BuffType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_BuffType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_ClientNpcTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_ClientNpcType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_ClientNpcType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_ClientNpcType), L, null, 3, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Func", E_ClientNpcType.Func);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fight", E_ClientNpcType.Fight);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_ClientNpcType), 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.PushE_ClientNpcType(L, (E_ClientNpcType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Func"))
			{
			translator.PushE_ClientNpcType(L, E_ClientNpcType.Func);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fight"))
			{
			translator.PushE_ClientNpcType(L, E_ClientNpcType.Fight);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_ClientNpcType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_ClientNpcType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_NpcTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_NpcType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_NpcType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_NpcType), L, null, 22, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Func", E_NpcType.Func);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Defend", E_NpcType.Defend);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fight", E_NpcType.Fight);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Summon", E_NpcType.Summon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ghost", E_NpcType.Ghost);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trap", E_NpcType.Trap);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Car", E_NpcType.Car);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sprite", E_NpcType.Sprite);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VirtualPlayer", E_NpcType.VirtualPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flag", E_NpcType.Flag);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collect", E_NpcType.Collect);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Catch", E_NpcType.Catch);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", E_NpcType.Pet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TouchKilled", E_NpcType.TouchKilled);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FMBoss", E_NpcType.FMBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BreakableObj", E_NpcType.BreakableObj);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightAssist", E_NpcType.FightAssist);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SGZC_FightAssist", E_NpcType.SGZC_FightAssist);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MonsterTime", E_NpcType.MonsterTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalEnemy", E_NpcType.PersonalEnemy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenWorldMap", E_NpcType.OpenWorldMap);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_NpcType), 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.PushE_NpcType(L, (E_NpcType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Func"))
			{
			translator.PushE_NpcType(L, E_NpcType.Func);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Defend"))
			{
			translator.PushE_NpcType(L, E_NpcType.Defend);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fight"))
			{
			translator.PushE_NpcType(L, E_NpcType.Fight);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Summon"))
			{
			translator.PushE_NpcType(L, E_NpcType.Summon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Ghost"))
			{
			translator.PushE_NpcType(L, E_NpcType.Ghost);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Trap"))
			{
			translator.PushE_NpcType(L, E_NpcType.Trap);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Car"))
			{
			translator.PushE_NpcType(L, E_NpcType.Car);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Sprite"))
			{
			translator.PushE_NpcType(L, E_NpcType.Sprite);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "VirtualPlayer"))
			{
			translator.PushE_NpcType(L, E_NpcType.VirtualPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Flag"))
			{
			translator.PushE_NpcType(L, E_NpcType.Flag);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Collect"))
			{
			translator.PushE_NpcType(L, E_NpcType.Collect);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Catch"))
			{
			translator.PushE_NpcType(L, E_NpcType.Catch);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
			{
			translator.PushE_NpcType(L, E_NpcType.Pet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TouchKilled"))
			{
			translator.PushE_NpcType(L, E_NpcType.TouchKilled);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FMBoss"))
			{
			translator.PushE_NpcType(L, E_NpcType.FMBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BreakableObj"))
			{
			translator.PushE_NpcType(L, E_NpcType.BreakableObj);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FightAssist"))
			{
			translator.PushE_NpcType(L, E_NpcType.FightAssist);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SGZC_FightAssist"))
			{
			translator.PushE_NpcType(L, E_NpcType.SGZC_FightAssist);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MonsterTime"))
			{
			translator.PushE_NpcType(L, E_NpcType.MonsterTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalEnemy"))
			{
			translator.PushE_NpcType(L, E_NpcType.PersonalEnemy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenWorldMap"))
			{
			translator.PushE_NpcType(L, E_NpcType.OpenWorldMap);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_NpcType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_NpcType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_MovingStateWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_MovingState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_MovingState), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_MovingState), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", E_MovingState.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fly", E_MovingState.Fly);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ride", E_MovingState.Ride);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_MovingState), 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.PushE_MovingState(L, (E_MovingState)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushE_MovingState(L, E_MovingState.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fly"))
			{
			translator.PushE_MovingState(L, E_MovingState.Fly);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Ride"))
			{
			translator.PushE_MovingState(L, E_MovingState.Ride);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_MovingState!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_MovingState! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class WindowTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(WindowType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(WindowType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(WindowType), L, null, 8, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Base", WindowType.Base);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", WindowType.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Modal", WindowType.Modal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tip", WindowType.Tip);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "System", WindowType.System);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Loading", WindowType.Loading);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flag", WindowType.Flag);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(WindowType), 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.PushWindowType(L, (WindowType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Base"))
			{
			translator.PushWindowType(L, WindowType.Base);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushWindowType(L, WindowType.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Modal"))
			{
			translator.PushWindowType(L, WindowType.Modal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Tip"))
			{
			translator.PushWindowType(L, WindowType.Tip);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "System"))
			{
			translator.PushWindowType(L, WindowType.System);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Loading"))
			{
			translator.PushWindowType(L, WindowType.Loading);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Flag"))
			{
			translator.PushWindowType(L, WindowType.Flag);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for WindowType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for WindowType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class GestureTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(GestureType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(GestureType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(GestureType), L, null, 5, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", GestureType.Left);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", GestureType.Right);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Up", GestureType.Up);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Down", GestureType.Down);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(GestureType), 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.PushGestureType(L, (GestureType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
			{
			translator.PushGestureType(L, GestureType.Left);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
			{
			translator.PushGestureType(L, GestureType.Right);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Up"))
			{
			translator.PushGestureType(L, GestureType.Up);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Down"))
			{
			translator.PushGestureType(L, GestureType.Down);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for GestureType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for GestureType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class UnityPlatformWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(UnityPlatform), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(UnityPlatform), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(UnityPlatform), L, null, 5, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Editor", UnityPlatform.Editor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Android", UnityPlatform.Android);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Iphone", UnityPlatform.Iphone);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standalone", UnityPlatform.Standalone);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(UnityPlatform), 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.PushUnityPlatform(L, (UnityPlatform)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Editor"))
			{
			translator.PushUnityPlatform(L, UnityPlatform.Editor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Android"))
			{
			translator.PushUnityPlatform(L, UnityPlatform.Android);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Iphone"))
			{
			translator.PushUnityPlatform(L, UnityPlatform.Iphone);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Standalone"))
			{
			translator.PushUnityPlatform(L, UnityPlatform.Standalone);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for UnityPlatform!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for UnityPlatform! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class RoleRenameResultWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(RoleRenameResult), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(RoleRenameResult), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(RoleRenameResult), L, null, 7, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MoneyErr", RoleRenameResult.MoneyErr);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameRuleErr", RoleRenameResult.NameRuleErr);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameLengErr", RoleRenameResult.NameLengErr);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameRepeatErr", RoleRenameResult.NameRepeatErr);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RenameFailErr", RoleRenameResult.RenameFailErr);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RenameSuccess", RoleRenameResult.RenameSuccess);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(RoleRenameResult), 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.PushRoleRenameResult(L, (RoleRenameResult)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "MoneyErr"))
			{
			translator.PushRoleRenameResult(L, RoleRenameResult.MoneyErr);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NameRuleErr"))
			{
			translator.PushRoleRenameResult(L, RoleRenameResult.NameRuleErr);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NameLengErr"))
			{
			translator.PushRoleRenameResult(L, RoleRenameResult.NameLengErr);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NameRepeatErr"))
			{
			translator.PushRoleRenameResult(L, RoleRenameResult.NameRepeatErr);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RenameFailErr"))
			{
			translator.PushRoleRenameResult(L, RoleRenameResult.RenameFailErr);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RenameSuccess"))
			{
			translator.PushRoleRenameResult(L, RoleRenameResult.RenameSuccess);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for RoleRenameResult!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for RoleRenameResult! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_SkillCastTargetWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_SkillCastTarget), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_SkillCastTarget), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_SkillCastTarget), L, null, 16, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", E_SkillCastTarget.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Self", E_SkillCastTarget.Self);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamMate", E_SkillCastTarget.TeamMate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Friend", E_SkillCastTarget.Friend);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CanAttacked", E_SkillCastTarget.CanAttacked);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SelfAndFriend", E_SkillCastTarget.SelfAndFriend);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerDeadBody", E_SkillCastTarget.PlayerDeadBody);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnDeadPlayer", E_SkillCastTarget.UnDeadPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CanAttackedMonster", E_SkillCastTarget.CanAttackedMonster);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CanAttackedPlayer", E_SkillCastTarget.CanAttackedPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", E_SkillCastTarget.All);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetToOwner", E_SkillCastTarget.PetToOwner);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SummonToOwner", E_SkillCastTarget.SummonToOwner);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Monster", E_SkillCastTarget.Monster);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FriendNpc", E_SkillCastTarget.FriendNpc);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_SkillCastTarget), 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.PushE_SkillCastTarget(L, (E_SkillCastTarget)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Self"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.Self);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamMate"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.TeamMate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Friend"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.Friend);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CanAttacked"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.CanAttacked);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SelfAndFriend"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.SelfAndFriend);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerDeadBody"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.PlayerDeadBody);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "UnDeadPlayer"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.UnDeadPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CanAttackedMonster"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.CanAttackedMonster);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CanAttackedPlayer"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.CanAttackedPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.All);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetToOwner"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.PetToOwner);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SummonToOwner"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.SummonToOwner);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Monster"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.Monster);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FriendNpc"))
			{
			translator.PushE_SkillCastTarget(L, E_SkillCastTarget.FriendNpc);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_SkillCastTarget!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_SkillCastTarget! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_SkillTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_SkillType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_SkillType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_SkillType), L, null, 24, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Special", E_SkillType.Special);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Attack", E_SkillType.Attack);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Recover", E_SkillType.Recover);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ContinuousGain", E_SkillType.ContinuousGain);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SustainedReduction", E_SkillType.SustainedReduction);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GainBuff", E_SkillType.GainBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReductionBuff", E_SkillType.ReductionBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Passive", E_SkillType.Passive);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Reborn", E_SkillType.Reborn);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ValueAdded", E_SkillType.ValueAdded);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Halo", E_SkillType.Halo);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip", E_SkillType.Equip);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Area", E_SkillType.Area);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Summon", E_SkillType.Summon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ControlBuff", E_SkillType.ControlBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MutilHurtBuffAtk", E_SkillType.MutilHurtBuffAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveGainBuff", E_SkillType.PassiveGainBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveReductionBuff", E_SkillType.PassiveReductionBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveControlBuff", E_SkillType.PassiveControlBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Property", E_SkillType.Property);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveBuff", E_SkillType.PassiveBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveContinuousGain", E_SkillType.PassiveContinuousGain);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveSustainedReduction", E_SkillType.PassiveSustainedReduction);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_SkillType), 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.PushE_SkillType(L, (E_SkillType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Special"))
			{
			translator.PushE_SkillType(L, E_SkillType.Special);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Attack"))
			{
			translator.PushE_SkillType(L, E_SkillType.Attack);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Recover"))
			{
			translator.PushE_SkillType(L, E_SkillType.Recover);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ContinuousGain"))
			{
			translator.PushE_SkillType(L, E_SkillType.ContinuousGain);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SustainedReduction"))
			{
			translator.PushE_SkillType(L, E_SkillType.SustainedReduction);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GainBuff"))
			{
			translator.PushE_SkillType(L, E_SkillType.GainBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReductionBuff"))
			{
			translator.PushE_SkillType(L, E_SkillType.ReductionBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Passive"))
			{
			translator.PushE_SkillType(L, E_SkillType.Passive);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Reborn"))
			{
			translator.PushE_SkillType(L, E_SkillType.Reborn);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ValueAdded"))
			{
			translator.PushE_SkillType(L, E_SkillType.ValueAdded);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Halo"))
			{
			translator.PushE_SkillType(L, E_SkillType.Halo);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip"))
			{
			translator.PushE_SkillType(L, E_SkillType.Equip);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Area"))
			{
			translator.PushE_SkillType(L, E_SkillType.Area);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Summon"))
			{
			translator.PushE_SkillType(L, E_SkillType.Summon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ControlBuff"))
			{
			translator.PushE_SkillType(L, E_SkillType.ControlBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MutilHurtBuffAtk"))
			{
			translator.PushE_SkillType(L, E_SkillType.MutilHurtBuffAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveGainBuff"))
			{
			translator.PushE_SkillType(L, E_SkillType.PassiveGainBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveReductionBuff"))
			{
			translator.PushE_SkillType(L, E_SkillType.PassiveReductionBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveControlBuff"))
			{
			translator.PushE_SkillType(L, E_SkillType.PassiveControlBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Property"))
			{
			translator.PushE_SkillType(L, E_SkillType.Property);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveBuff"))
			{
			translator.PushE_SkillType(L, E_SkillType.PassiveBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveContinuousGain"))
			{
			translator.PushE_SkillType(L, E_SkillType.PassiveContinuousGain);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveSustainedReduction"))
			{
			translator.PushE_SkillType(L, E_SkillType.PassiveSustainedReduction);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_SkillType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_SkillType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_SkillFuncTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_SkillFuncType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_SkillFuncType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_SkillFuncType), L, null, 15, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Common", E_SkillFuncType.Common);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoActiveSkill", E_SkillFuncType.FaBaoActiveSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoPassiveSkills", E_SkillFuncType.FaBaoPassiveSkills);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSpSkill", E_SkillFuncType.FaBaoSpSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TalentSkills", E_SkillFuncType.TalentSkills);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RiderSkill", E_SkillFuncType.RiderSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetSkill", E_SkillFuncType.PetSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GodWeaponSkill", E_SkillFuncType.GodWeaponSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NormalAttack", E_SkillFuncType.NormalAttack);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpLv15Skill", E_SkillFuncType.SpLv15Skill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Roll", E_SkillFuncType.Roll);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmSkill", E_SkillFuncType.RealmSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MythicalAnimal", E_SkillFuncType.MythicalAnimal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZhuxianSkill", E_SkillFuncType.ZhuxianSkill);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_SkillFuncType), 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.PushE_SkillFuncType(L, (E_SkillFuncType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Common"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.Common);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoActiveSkill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.FaBaoActiveSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoPassiveSkills"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.FaBaoPassiveSkills);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSpSkill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.FaBaoSpSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TalentSkills"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.TalentSkills);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RiderSkill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.RiderSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetSkill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.PetSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GodWeaponSkill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.GodWeaponSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NormalAttack"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.NormalAttack);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SpLv15Skill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.SpLv15Skill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Roll"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.Roll);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmSkill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.RealmSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MythicalAnimal"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.MythicalAnimal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZhuxianSkill"))
			{
			translator.PushE_SkillFuncType(L, E_SkillFuncType.ZhuxianSkill);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_SkillFuncType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_SkillFuncType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_SkillCastTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_SkillCastType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_SkillCastType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_SkillCastType), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", E_SkillCastType.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeedTarget", E_SkillCastType.NeedTarget);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ground", E_SkillCastType.Ground);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_SkillCastType), 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.PushE_SkillCastType(L, (E_SkillCastType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushE_SkillCastType(L, E_SkillCastType.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NeedTarget"))
			{
			translator.PushE_SkillCastType(L, E_SkillCastType.NeedTarget);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Ground"))
			{
			translator.PushE_SkillCastType(L, E_SkillCastType.Ground);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_SkillCastType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_SkillCastType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class MapTransferTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(MapTransferType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(MapTransferType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(MapTransferType), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldTransport", MapTransferType.WorldTransport);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BigMapTransport", MapTransferType.BigMapTransport);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MissionTransport", MapTransferType.MissionTransport);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(MapTransferType), 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.PushMapTransferType(L, (MapTransferType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "WorldTransport"))
			{
			translator.PushMapTransferType(L, MapTransferType.WorldTransport);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BigMapTransport"))
			{
			translator.PushMapTransferType(L, MapTransferType.BigMapTransport);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MissionTransport"))
			{
			translator.PushMapTransferType(L, MapTransferType.MissionTransport);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for MapTransferType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for MapTransferType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class DropItemTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(DropItemType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DropItemType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(DropItemType), L, null, 5, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern0", DropItemType.Pattern0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern1", DropItemType.Pattern1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern2", DropItemType.Pattern2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern3", DropItemType.Pattern3);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(DropItemType), 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.PushDropItemType(L, (DropItemType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern0"))
			{
			translator.PushDropItemType(L, DropItemType.Pattern0);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern1"))
			{
			translator.PushDropItemType(L, DropItemType.Pattern1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern2"))
			{
			translator.PushDropItemType(L, DropItemType.Pattern2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern3"))
			{
			translator.PushDropItemType(L, DropItemType.Pattern3);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for DropItemType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for DropItemType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class DailyQuestTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(DailyQuestType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DailyQuestType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(DailyQuestType), L, null, 34, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BountyMission", DailyQuestType.BountyMission);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IceCrystal", DailyQuestType.IceCrystal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyFeast", DailyQuestType.FairyFeast);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlastStove", DailyQuestType.BlastStove);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kirin", DailyQuestType.Kirin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLand", DailyQuestType.FairyLand);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GuardSky", DailyQuestType.GuardSky);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", DailyQuestType.Demon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trial", DailyQuestType.Trial);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGround", DailyQuestType.AncientBattleGround);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmperorRelic", DailyQuestType.EmperorRelic);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WyTaiChi", DailyQuestType.WyTaiChi);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLeague", DailyQuestType.FairyLeague);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeavenBattle", DailyQuestType.HeavenBattle);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Prayer", DailyQuestType.Prayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldBoss", DailyQuestType.WorldBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJar", DailyQuestType.DemonJar);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyTask", DailyQuestType.FairyTask);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTowerSweep", DailyQuestType.RuneTowerSweep);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", DailyQuestType.RuneTower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureCollectSoul", DailyQuestType.TreasureCollectSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BossHome", DailyQuestType.BossHome);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalBoss", DailyQuestType.PersonalBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodArea", DailyQuestType.ElderGodArea);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyGrabBoss", DailyQuestType.FairyGrabBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonster", DailyQuestType.KillMonster);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DungeonAssist", DailyQuestType.DungeonAssist);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoulDungeon", DailyQuestType.GatherSoulDungeon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerPk", DailyQuestType.CrossServerPk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllianceBoss", DailyQuestType.AllianceBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RidingPetActivity", DailyQuestType.RidingPetActivity);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HazyRegion", DailyQuestType.HazyRegion);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkyTower", DailyQuestType.SkyTower);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(DailyQuestType), 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.PushDailyQuestType(L, (DailyQuestType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "BountyMission"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.BountyMission);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IceCrystal"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.IceCrystal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyFeast"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.FairyFeast);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BlastStove"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.BlastStove);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Kirin"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.Kirin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLand"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.FairyLand);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GuardSky"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.GuardSky);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.Demon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Trial"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.Trial);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGround"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.AncientBattleGround);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EmperorRelic"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.EmperorRelic);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WyTaiChi"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.WyTaiChi);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLeague"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.FairyLeague);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HeavenBattle"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.HeavenBattle);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Prayer"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.Prayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldBoss"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.WorldBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJar"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.DemonJar);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyTask"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.FairyTask);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTowerSweep"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.RuneTowerSweep);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.RuneTower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureCollectSoul"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.TreasureCollectSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BossHome"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.BossHome);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalBoss"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.PersonalBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodArea"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.ElderGodArea);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyGrabBoss"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.FairyGrabBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonster"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.KillMonster);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DungeonAssist"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.DungeonAssist);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoulDungeon"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.GatherSoulDungeon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerPk"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.CrossServerPk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AllianceBoss"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.AllianceBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RidingPetActivity"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.RidingPetActivity);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HazyRegion"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.HazyRegion);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkyTower"))
			{
			translator.PushDailyQuestType(L, DailyQuestType.SkyTower);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for DailyQuestType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for DailyQuestType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class DungeonCoolDownTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(DungeonCoolDownType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DungeonCoolDownType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(DungeonCoolDownType), L, null, 11, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeaveMap", DungeonCoolDownType.LeaveMap);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WaitStart", DungeonCoolDownType.WaitStart);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightStart", DungeonCoolDownType.FightStart);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlagTake", DungeonCoolDownType.FlagTake);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NextRound", DungeonCoolDownType.NextRound);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FBAddTime", DungeonCoolDownType.FBAddTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodAreaDeadTime", DungeonCoolDownType.ElderGodAreaDeadTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PickUpTime", DungeonCoolDownType.PickUpTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WaitPlayer", DungeonCoolDownType.WaitPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerLeave", DungeonCoolDownType.PlayerLeave);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(DungeonCoolDownType), 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.PushDungeonCoolDownType(L, (DungeonCoolDownType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "LeaveMap"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.LeaveMap);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WaitStart"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.WaitStart);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FightStart"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.FightStart);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FlagTake"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.FlagTake);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NextRound"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.NextRound);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FBAddTime"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.FBAddTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodAreaDeadTime"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.ElderGodAreaDeadTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PickUpTime"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.PickUpTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WaitPlayer"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.WaitPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerLeave"))
			{
			translator.PushDungeonCoolDownType(L, DungeonCoolDownType.PlayerLeave);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for DungeonCoolDownType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for DungeonCoolDownType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class RoleEquipTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(RoleEquipType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(RoleEquipType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(RoleEquipType), L, null, 22, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Weapon", RoleEquipType.Weapon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Weapon2", RoleEquipType.Weapon2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hat", RoleEquipType.Hat);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clothes", RoleEquipType.Clothes);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Belt", RoleEquipType.Belt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trousers", RoleEquipType.Trousers);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Shoes", RoleEquipType.Shoes);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Glove", RoleEquipType.Glove);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Neck", RoleEquipType.Neck);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyCan1", RoleEquipType.FairyCan1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyCan2", RoleEquipType.FairyCan2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Jade", RoleEquipType.Jade);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", RoleEquipType.Wing);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard", RoleEquipType.Guard);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PeerlessWeapon1", RoleEquipType.PeerlessWeapon1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PeerlessWeapon2", RoleEquipType.PeerlessWeapon2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", RoleEquipType.Mount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionWeapon", RoleEquipType.FashionWeapon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionClothes", RoleEquipType.FashionClothes);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionWeapon2", RoleEquipType.FashionWeapon2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "retMax", RoleEquipType.retMax);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(RoleEquipType), 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.PushRoleEquipType(L, (RoleEquipType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Weapon"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Weapon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Weapon2"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Weapon2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Hat"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Hat);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Clothes"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Clothes);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Belt"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Belt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Trousers"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Trousers);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Shoes"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Shoes);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Glove"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Glove);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Neck"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Neck);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyCan1"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.FairyCan1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyCan2"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.FairyCan2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Jade"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Jade);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Wing);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Guard);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PeerlessWeapon1"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.PeerlessWeapon1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PeerlessWeapon2"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.PeerlessWeapon2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.Mount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionWeapon"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.FashionWeapon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionClothes"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.FashionClothes);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionWeapon2"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.FashionWeapon2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "retMax"))
			{
			translator.PushRoleEquipType(L, RoleEquipType.retMax);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for RoleEquipType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for RoleEquipType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class PlayerDataTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(PlayerDataType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(PlayerDataType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(PlayerDataType), L, null, 213, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AccountID", PlayerDataType.AccountID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerID", PlayerDataType.PlayerID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerName", PlayerDataType.PlayerName);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sex", PlayerDataType.Sex);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hair", PlayerDataType.Hair);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HairColor", PlayerDataType.HairColor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Face", PlayerDataType.Face);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job", PlayerDataType.Job);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LV", PlayerDataType.LV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TotalExp", PlayerDataType.TotalExp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Family", PlayerDataType.Family);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Country", PlayerDataType.Country);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamHornor", PlayerDataType.TeamHornor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PKValue", PlayerDataType.PKValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyHornor", PlayerDataType.FamilyHornor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyActiveValue", PlayerDataType.FamilyActiveValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryHornor", PlayerDataType.CountryHornor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mate", PlayerDataType.Mate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gold", PlayerDataType.Gold);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoldPaper", PlayerDataType.GoldPaper);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Silver", PlayerDataType.Silver);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SilverPaper", PlayerDataType.SilverPaper);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPoint", PlayerDataType.FightPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HappyPoint", PlayerDataType.HappyPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MapID", PlayerDataType.MapID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PosX", PlayerDataType.PosX);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PosY", PlayerDataType.PosY);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "State", PlayerDataType.State);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxHP", PlayerDataType.MaxHP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HP", PlayerDataType.HP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxMP", PlayerDataType.MaxMP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MP", PlayerDataType.MP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XP", PlayerDataType.XP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HPRestoreSetting", PlayerDataType.HPRestoreSetting);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MPRestoreSetting", PlayerDataType.MPRestoreSetting);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpRate", PlayerDataType.ExpRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreePoint", PlayerDataType.FreePoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreeSkillPoint", PlayerDataType.FreeSkillPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "STR", PlayerDataType.STR);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PNE", PlayerDataType.PNE);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PHY", PlayerDataType.PHY);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CON", PlayerDataType.CON);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEF", PlayerDataType.DEF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MINATK", PlayerDataType.MINATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAXATK", PlayerDataType.MAXATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAtkMin", PlayerDataType.MAtkMin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAtkMax", PlayerDataType.MAtkMax);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MDef", PlayerDataType.MDef);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HIT", PlayerDataType.HIT);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "POISIONATK", PlayerDataType.POISIONATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FIREATK", PlayerDataType.FIREATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REALATK", PlayerDataType.REALATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "THUNDERATK", PlayerDataType.THUNDERATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WINDATK", PlayerDataType.WINDATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "POISIONDEF", PlayerDataType.POISIONDEF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FIREDEF", PlayerDataType.FIREDEF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REALDEF", PlayerDataType.REALDEF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "THUNDERDEF", PlayerDataType.THUNDERDEF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WINDDEF", PlayerDataType.WINDDEF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Miss", PlayerDataType.Miss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHit", PlayerDataType.SuperHit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Buff", PlayerDataType.Buff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skill", PlayerDataType.Skill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mark", PlayerDataType.Mark);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SettingH", PlayerDataType.SettingH);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SettingV", PlayerDataType.SettingV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPK", PlayerDataType.FightPK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ActiveValue", PlayerDataType.ActiveValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerType", PlayerDataType.PlayerType);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameColor", PlayerDataType.NameColor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AtkInterval", PlayerDataType.AtkInterval);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Speed", PlayerDataType.Speed);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHitRate", PlayerDataType.SuperHitRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PickupDist", PlayerDataType.PickupDist);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryLastWeekHornor", PlayerDataType.CountryLastWeekHornor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastWeekOnlineTime", PlayerDataType.LastWeekOnlineTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastWeekFamilyActiveValue", PlayerDataType.LastWeekFamilyActiveValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FBID", PlayerDataType.FBID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyLV", PlayerDataType.FamilyLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealMapID", PlayerDataType.RealMapID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GMLevel", PlayerDataType.GMLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamID", PlayerDataType.TeamID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamLV", PlayerDataType.TeamLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPower", PlayerDataType.FightPower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornMapID", PlayerDataType.RebornMapID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornPosX", PlayerDataType.RebornPosX);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornPosY", PlayerDataType.RebornPosY);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Coin", PlayerDataType.Coin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BillboardLV", PlayerDataType.BillboardLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tick", PlayerDataType.Tick);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CurrentPlayerType", PlayerDataType.CurrentPlayerType);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FriendFavor", PlayerDataType.FriendFavor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BackpackLV", PlayerDataType.BackpackLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReincarnationLV", PlayerDataType.ReincarnationLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseSTR", PlayerDataType.BaseSTR);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasePNE", PlayerDataType.BasePNE);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasePHY", PlayerDataType.BasePHY);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseCON", PlayerDataType.BaseCON);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReceivedSalary", PlayerDataType.ReceivedSalary);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WarehouseLV", PlayerDataType.WarehouseLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipShowSwitch", PlayerDataType.EquipShowSwitch);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckValue", PlayerDataType.LuckValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr1", PlayerDataType.ExAttr1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr2", PlayerDataType.ExAttr2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr3", PlayerDataType.ExAttr3);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr4", PlayerDataType.ExAttr4);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr5", PlayerDataType.ExAttr5);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Faction", PlayerDataType.Faction);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InfamyValue", PlayerDataType.InfamyValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmLevel", PlayerDataType.RealmLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsFindByLabel", PlayerDataType.IsFindByLabel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsCloseFriendLabel", PlayerDataType.IsCloseFriendLabel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ChangeCoinPointTotal", PlayerDataType.ChangeCoinPointTotal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VIPLv", PlayerDataType.VIPLv);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr6", PlayerDataType.ExAttr6);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr7", PlayerDataType.ExAttr7);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr8", PlayerDataType.ExAttr8);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr9", PlayerDataType.ExAttr9);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr10", PlayerDataType.ExAttr10);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ModelMark", PlayerDataType.ModelMark);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrizeCoin", PlayerDataType.PrizeCoin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr11", PlayerDataType.ExAttr11);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr12", PlayerDataType.ExAttr12);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr13", PlayerDataType.ExAttr13);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr14", PlayerDataType.ExAttr14);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAtkRate", PlayerDataType.SkillAtkRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHitRate", PlayerDataType.LuckyHitRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHitVal", PlayerDataType.LuckyHitVal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GreatHitRate", PlayerDataType.GreatHitRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GreatHitVal", PlayerDataType.GreatHitVal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillBackHP", PlayerDataType.KillBackHP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillBackMP", PlayerDataType.KillBackMP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamageReduceRate", PlayerDataType.DamageReduceRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamageBackRate", PlayerDataType.DamageBackRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoldFoundRate", PlayerDataType.GoldFoundRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IgnoreDefRate", PlayerDataType.IgnoreDefRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx1", PlayerDataType.BattleValEx1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx2", PlayerDataType.BattleValEx2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx3", PlayerDataType.BattleValEx3);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx4", PlayerDataType.BattleValEx4);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx5", PlayerDataType.BattleValEx5);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HPRestorePer", PlayerDataType.HPRestorePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LVEx", PlayerDataType.LVEx);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LV2", PlayerDataType.LV2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpPoint", PlayerDataType.ExpPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OperateInfo", PlayerDataType.OperateInfo);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHitReduce", PlayerDataType.SuperHitReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHitRateReduce", PlayerDataType.LuckyHitRateReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAtkRateReduce", PlayerDataType.SkillAtkRateReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePVP", PlayerDataType.DamagePVP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpeedValue", PlayerDataType.SpeedValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePVE", PlayerDataType.DamagePVE);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetDamPer", PlayerDataType.PetDamPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IgnoreDefRateReduce", PlayerDataType.IgnoreDefRateReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamChanceDef", PlayerDataType.DamChanceDef);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BleedDamage", PlayerDataType.BleedDamage);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaintRate", PlayerDataType.FaintRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaintDefRate", PlayerDataType.FaintDefRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FinalHurt", PlayerDataType.FinalHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FinalHurtReduce", PlayerDataType.FinalHurtReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePerPVP", PlayerDataType.DamagePerPVP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePerPVPReduce", PlayerDataType.DamagePerPVPReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComboDamRate", PlayerDataType.ComboDamRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComboDamPer", PlayerDataType.ComboDamPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxProDef", PlayerDataType.MaxProDef);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyContribution", PlayerDataType.FamilyContribution);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyStoreScore", PlayerDataType.FamilyStoreScore);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneSplinters", PlayerDataType.RuneSplinters);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rune", PlayerDataType.Rune);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmPoint", PlayerDataType.RealmPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MagicEssence", PlayerDataType.MagicEssence);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionLiven", PlayerDataType.UnionLiven);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FBHelpPoint", PlayerDataType.FBHelpPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerPKState", PlayerDataType.PlayerPKState);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsAttackBossState", PlayerDataType.IsAttackBossState);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsMinimum", PlayerDataType.BasicsMinimum);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsMaxAttack", PlayerDataType.BasicsMaxAttack);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsLife", PlayerDataType.BasicsLife);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsDefense", PlayerDataType.BasicsDefense);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsScoreAHit", PlayerDataType.BasicsScoreAHit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsDodge", PlayerDataType.BasicsDodge);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnlyFinalHurt", PlayerDataType.OnlyFinalHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_ForbidenTalk", PlayerDataType.CDBPlayerRefresh_ForbidenTalk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FuncDef", PlayerDataType.CDBPlayerRefresh_FuncDef);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_TreasureScore", PlayerDataType.CDBPlayerRefresh_TreasureScore);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Danjing", PlayerDataType.CDBPlayerRefresh_Danjing);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_NPCHurtAddPer", PlayerDataType.CDBPlayerRefresh_NPCHurtAddPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FunalHurtPer", PlayerDataType.FunalHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_TalentPoint", PlayerDataType.CDBPlayerRefresh_TalentPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_1", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_2", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_3", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_3);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_4", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_4);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SoulDust", PlayerDataType.CDBPlayerRefresh_SoulDust);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SoulSplinters", PlayerDataType.CDBPlayerRefresh_SoulSplinters);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SoulCore", PlayerDataType.CDBPlayerRefresh_SoulCore);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Honor", PlayerDataType.CDBPlayerRefresh_Honor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_ZhuxianRate", PlayerDataType.CDBPlayerRefresh_ZhuxianRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Mater", PlayerDataType.CDBPlayerRefresh_Mater);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Wood", PlayerDataType.CDBPlayerRefresh_Wood);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Water", PlayerDataType.CDBPlayerRefresh_Water);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Fire", PlayerDataType.CDBPlayerRefresh_Fire);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Earth", PlayerDataType.CDBPlayerRefresh_Earth);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_NormalHurt", PlayerDataType.CDBPlayerRefresh_NormalHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_NormalHurtPer", PlayerDataType.CDBPlayerRefresh_NormalHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FabaoHurt", PlayerDataType.CDBPlayerRefresh_FabaoHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FabaoHurtPer", PlayerDataType.CDBPlayerRefresh_FabaoHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SuperHitRateReduce", PlayerDataType.CDBPlayerRefresh_SuperHitRateReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_LuckyHitReduce", PlayerDataType.CDBPlayerRefresh_LuckyHitReduce);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FinalHurtReducePer", PlayerDataType.CDBPlayerRefresh_FinalHurtReducePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_YinjiTime", PlayerDataType.CDBPlayerRefresh_YinjiTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_YinjiCount", PlayerDataType.CDBPlayerRefresh_YinjiCount);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(PlayerDataType), 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.PushPlayerDataType(L, (PlayerDataType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "AccountID"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.AccountID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerID"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PlayerID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerName"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PlayerName);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Sex"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Sex);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Hair"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Hair);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HairColor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.HairColor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Face"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Face);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Job"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Job);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TotalExp"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.TotalExp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Family"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Family);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Country"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Country);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamHornor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.TeamHornor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PKValue"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PKValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyHornor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FamilyHornor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyActiveValue"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FamilyActiveValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryHornor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CountryHornor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Mate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Gold"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Gold);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GoldPaper"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.GoldPaper);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Silver"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Silver);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SilverPaper"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SilverPaper);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FightPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HappyPoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.HappyPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MapID"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MapID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PosX"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PosX);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PosY"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PosY);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "State"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.State);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxHP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MaxHP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.HP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxMP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MaxMP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "XP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.XP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HPRestoreSetting"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.HPRestoreSetting);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MPRestoreSetting"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MPRestoreSetting);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExpRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FreePoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FreePoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FreeSkillPoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FreeSkillPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "STR"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.STR);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PNE"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PNE);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PHY"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PHY);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CON"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CON);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DEF"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DEF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MINATK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MINATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MAXATK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MAXATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MAtkMin"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MAtkMin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MAtkMax"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MAtkMax);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MDef"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MDef);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HIT"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.HIT);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "POISIONATK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.POISIONATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FIREATK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FIREATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "REALATK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.REALATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "THUNDERATK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.THUNDERATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WINDATK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.WINDATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "POISIONDEF"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.POISIONDEF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FIREDEF"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FIREDEF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "REALDEF"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.REALDEF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "THUNDERDEF"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.THUNDERDEF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WINDDEF"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.WINDDEF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Miss"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Miss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHit"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SuperHit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Buff"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Buff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Skill"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Skill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mark"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Mark);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SettingH"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SettingH);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SettingV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SettingV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPK"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FightPK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ActiveValue"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ActiveValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerType"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PlayerType);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NameColor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.NameColor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AtkInterval"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.AtkInterval);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Speed"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Speed);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHitRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SuperHitRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PickupDist"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PickupDist);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryLastWeekHornor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CountryLastWeekHornor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LastWeekOnlineTime"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LastWeekOnlineTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LastWeekFamilyActiveValue"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LastWeekFamilyActiveValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FBID"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FBID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyLV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FamilyLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealMapID"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.RealMapID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GMLevel"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.GMLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamID"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.TeamID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamLV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.TeamLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPower"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FightPower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornMapID"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.RebornMapID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornPosX"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.RebornPosX);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornPosY"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.RebornPosY);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Coin"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Coin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BillboardLV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BillboardLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Tick"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Tick);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CurrentPlayerType"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CurrentPlayerType);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FriendFavor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FriendFavor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BackpackLV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BackpackLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReincarnationLV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ReincarnationLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseSTR"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BaseSTR);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasePNE"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasePNE);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasePHY"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasePHY);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseCON"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BaseCON);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReceivedSalary"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ReceivedSalary);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WarehouseLV"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.WarehouseLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipShowSwitch"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.EquipShowSwitch);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckValue"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LuckValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr1"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr2"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr3"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr3);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr4"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr4);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr5"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr5);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Faction"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Faction);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "InfamyValue"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.InfamyValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmLevel"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.RealmLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IsFindByLabel"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.IsFindByLabel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IsCloseFriendLabel"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.IsCloseFriendLabel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ChangeCoinPointTotal"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ChangeCoinPointTotal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "VIPLv"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.VIPLv);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr6"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr6);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr7"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr7);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr8"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr8);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr9"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr9);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr10"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr10);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ModelMark"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ModelMark);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PrizeCoin"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PrizeCoin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr11"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr11);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr12"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr12);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr13"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr13);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr14"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExAttr14);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAtkRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SkillAtkRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHitRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LuckyHitRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHitVal"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LuckyHitVal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GreatHitRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.GreatHitRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GreatHitVal"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.GreatHitVal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillBackHP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.KillBackHP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillBackMP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.KillBackMP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DamageReduceRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DamageReduceRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DamageBackRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DamageBackRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GoldFoundRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.GoldFoundRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IgnoreDefRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.IgnoreDefRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx1"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BattleValEx1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx2"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BattleValEx2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx3"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BattleValEx3);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx4"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BattleValEx4);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx5"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BattleValEx5);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HPRestorePer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.HPRestorePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LVEx"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LVEx);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LV2"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LV2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpPoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ExpPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OperateInfo"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.OperateInfo);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHitReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SuperHitReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHitRateReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.LuckyHitRateReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAtkRateReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SkillAtkRateReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePVP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DamagePVP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SpeedValue"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.SpeedValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePVE"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DamagePVE);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetDamPer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PetDamPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IgnoreDefRateReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.IgnoreDefRateReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DamChanceDef"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DamChanceDef);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BleedDamage"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BleedDamage);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FaintRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FaintRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FaintDefRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FaintDefRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FinalHurt"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FinalHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FinalHurtReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FinalHurtReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePerPVP"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DamagePerPVP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePerPVPReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.DamagePerPVPReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ComboDamRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ComboDamRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ComboDamPer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.ComboDamPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxProDef"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MaxProDef);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyContribution"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FamilyContribution);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyStoreScore"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FamilyStoreScore);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneSplinters"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.RuneSplinters);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Rune"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.Rune);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmPoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.RealmPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MagicEssence"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.MagicEssence);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionLiven"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.UnionLiven);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FBHelpPoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FBHelpPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerPKState"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.PlayerPKState);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IsAttackBossState"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.IsAttackBossState);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsMinimum"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasicsMinimum);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsMaxAttack"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasicsMaxAttack);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsLife"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasicsLife);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsDefense"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasicsDefense);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsScoreAHit"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasicsScoreAHit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsDodge"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.BasicsDodge);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OnlyFinalHurt"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.OnlyFinalHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_ForbidenTalk"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_ForbidenTalk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FuncDef"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FuncDef);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_TreasureScore"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_TreasureScore);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Danjing"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Danjing);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_NPCHurtAddPer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_NPCHurtAddPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FunalHurtPer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.FunalHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_TalentPoint"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_TalentPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_1"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_2"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_3"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_3);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_4"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_4);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SoulDust"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SoulDust);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SoulSplinters"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SoulSplinters);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SoulCore"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SoulCore);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Honor"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Honor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_ZhuxianRate"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_ZhuxianRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Mater"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Mater);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Wood"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Wood);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Water"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Water);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Fire"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Fire);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Earth"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Earth);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_NormalHurt"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_NormalHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_NormalHurtPer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_NormalHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FabaoHurt"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FabaoHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FabaoHurtPer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FabaoHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SuperHitRateReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SuperHitRateReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_LuckyHitReduce"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_LuckyHitReduce);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FinalHurtReducePer"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FinalHurtReducePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_YinjiTime"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_YinjiTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_YinjiCount"))
			{
			translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_YinjiCount);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for PlayerDataType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for PlayerDataType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class PackTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(PackType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(PackType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(PackType), L, null, 14, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Deleted", PackType.Deleted);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip", PackType.Equip);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Item", PackType.Item);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Warehouse", PackType.Warehouse);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horse", PackType.Horse);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AnyWhere", PackType.AnyWhere);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InterimPack", PackType.InterimPack);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", PackType.Treasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetPack", PackType.PetPack);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzItem", PackType.DogzItem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzEquip", PackType.DogzEquip);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoul", PackType.GatherSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RunePack", PackType.RunePack);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(PackType), 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.PushPackType(L, (PackType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Deleted"))
			{
			translator.PushPackType(L, PackType.Deleted);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip"))
			{
			translator.PushPackType(L, PackType.Equip);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Item"))
			{
			translator.PushPackType(L, PackType.Item);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Warehouse"))
			{
			translator.PushPackType(L, PackType.Warehouse);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Horse"))
			{
			translator.PushPackType(L, PackType.Horse);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AnyWhere"))
			{
			translator.PushPackType(L, PackType.AnyWhere);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "InterimPack"))
			{
			translator.PushPackType(L, PackType.InterimPack);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
			{
			translator.PushPackType(L, PackType.Treasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetPack"))
			{
			translator.PushPackType(L, PackType.PetPack);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzItem"))
			{
			translator.PushPackType(L, PackType.DogzItem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzEquip"))
			{
			translator.PushPackType(L, PackType.DogzEquip);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoul"))
			{
			translator.PushPackType(L, PackType.GatherSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RunePack"))
			{
			translator.PushPackType(L, PackType.RunePack);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for PackType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for PackType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class ItemTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(ItemType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ItemType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(ItemType), L, null, 25, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Copper", ItemType.Copper);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Drugs", ItemType.Drugs);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Buff", ItemType.Buff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gemstone", ItemType.Gemstone);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeSuitStone", ItemType.ComposeSuitStone);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingsMat", ItemType.WingsMat);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DropCopper", ItemType.DropCopper);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipTools", ItemType.VipTools);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Box", ItemType.Box);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Weapon", ItemType.Equip_Weapon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Weapon2", ItemType.Equip_Weapon2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Hat", ItemType.Equip_Hat);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Clothes", ItemType.Equip_Clothes);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Belt", ItemType.Equip_Belt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Trousers", ItemType.Equip_Trousers);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Shoes", ItemType.Equip_Shoes);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Glove", ItemType.Equip_Glove);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Neck", ItemType.Equip_Neck);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_FairyCan1", ItemType.Equip_FairyCan1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_FairyCan2", ItemType.Equip_FairyCan2);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Jade", ItemType.Equip_Jade);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Wing", ItemType.Equip_Wing);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard_1", ItemType.Guard_1);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard_2", ItemType.Guard_2);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(ItemType), 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.PushItemType(L, (ItemType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Copper"))
			{
			translator.PushItemType(L, ItemType.Copper);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Drugs"))
			{
			translator.PushItemType(L, ItemType.Drugs);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Buff"))
			{
			translator.PushItemType(L, ItemType.Buff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Gemstone"))
			{
			translator.PushItemType(L, ItemType.Gemstone);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeSuitStone"))
			{
			translator.PushItemType(L, ItemType.ComposeSuitStone);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WingsMat"))
			{
			translator.PushItemType(L, ItemType.WingsMat);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DropCopper"))
			{
			translator.PushItemType(L, ItemType.DropCopper);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "VipTools"))
			{
			translator.PushItemType(L, ItemType.VipTools);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Box"))
			{
			translator.PushItemType(L, ItemType.Box);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Weapon"))
			{
			translator.PushItemType(L, ItemType.Equip_Weapon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Weapon2"))
			{
			translator.PushItemType(L, ItemType.Equip_Weapon2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Hat"))
			{
			translator.PushItemType(L, ItemType.Equip_Hat);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Clothes"))
			{
			translator.PushItemType(L, ItemType.Equip_Clothes);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Belt"))
			{
			translator.PushItemType(L, ItemType.Equip_Belt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Trousers"))
			{
			translator.PushItemType(L, ItemType.Equip_Trousers);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Shoes"))
			{
			translator.PushItemType(L, ItemType.Equip_Shoes);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Glove"))
			{
			translator.PushItemType(L, ItemType.Equip_Glove);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Neck"))
			{
			translator.PushItemType(L, ItemType.Equip_Neck);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_FairyCan1"))
			{
			translator.PushItemType(L, ItemType.Equip_FairyCan1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_FairyCan2"))
			{
			translator.PushItemType(L, ItemType.Equip_FairyCan2);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Jade"))
			{
			translator.PushItemType(L, ItemType.Equip_Jade);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Wing"))
			{
			translator.PushItemType(L, ItemType.Equip_Wing);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard_1"))
			{
			translator.PushItemType(L, ItemType.Guard_1);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard_2"))
			{
			translator.PushItemType(L, ItemType.Guard_2);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for ItemType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for ItemType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class MakeTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(MakeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(MakeType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(MakeType), L, null, 10, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneKeySell", MakeType.OneKeySell);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipStarUpgrade", MakeType.EquipStarUpgrade);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ItemCompound", MakeType.ItemCompound);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DrugRefine", MakeType.DrugRefine);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DrugRecycle", MakeType.DrugRecycle);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzEquipPlus", MakeType.DogzEquipPlus);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneCompound", MakeType.RuneCompound);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoulCompound", MakeType.GatherSoulCompound);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoulDecompose", MakeType.GatherSoulDecompose);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(MakeType), 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.PushMakeType(L, (MakeType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "OneKeySell"))
			{
			translator.PushMakeType(L, MakeType.OneKeySell);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipStarUpgrade"))
			{
			translator.PushMakeType(L, MakeType.EquipStarUpgrade);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ItemCompound"))
			{
			translator.PushMakeType(L, MakeType.ItemCompound);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DrugRefine"))
			{
			translator.PushMakeType(L, MakeType.DrugRefine);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DrugRecycle"))
			{
			translator.PushMakeType(L, MakeType.DrugRecycle);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzEquipPlus"))
			{
			translator.PushMakeType(L, MakeType.DogzEquipPlus);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneCompound"))
			{
			translator.PushMakeType(L, MakeType.RuneCompound);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoulCompound"))
			{
			translator.PushMakeType(L, MakeType.GatherSoulCompound);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoulDecompose"))
			{
			translator.PushMakeType(L, MakeType.GatherSoulDecompose);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for MakeType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for MakeType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class TitleTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(TitleType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TitleType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(TitleType), L, null, 6, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", TitleType.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Get", TitleType.Get);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Activity", TitleType.Activity);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vip", TitleType.Vip);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Achivement", TitleType.Achivement);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(TitleType), 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.PushTitleType(L, (TitleType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushTitleType(L, TitleType.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Get"))
			{
			translator.PushTitleType(L, TitleType.Get);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Activity"))
			{
			translator.PushTitleType(L, TitleType.Activity);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Vip"))
			{
			translator.PushTitleType(L, TitleType.Vip);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Achivement"))
			{
			translator.PushTitleType(L, TitleType.Achivement);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for TitleType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for TitleType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class FuncOpenEnumWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(FuncOpenEnum), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(FuncOpenEnum), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(FuncOpenEnum), L, null, 59, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Strength", FuncOpenEnum.Strength);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gem", FuncOpenEnum.Gem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", FuncOpenEnum.Wing);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", FuncOpenEnum.Pet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", FuncOpenEnum.Treasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mounts", FuncOpenEnum.Mounts);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rune", FuncOpenEnum.Rune);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", FuncOpenEnum.Realm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", FuncOpenEnum.Fairy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyTask", FuncOpenEnum.FairyTask);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GodWeapon", FuncOpenEnum.GodWeapon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SelfBoss", FuncOpenEnum.SelfBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Title", FuncOpenEnum.Title);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Talent", FuncOpenEnum.Talent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Suit", FuncOpenEnum.Suit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpPray", FuncOpenEnum.ExpPray);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CoinPray", FuncOpenEnum.CoinPray);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldLv", FuncOpenEnum.WorldLv);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rank", FuncOpenEnum.Rank);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Friend", FuncOpenEnum.Friend);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TouchSky", FuncOpenEnum.TouchSky);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Compose", FuncOpenEnum.Compose);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HuntTreasure", FuncOpenEnum.HuntTreasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Market", FuncOpenEnum.Market);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DayDaily", FuncOpenEnum.DayDaily);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Store", FuncOpenEnum.Store);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", FuncOpenEnum.RuneTower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SignIn", FuncOpenEnum.SignIn);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Potential", FuncOpenEnum.Potential);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IceCrystal", FuncOpenEnum.IceCrystal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyFest", FuncOpenEnum.FairyFest);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin", FuncOpenEnum.Kylin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLand", FuncOpenEnum.FairyLand);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlastFurnace", FuncOpenEnum.BlastFurnace);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Munekado", FuncOpenEnum.Munekado);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GuardSky", FuncOpenEnum.GuardSky);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingRefine", FuncOpenEnum.WingRefine);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipRefine", FuncOpenEnum.EquipRefine);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGods", FuncOpenEnum.ElderGods);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose", FuncOpenEnum.EquipCompose);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard", FuncOpenEnum.Guard);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillTreasure", FuncOpenEnum.SkillTreasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingCompose", FuncOpenEnum.WingCompose);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", FuncOpenEnum.Demon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HappyFindTreasure", FuncOpenEnum.HappyFindTreasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPromote", FuncOpenEnum.FightPromote);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGround", FuncOpenEnum.AncientBattleGround);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Chat", FuncOpenEnum.Chat);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLeague", FuncOpenEnum.FairyLeague);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Recharge", FuncOpenEnum.Recharge);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRedEnvelope", FuncOpenEnum.OpenServerRedEnvelope);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipDecompose", FuncOpenEnum.EquipDecompose);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHost", FuncOpenEnum.TreasureFindHost);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dogz", FuncOpenEnum.Dogz);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReikiRoot", FuncOpenEnum.ReikiRoot);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServer", FuncOpenEnum.CrossServer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerBoss", FuncOpenEnum.CrossServerBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HazyRegion", FuncOpenEnum.HazyRegion);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(FuncOpenEnum), 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.PushFuncOpenEnum(L, (FuncOpenEnum)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Strength"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Strength);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Gem"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Gem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Wing);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Pet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Treasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mounts"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Mounts);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Rune"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Rune);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Realm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Fairy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyTask"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyTask);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GodWeapon"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.GodWeapon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SelfBoss"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.SelfBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Title"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Title);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Talent"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Talent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Suit"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Suit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpPray"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.ExpPray);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CoinPray"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.CoinPray);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldLv"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.WorldLv);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Rank"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Rank);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Friend"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Friend);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TouchSky"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.TouchSky);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Compose"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Compose);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HuntTreasure"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.HuntTreasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Market"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Market);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DayDaily"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.DayDaily);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Store"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Store);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.RuneTower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SignIn"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.SignIn);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Potential"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Potential);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IceCrystal"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.IceCrystal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyFest"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyFest);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Kylin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLand"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyLand);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BlastFurnace"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.BlastFurnace);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Munekado"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Munekado);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GuardSky"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.GuardSky);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WingRefine"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.WingRefine);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipRefine"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.EquipRefine);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGods"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.ElderGods);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.EquipCompose);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Guard);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillTreasure"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.SkillTreasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WingCompose"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.WingCompose);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Demon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HappyFindTreasure"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.HappyFindTreasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPromote"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.FightPromote);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGround"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.AncientBattleGround);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Chat"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Chat);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLeague"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyLeague);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Recharge"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Recharge);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRedEnvelope"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.OpenServerRedEnvelope);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipDecompose"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.EquipDecompose);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHost"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.TreasureFindHost);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Dogz"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.Dogz);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReikiRoot"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.ReikiRoot);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServer"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.CrossServer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerBoss"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.CrossServerBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HazyRegion"))
			{
			translator.PushFuncOpenEnum(L, FuncOpenEnum.HazyRegion);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for FuncOpenEnum!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for FuncOpenEnum! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class PropertyTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(PropertyType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(PropertyType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(PropertyType), L, null, 126, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LV", PropertyType.LV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "POWER", PropertyType.POWER);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AGILITY", PropertyType.AGILITY);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PHYSIQUE", PropertyType.PHYSIQUE);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MENTALITY", PropertyType.MENTALITY);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HP", PropertyType.HP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ATK", PropertyType.ATK);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEF", PropertyType.DEF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HIT", PropertyType.HIT);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MISS", PropertyType.MISS);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ATKSPEED", PropertyType.ATKSPEED);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritChance", PropertyType.CritChance);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritHurt", PropertyType.CritHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritResis", PropertyType.CritResis);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeartHit", PropertyType.HeartHit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeartHurt", PropertyType.HeartHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeartResis", PropertyType.HeartResis);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillHurt", PropertyType.SkillHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPAddHurt", PropertyType.PVPAddHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPReduceHurt", PropertyType.PVPReduceHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LifeReply", PropertyType.LifeReply);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HurtReflect", PropertyType.HurtReflect);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MoveSpeed", PropertyType.MoveSpeed);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetHurt", PropertyType.PetHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetAddHurt", PropertyType.PetAddHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealHurt", PropertyType.RealHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealResis", PropertyType.RealResis);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefyDef", PropertyType.DefyDef);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefyDefResis", PropertyType.DefyDefResis);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefChance", PropertyType.DefChance);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BloodHurt", PropertyType.BloodHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AktReplyBlood", PropertyType.AktReplyBlood);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stun", PropertyType.Stun);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CtrlResis", PropertyType.CtrlResis);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddFinalHurt", PropertyType.AddFinalHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceFinalHurt", PropertyType.ReduceFinalHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPAddHurtPer", PropertyType.PVPAddHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPReduceHurtPer", PropertyType.PVPReduceHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DleHitChance", PropertyType.DleHitChance);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DleHurt", PropertyType.DleHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicAtkPercent", PropertyType.BasicAtkPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicHpPercent", PropertyType.BasicHpPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicDefPercent", PropertyType.BasicDefPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HitPercent", PropertyType.HitPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DodgePercent", PropertyType.DodgePercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonsExpPercent", PropertyType.KillMonsExpPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HorcruxBasicAttrPercent", PropertyType.HorcruxBasicAttrPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceSkillHurtPercent", PropertyType.ReduceSkillHurtPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HpPercent", PropertyType.HpPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AtkPercent", PropertyType.AtkPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EveryLvAddAtk", PropertyType.EveryLvAddAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EveryLvAddHp", PropertyType.EveryLvAddHp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddEquipDropPrecent", PropertyType.AddEquipDropPrecent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddCoinsPrecent", PropertyType.AddCoinsPrecent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddRealHurtPer", PropertyType.AddRealHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceRealHurtPer", PropertyType.ReduceRealHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ArmorMaxHPPer", PropertyType.ArmorMaxHPPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WeaponAtkPer", PropertyType.WeaponAtkPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ArmorDefPer", PropertyType.ArmorDefPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MinAtk", PropertyType.MinAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxAtk", PropertyType.MaxAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefencePercent", PropertyType.DefencePercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritHurtPercent", PropertyType.CritHurtPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MoveSpeedPercent", PropertyType.MoveSpeedPercent);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxProDef", PropertyType.MaxProDef);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ProDefHPPer", PropertyType.ProDefHPPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ProDefAbsorb", PropertyType.ProDefAbsorb);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseHitPer", PropertyType.BaseHitPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseMissPer", PropertyType.BaseMissPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetMinAtk", PropertyType.PetMinAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetMaxAtk", PropertyType.PetMaxAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnlyFinalHurt", PropertyType.OnlyFinalHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPAtkBackHP", PropertyType.PVPAtkBackHP);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ChanceExpRate", PropertyType.ChanceExpRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HorseAtkPer", PropertyType.HorseAtkPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoneBasePer", PropertyType.StoneBasePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmBasePer", PropertyType.RealmBasePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetSkillAtkRate", PropertyType.PetSkillAtkRate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingHPPer", PropertyType.WingHPPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuiteBasePer", PropertyType.SuiteBasePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlusBaseAtkPer", PropertyType.PlusBaseAtkPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcHurtAddPer", PropertyType.NpcHurtAddPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobAHurtAddPer", PropertyType.JobAHurtAddPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobBHurtAddPer", PropertyType.JobBHurtAddPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobCHurtAddPer", PropertyType.JobCHurtAddPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobAAtkReducePer", PropertyType.JobAAtkReducePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobBAtkReducePer", PropertyType.JobBAtkReducePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobCAtkReducePer", PropertyType.JobCAtkReducePer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXCloakAttrPer", PropertyType.ZXCloakAttrPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXMaskAttrPer", PropertyType.ZXMaskAttrPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXGloveAttrPer", PropertyType.ZXGloveAttrPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXRuyiAttrPer", PropertyType.ZXRuyiAttrPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXPendantAttrPer", PropertyType.ZXPendantAttrPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXRingAttrPer", PropertyType.ZXRingAttrPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerA", PropertyType.SkillAddPerA);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerB", PropertyType.SkillAddPerB);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerC", PropertyType.SkillAddPerC);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerD", PropertyType.SkillAddPerD);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerE", PropertyType.SkillAddPerE);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerF", PropertyType.SkillAddPerF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerG", PropertyType.SkillAddPerG);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerA", PropertyType.SkillReducePerA);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerB", PropertyType.SkillReducePerB);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerC", PropertyType.SkillReducePerC);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerD", PropertyType.SkillReducePerD);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerE", PropertyType.SkillReducePerE);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerF", PropertyType.SkillReducePerF);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerG", PropertyType.SkillReducePerG);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Luck", PropertyType.Luck);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckPer", PropertyType.LuckPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddNormalHurt", PropertyType.AddNormalHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddNormalHurtPer", PropertyType.AddNormalHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddSkillHurt", PropertyType.AddSkillHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddSkillHurtPer", PropertyType.AddSkillHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceCrit", PropertyType.ReduceCrit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddHeartHurtPer", PropertyType.AddHeartHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceHeartHurtPer", PropertyType.ReduceHeartHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddPVEHurt", PropertyType.AddPVEHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddFinalHurtPer", PropertyType.AddFinalHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceFinalHurtPer", PropertyType.ReduceFinalHurtPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mater", PropertyType.Mater);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wood", PropertyType.Wood);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Water", PropertyType.Water);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fire", PropertyType.Fire);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Earth", PropertyType.Earth);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(PropertyType), 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.PushPropertyType(L, (PropertyType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "LV"))
			{
			translator.PushPropertyType(L, PropertyType.LV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "POWER"))
			{
			translator.PushPropertyType(L, PropertyType.POWER);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AGILITY"))
			{
			translator.PushPropertyType(L, PropertyType.AGILITY);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PHYSIQUE"))
			{
			translator.PushPropertyType(L, PropertyType.PHYSIQUE);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MENTALITY"))
			{
			translator.PushPropertyType(L, PropertyType.MENTALITY);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HP"))
			{
			translator.PushPropertyType(L, PropertyType.HP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ATK"))
			{
			translator.PushPropertyType(L, PropertyType.ATK);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DEF"))
			{
			translator.PushPropertyType(L, PropertyType.DEF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HIT"))
			{
			translator.PushPropertyType(L, PropertyType.HIT);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MISS"))
			{
			translator.PushPropertyType(L, PropertyType.MISS);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ATKSPEED"))
			{
			translator.PushPropertyType(L, PropertyType.ATKSPEED);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CritChance"))
			{
			translator.PushPropertyType(L, PropertyType.CritChance);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CritHurt"))
			{
			translator.PushPropertyType(L, PropertyType.CritHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CritResis"))
			{
			translator.PushPropertyType(L, PropertyType.CritResis);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HeartHit"))
			{
			translator.PushPropertyType(L, PropertyType.HeartHit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HeartHurt"))
			{
			translator.PushPropertyType(L, PropertyType.HeartHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HeartResis"))
			{
			translator.PushPropertyType(L, PropertyType.HeartResis);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillHurt"))
			{
			translator.PushPropertyType(L, PropertyType.SkillHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPAddHurt"))
			{
			translator.PushPropertyType(L, PropertyType.PVPAddHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPReduceHurt"))
			{
			translator.PushPropertyType(L, PropertyType.PVPReduceHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LifeReply"))
			{
			translator.PushPropertyType(L, PropertyType.LifeReply);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HurtReflect"))
			{
			translator.PushPropertyType(L, PropertyType.HurtReflect);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MoveSpeed"))
			{
			translator.PushPropertyType(L, PropertyType.MoveSpeed);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetHurt"))
			{
			translator.PushPropertyType(L, PropertyType.PetHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetAddHurt"))
			{
			translator.PushPropertyType(L, PropertyType.PetAddHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealHurt"))
			{
			translator.PushPropertyType(L, PropertyType.RealHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealResis"))
			{
			translator.PushPropertyType(L, PropertyType.RealResis);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DefyDef"))
			{
			translator.PushPropertyType(L, PropertyType.DefyDef);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DefyDefResis"))
			{
			translator.PushPropertyType(L, PropertyType.DefyDefResis);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DefChance"))
			{
			translator.PushPropertyType(L, PropertyType.DefChance);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BloodHurt"))
			{
			translator.PushPropertyType(L, PropertyType.BloodHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AktReplyBlood"))
			{
			translator.PushPropertyType(L, PropertyType.AktReplyBlood);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Stun"))
			{
			translator.PushPropertyType(L, PropertyType.Stun);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CtrlResis"))
			{
			translator.PushPropertyType(L, PropertyType.CtrlResis);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddFinalHurt"))
			{
			translator.PushPropertyType(L, PropertyType.AddFinalHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceFinalHurt"))
			{
			translator.PushPropertyType(L, PropertyType.ReduceFinalHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPAddHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.PVPAddHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPReduceHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.PVPReduceHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DleHitChance"))
			{
			translator.PushPropertyType(L, PropertyType.DleHitChance);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DleHurt"))
			{
			translator.PushPropertyType(L, PropertyType.DleHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicAtkPercent"))
			{
			translator.PushPropertyType(L, PropertyType.BasicAtkPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicHpPercent"))
			{
			translator.PushPropertyType(L, PropertyType.BasicHpPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicDefPercent"))
			{
			translator.PushPropertyType(L, PropertyType.BasicDefPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HitPercent"))
			{
			translator.PushPropertyType(L, PropertyType.HitPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DodgePercent"))
			{
			translator.PushPropertyType(L, PropertyType.DodgePercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonsExpPercent"))
			{
			translator.PushPropertyType(L, PropertyType.KillMonsExpPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HorcruxBasicAttrPercent"))
			{
			translator.PushPropertyType(L, PropertyType.HorcruxBasicAttrPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceSkillHurtPercent"))
			{
			translator.PushPropertyType(L, PropertyType.ReduceSkillHurtPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HpPercent"))
			{
			translator.PushPropertyType(L, PropertyType.HpPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AtkPercent"))
			{
			translator.PushPropertyType(L, PropertyType.AtkPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EveryLvAddAtk"))
			{
			translator.PushPropertyType(L, PropertyType.EveryLvAddAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EveryLvAddHp"))
			{
			translator.PushPropertyType(L, PropertyType.EveryLvAddHp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddEquipDropPrecent"))
			{
			translator.PushPropertyType(L, PropertyType.AddEquipDropPrecent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddCoinsPrecent"))
			{
			translator.PushPropertyType(L, PropertyType.AddCoinsPrecent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddRealHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.AddRealHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceRealHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.ReduceRealHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ArmorMaxHPPer"))
			{
			translator.PushPropertyType(L, PropertyType.ArmorMaxHPPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WeaponAtkPer"))
			{
			translator.PushPropertyType(L, PropertyType.WeaponAtkPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ArmorDefPer"))
			{
			translator.PushPropertyType(L, PropertyType.ArmorDefPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MinAtk"))
			{
			translator.PushPropertyType(L, PropertyType.MinAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxAtk"))
			{
			translator.PushPropertyType(L, PropertyType.MaxAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DefencePercent"))
			{
			translator.PushPropertyType(L, PropertyType.DefencePercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CritHurtPercent"))
			{
			translator.PushPropertyType(L, PropertyType.CritHurtPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MoveSpeedPercent"))
			{
			translator.PushPropertyType(L, PropertyType.MoveSpeedPercent);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxProDef"))
			{
			translator.PushPropertyType(L, PropertyType.MaxProDef);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ProDefHPPer"))
			{
			translator.PushPropertyType(L, PropertyType.ProDefHPPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ProDefAbsorb"))
			{
			translator.PushPropertyType(L, PropertyType.ProDefAbsorb);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseHitPer"))
			{
			translator.PushPropertyType(L, PropertyType.BaseHitPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseMissPer"))
			{
			translator.PushPropertyType(L, PropertyType.BaseMissPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetMinAtk"))
			{
			translator.PushPropertyType(L, PropertyType.PetMinAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetMaxAtk"))
			{
			translator.PushPropertyType(L, PropertyType.PetMaxAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OnlyFinalHurt"))
			{
			translator.PushPropertyType(L, PropertyType.OnlyFinalHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPAtkBackHP"))
			{
			translator.PushPropertyType(L, PropertyType.PVPAtkBackHP);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ChanceExpRate"))
			{
			translator.PushPropertyType(L, PropertyType.ChanceExpRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HorseAtkPer"))
			{
			translator.PushPropertyType(L, PropertyType.HorseAtkPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "StoneBasePer"))
			{
			translator.PushPropertyType(L, PropertyType.StoneBasePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmBasePer"))
			{
			translator.PushPropertyType(L, PropertyType.RealmBasePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetSkillAtkRate"))
			{
			translator.PushPropertyType(L, PropertyType.PetSkillAtkRate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WingHPPer"))
			{
			translator.PushPropertyType(L, PropertyType.WingHPPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SuiteBasePer"))
			{
			translator.PushPropertyType(L, PropertyType.SuiteBasePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PlusBaseAtkPer"))
			{
			translator.PushPropertyType(L, PropertyType.PlusBaseAtkPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcHurtAddPer"))
			{
			translator.PushPropertyType(L, PropertyType.NpcHurtAddPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JobAHurtAddPer"))
			{
			translator.PushPropertyType(L, PropertyType.JobAHurtAddPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JobBHurtAddPer"))
			{
			translator.PushPropertyType(L, PropertyType.JobBHurtAddPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JobCHurtAddPer"))
			{
			translator.PushPropertyType(L, PropertyType.JobCHurtAddPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JobAAtkReducePer"))
			{
			translator.PushPropertyType(L, PropertyType.JobAAtkReducePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JobBAtkReducePer"))
			{
			translator.PushPropertyType(L, PropertyType.JobBAtkReducePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JobCAtkReducePer"))
			{
			translator.PushPropertyType(L, PropertyType.JobCAtkReducePer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXCloakAttrPer"))
			{
			translator.PushPropertyType(L, PropertyType.ZXCloakAttrPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXMaskAttrPer"))
			{
			translator.PushPropertyType(L, PropertyType.ZXMaskAttrPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXGloveAttrPer"))
			{
			translator.PushPropertyType(L, PropertyType.ZXGloveAttrPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXRuyiAttrPer"))
			{
			translator.PushPropertyType(L, PropertyType.ZXRuyiAttrPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXPendantAttrPer"))
			{
			translator.PushPropertyType(L, PropertyType.ZXPendantAttrPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXRingAttrPer"))
			{
			translator.PushPropertyType(L, PropertyType.ZXRingAttrPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerA"))
			{
			translator.PushPropertyType(L, PropertyType.SkillAddPerA);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerB"))
			{
			translator.PushPropertyType(L, PropertyType.SkillAddPerB);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerC"))
			{
			translator.PushPropertyType(L, PropertyType.SkillAddPerC);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerD"))
			{
			translator.PushPropertyType(L, PropertyType.SkillAddPerD);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerE"))
			{
			translator.PushPropertyType(L, PropertyType.SkillAddPerE);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerF"))
			{
			translator.PushPropertyType(L, PropertyType.SkillAddPerF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerG"))
			{
			translator.PushPropertyType(L, PropertyType.SkillAddPerG);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerA"))
			{
			translator.PushPropertyType(L, PropertyType.SkillReducePerA);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerB"))
			{
			translator.PushPropertyType(L, PropertyType.SkillReducePerB);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerC"))
			{
			translator.PushPropertyType(L, PropertyType.SkillReducePerC);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerD"))
			{
			translator.PushPropertyType(L, PropertyType.SkillReducePerD);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerE"))
			{
			translator.PushPropertyType(L, PropertyType.SkillReducePerE);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerF"))
			{
			translator.PushPropertyType(L, PropertyType.SkillReducePerF);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerG"))
			{
			translator.PushPropertyType(L, PropertyType.SkillReducePerG);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Luck"))
			{
			translator.PushPropertyType(L, PropertyType.Luck);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckPer"))
			{
			translator.PushPropertyType(L, PropertyType.LuckPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddNormalHurt"))
			{
			translator.PushPropertyType(L, PropertyType.AddNormalHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddNormalHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.AddNormalHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddSkillHurt"))
			{
			translator.PushPropertyType(L, PropertyType.AddSkillHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddSkillHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.AddSkillHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceCrit"))
			{
			translator.PushPropertyType(L, PropertyType.ReduceCrit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddHeartHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.AddHeartHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceHeartHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.ReduceHeartHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddPVEHurt"))
			{
			translator.PushPropertyType(L, PropertyType.AddPVEHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AddFinalHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.AddFinalHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceFinalHurtPer"))
			{
			translator.PushPropertyType(L, PropertyType.ReduceFinalHurtPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mater"))
			{
			translator.PushPropertyType(L, PropertyType.Mater);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wood"))
			{
			translator.PushPropertyType(L, PropertyType.Wood);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Water"))
			{
			translator.PushPropertyType(L, PropertyType.Water);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fire"))
			{
			translator.PushPropertyType(L, PropertyType.Fire);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Earth"))
			{
			translator.PushPropertyType(L, PropertyType.Earth);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for PropertyType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for PropertyType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class TextColTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(TextColType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TextColType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(TextColType), L, null, 16, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", TextColType.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "White", TextColType.White);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blue", TextColType.Blue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Purple", TextColType.Purple);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Orange", TextColType.Orange);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Red", TextColType.Red);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pink", TextColType.Pink);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NavyBrown", TextColType.NavyBrown);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Green", TextColType.Green);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Black", TextColType.Black);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DarkGreen", TextColType.DarkGreen);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NavyYellow", TextColType.NavyYellow);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightGreen", TextColType.LightGreen);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightYellow", TextColType.LightYellow);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gray", TextColType.Gray);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(TextColType), 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.PushTextColType(L, (TextColType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushTextColType(L, TextColType.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "White"))
			{
			translator.PushTextColType(L, TextColType.White);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Blue"))
			{
			translator.PushTextColType(L, TextColType.Blue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Purple"))
			{
			translator.PushTextColType(L, TextColType.Purple);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Orange"))
			{
			translator.PushTextColType(L, TextColType.Orange);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Red"))
			{
			translator.PushTextColType(L, TextColType.Red);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pink"))
			{
			translator.PushTextColType(L, TextColType.Pink);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NavyBrown"))
			{
			translator.PushTextColType(L, TextColType.NavyBrown);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Green"))
			{
			translator.PushTextColType(L, TextColType.Green);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Black"))
			{
			translator.PushTextColType(L, TextColType.Black);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DarkGreen"))
			{
			translator.PushTextColType(L, TextColType.DarkGreen);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NavyYellow"))
			{
			translator.PushTextColType(L, TextColType.NavyYellow);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LightGreen"))
			{
			translator.PushTextColType(L, TextColType.LightGreen);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LightYellow"))
			{
			translator.PushTextColType(L, TextColType.LightYellow);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Gray"))
			{
			translator.PushTextColType(L, TextColType.Gray);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for TextColType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for TextColType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_ModelResTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_ModelResType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_ModelResType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_ModelResType), L, null, 8, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Weapon", E_ModelResType.Weapon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", E_ModelResType.Wing);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horse", E_ModelResType.Horse);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Suit", E_ModelResType.Suit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", E_ModelResType.Pet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Secondary", E_ModelResType.Secondary);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hand", E_ModelResType.Hand);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_ModelResType), 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.PushE_ModelResType(L, (E_ModelResType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Weapon"))
			{
			translator.PushE_ModelResType(L, E_ModelResType.Weapon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
			{
			translator.PushE_ModelResType(L, E_ModelResType.Wing);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Horse"))
			{
			translator.PushE_ModelResType(L, E_ModelResType.Horse);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Suit"))
			{
			translator.PushE_ModelResType(L, E_ModelResType.Suit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
			{
			translator.PushE_ModelResType(L, E_ModelResType.Pet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Secondary"))
			{
			translator.PushE_ModelResType(L, E_ModelResType.Secondary);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Hand"))
			{
			translator.PushE_ModelResType(L, E_ModelResType.Hand);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_ModelResType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_ModelResType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class TreasureCategoryWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(TreasureCategory), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TreasureCategory), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(TreasureCategory), L, null, 6, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Human", TreasureCategory.Human);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", TreasureCategory.Demon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", TreasureCategory.Fairy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "King", TreasureCategory.King);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Zerg", TreasureCategory.Zerg);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(TreasureCategory), 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.PushTreasureCategory(L, (TreasureCategory)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Human"))
			{
			translator.PushTreasureCategory(L, TreasureCategory.Human);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
			{
			translator.PushTreasureCategory(L, TreasureCategory.Demon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
			{
			translator.PushTreasureCategory(L, TreasureCategory.Fairy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "King"))
			{
			translator.PushTreasureCategory(L, TreasureCategory.King);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Zerg"))
			{
			translator.PushTreasureCategory(L, TreasureCategory.Zerg);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for TreasureCategory!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for TreasureCategory! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class TreasureStateWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(TreasureState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TreasureState), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(TreasureState), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collected", TreasureState.Collected);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collecting", TreasureState.Collecting);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Locked", TreasureState.Locked);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(TreasureState), 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.PushTreasureState(L, (TreasureState)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Collected"))
			{
			translator.PushTreasureState(L, TreasureState.Collected);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Collecting"))
			{
			translator.PushTreasureState(L, TreasureState.Collecting);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Locked"))
			{
			translator.PushTreasureState(L, TreasureState.Locked);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for TreasureState!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for TreasureState! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class FunctionUnlockTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(FunctionUnlockType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(FunctionUnlockType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(FunctionUnlockType), L, null, 7, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", FunctionUnlockType.Treasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", FunctionUnlockType.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureSkill", FunctionUnlockType.TreasureSkill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skill", FunctionUnlockType.Skill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFunc", FunctionUnlockType.TreasureFunc);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureChapter", FunctionUnlockType.TreasureChapter);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(FunctionUnlockType), 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.PushFunctionUnlockType(L, (FunctionUnlockType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
			{
			translator.PushFunctionUnlockType(L, FunctionUnlockType.Treasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushFunctionUnlockType(L, FunctionUnlockType.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureSkill"))
			{
			translator.PushFunctionUnlockType(L, FunctionUnlockType.TreasureSkill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Skill"))
			{
			translator.PushFunctionUnlockType(L, FunctionUnlockType.Skill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFunc"))
			{
			translator.PushFunctionUnlockType(L, FunctionUnlockType.TreasureFunc);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureChapter"))
			{
			translator.PushFunctionUnlockType(L, FunctionUnlockType.TreasureChapter);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for FunctionUnlockType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for FunctionUnlockType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class RedPointStateWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(RedPointState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(RedPointState), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(RedPointState), L, null, 6, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", RedPointState.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Simple", RedPointState.Simple);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Quantity", RedPointState.Quantity);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full", RedPointState.Full);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetReward", RedPointState.GetReward);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(RedPointState), 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.PushRedPointState(L, (RedPointState)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushRedPointState(L, RedPointState.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Simple"))
			{
			translator.PushRedPointState(L, RedPointState.Simple);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Quantity"))
			{
			translator.PushRedPointState(L, RedPointState.Quantity);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Full"))
			{
			translator.PushRedPointState(L, RedPointState.Full);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GetReward"))
			{
			translator.PushRedPointState(L, RedPointState.GetReward);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for RedPointState!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for RedPointState! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class TeamInviteTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(TeamInviteType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TeamInviteType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(TeamInviteType), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Friend", TeamInviteType.Friend);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", TeamInviteType.Fairy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NearBy", TeamInviteType.NearBy);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(TeamInviteType), 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.PushTeamInviteType(L, (TeamInviteType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Friend"))
			{
			translator.PushTeamInviteType(L, TeamInviteType.Friend);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
			{
			translator.PushTeamInviteType(L, TeamInviteType.Fairy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NearBy"))
			{
			translator.PushTeamInviteType(L, TeamInviteType.NearBy);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for TeamInviteType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for TeamInviteType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class TeammatePrepareStateWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(TeammatePrepareState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TeammatePrepareState), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(TeammatePrepareState), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnPrepared", TeammatePrepareState.UnPrepared);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Prepared", TeammatePrepareState.Prepared);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rejected", TeammatePrepareState.Rejected);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(TeammatePrepareState), 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.PushTeammatePrepareState(L, (TeammatePrepareState)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "UnPrepared"))
			{
			translator.PushTeammatePrepareState(L, TeammatePrepareState.UnPrepared);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Prepared"))
			{
			translator.PushTeammatePrepareState(L, TeammatePrepareState.Prepared);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Rejected"))
			{
			translator.PushTeammatePrepareState(L, TeammatePrepareState.Rejected);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for TeammatePrepareState!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for TeammatePrepareState! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class VipPrivilegeTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(VipPrivilegeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(VipPrivilegeType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(VipPrivilegeType), L, null, 33, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureAtk", VipPrivilegeType.TreasureAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GemHole", VipPrivilegeType.GemHole);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipBuff", VipPrivilegeType.VipBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TradeTax", VipPrivilegeType.TradeTax);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrivateClerk", VipPrivilegeType.PrivateClerk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreeTransfer", VipPrivilegeType.FreeTransfer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoFairyMisstion", VipPrivilegeType.AutoFairyMisstion);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gather", VipPrivilegeType.Gather);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Undead", VipPrivilegeType.Undead);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonsterExpUp", VipPrivilegeType.KillMonsterExpUp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Minion", VipPrivilegeType.Minion);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonsterSp", VipPrivilegeType.KillMonsterSp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoldWish", VipPrivilegeType.GoldWish);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpWish", VipPrivilegeType.ExpWish);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SelfBoss", VipPrivilegeType.SelfBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BossHome", VipPrivilegeType.BossHome);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetDungeon", VipPrivilegeType.PetDungeon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaptizeDungeon", VipPrivilegeType.BaptizeDungeon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForbiddenArea", VipPrivilegeType.ForbiddenArea);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fane", VipPrivilegeType.Fane);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Chasm", VipPrivilegeType.Chasm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DarkDorr", VipPrivilegeType.DarkDorr);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyDaimondGift", VipPrivilegeType.FairyDaimondGift);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarketPutawayPwd", VipPrivilegeType.MarketPutawayPwd);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJar", VipPrivilegeType.DemonJar);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJarDouble", VipPrivilegeType.DemonJarDouble);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BindJadeWheel", VipPrivilegeType.BindJadeWheel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrayForDrug", VipPrivilegeType.PrayForDrug);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJarAuto", VipPrivilegeType.DemonJarAuto);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AssistXianYuanCoinsAdd", VipPrivilegeType.AssistXianYuanCoinsAdd);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AssistXianYuanCoinsRatioAdd", VipPrivilegeType.AssistXianYuanCoinsRatioAdd);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyBoss", VipPrivilegeType.JadeDynastyBoss);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(VipPrivilegeType), 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.PushVipPrivilegeType(L, (VipPrivilegeType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureAtk"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.TreasureAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GemHole"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.GemHole);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "VipBuff"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.VipBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TradeTax"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.TradeTax);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PrivateClerk"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.PrivateClerk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FreeTransfer"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.FreeTransfer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoFairyMisstion"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.AutoFairyMisstion);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Gather"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.Gather);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Undead"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.Undead);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonsterExpUp"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.KillMonsterExpUp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Minion"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.Minion);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonsterSp"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.KillMonsterSp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GoldWish"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.GoldWish);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpWish"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.ExpWish);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SelfBoss"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.SelfBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BossHome"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.BossHome);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetDungeon"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.PetDungeon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BaptizeDungeon"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.BaptizeDungeon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ForbiddenArea"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.ForbiddenArea);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fane"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.Fane);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Chasm"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.Chasm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DarkDorr"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.DarkDorr);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyDaimondGift"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.FairyDaimondGift);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MarketPutawayPwd"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.MarketPutawayPwd);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJar"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.DemonJar);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJarDouble"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.DemonJarDouble);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BindJadeWheel"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.BindJadeWheel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PrayForDrug"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.PrayForDrug);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJarAuto"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.DemonJarAuto);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AssistXianYuanCoinsAdd"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.AssistXianYuanCoinsAdd);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AssistXianYuanCoinsRatioAdd"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.AssistXianYuanCoinsRatioAdd);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyBoss"))
			{
			translator.PushVipPrivilegeType(L, VipPrivilegeType.JadeDynastyBoss);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for VipPrivilegeType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for VipPrivilegeType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_AttackModeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_AttackMode), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_AttackMode), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_AttackMode), L, null, 9, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Peace", E_AttackMode.Peace);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", E_AttackMode.All);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Country", E_AttackMode.Country);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Group", E_AttackMode.Group);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Team", E_AttackMode.Team);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Family", E_AttackMode.Family);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoodEval", E_AttackMode.GoodEval);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Contest", E_AttackMode.Contest);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_AttackMode), 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.PushE_AttackMode(L, (E_AttackMode)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Peace"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.Peace);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.All);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Country"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.Country);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Group"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.Group);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Team"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.Team);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Family"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.Family);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GoodEval"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.GoodEval);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Contest"))
			{
			translator.PushE_AttackMode(L, E_AttackMode.Contest);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_AttackMode!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_AttackMode! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_ItemColorWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_ItemColor), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_ItemColor), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_ItemColor), L, null, 7, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "White", E_ItemColor.White);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blue", E_ItemColor.Blue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Purple", E_ItemColor.Purple);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Orange", E_ItemColor.Orange);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Red", E_ItemColor.Red);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pink", E_ItemColor.Pink);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_ItemColor), 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.PushE_ItemColor(L, (E_ItemColor)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "White"))
			{
			translator.PushE_ItemColor(L, E_ItemColor.White);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Blue"))
			{
			translator.PushE_ItemColor(L, E_ItemColor.Blue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Purple"))
			{
			translator.PushE_ItemColor(L, E_ItemColor.Purple);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Orange"))
			{
			translator.PushE_ItemColor(L, E_ItemColor.Orange);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Red"))
			{
			translator.PushE_ItemColor(L, E_ItemColor.Red);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pink"))
			{
			translator.PushE_ItemColor(L, E_ItemColor.Pink);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_ItemColor!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_ItemColor! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class FindPreciousTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(FindPreciousType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(FindPreciousType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(FindPreciousType), L, null, 10, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldBoss", FindPreciousType.WorldBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BossHome", FindPreciousType.BossHome);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalBoss", FindPreciousType.PersonalBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodArea", FindPreciousType.ElderGodArea);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJar", FindPreciousType.DemonJar);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzDungeon", FindPreciousType.DogzDungeon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerBoss", FindPreciousType.CrossServerBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyBoss", FindPreciousType.JadeDynastyBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", FindPreciousType.None);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(FindPreciousType), 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.PushFindPreciousType(L, (FindPreciousType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "WorldBoss"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.WorldBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BossHome"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.BossHome);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalBoss"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.PersonalBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodArea"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.ElderGodArea);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJar"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.DemonJar);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzDungeon"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.DogzDungeon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerBoss"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.CrossServerBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyBoss"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.JadeDynastyBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushFindPreciousType(L, FindPreciousType.None);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for FindPreciousType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for FindPreciousType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class GotServerRewardTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(GotServerRewardType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(GotServerRewardType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(GotServerRewardType), L, null, 26, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_Activity", GotServerRewardType.Def_RewardType_Activity);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FamilyActivity", GotServerRewardType.Def_RewardType_FamilyActivity);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_ChampionFamilyDailyReward", GotServerRewardType.Def_RewardType_ChampionFamilyDailyReward);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_XMZZWinCnt", GotServerRewardType.Def_RewardType_XMZZWinCnt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FairyDayAward", GotServerRewardType.Def_RewardType_FairyDayAward);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_XBXZ", GotServerRewardType.Def_RewardType_XBXZ);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_DayRealmPoint", GotServerRewardType.Def_RewardType_DayRealmPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_GoldGiftFirst", GotServerRewardType.Def_RewardType_GoldGiftFirst);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_TreasureSoul", GotServerRewardType.Def_RewardType_TreasureSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_ConsumeRebate", GotServerRewardType.Def_RewardType_ConsumeRebate);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_BossReborn", GotServerRewardType.Def_RewardType_BossReborn);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FCRecharge", GotServerRewardType.Def_RewardType_FCRecharge);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FCParty", GotServerRewardType.Def_RewardType_FCParty);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_WishingWell", GotServerRewardType.Def_RewardType_WishingWell);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_OpenFunc", GotServerRewardType.Def_RewardType_OpenFunc);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_TotalRecharge", GotServerRewardType.Def_RewardType_TotalRecharge);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_IceLodeStar", GotServerRewardType.Def_RewardType_IceLodeStar);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_WeekPartyAct", GotServerRewardType.Def_RewardType_WeekPartyAct);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_WeekPartyPoint", GotServerRewardType.Def_RewardType_WeekPartyPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_ActLoginAwardAct", GotServerRewardType.Def_RewardType_ActLoginAwardAct);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_NewFairyCRecharge", GotServerRewardType.Def_RewardType_NewFairyCRecharge);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_NewFairyCParty", GotServerRewardType.Def_RewardType_NewFairyCParty);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FeastWeekPartyAct", GotServerRewardType.Def_RewardType_FeastWeekPartyAct);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FeastWeekPartyPoint", GotServerRewardType.Def_RewardType_FeastWeekPartyPoint);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FairyAdventuresAward", GotServerRewardType.Def_RewardType_FairyAdventuresAward);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(GotServerRewardType), 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.PushGotServerRewardType(L, (GotServerRewardType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_Activity"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_Activity);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FamilyActivity"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FamilyActivity);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_ChampionFamilyDailyReward"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_ChampionFamilyDailyReward);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_XMZZWinCnt"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_XMZZWinCnt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FairyDayAward"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FairyDayAward);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_XBXZ"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_XBXZ);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_DayRealmPoint"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_DayRealmPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_GoldGiftFirst"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_GoldGiftFirst);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_TreasureSoul"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_TreasureSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_ConsumeRebate"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_ConsumeRebate);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_BossReborn"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_BossReborn);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FCRecharge"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FCRecharge);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FCParty"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FCParty);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_WishingWell"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_WishingWell);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_OpenFunc"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_OpenFunc);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_TotalRecharge"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_TotalRecharge);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_IceLodeStar"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_IceLodeStar);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_WeekPartyAct"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_WeekPartyAct);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_WeekPartyPoint"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_WeekPartyPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_ActLoginAwardAct"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_ActLoginAwardAct);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_NewFairyCRecharge"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_NewFairyCRecharge);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_NewFairyCParty"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_NewFairyCParty);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FeastWeekPartyAct"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FeastWeekPartyAct);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FeastWeekPartyPoint"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FeastWeekPartyPoint);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FairyAdventuresAward"))
			{
			translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FairyAdventuresAward);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for GotServerRewardType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for GotServerRewardType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class MapTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(MapType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(MapType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(MapType), L, null, 12, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenCountry", MapType.OpenCountry);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleFB", MapType.SingleFB);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultipleFB", MapType.MultipleFB);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyFB", MapType.FamilyFB);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyWarFB", MapType.FamilyWarFB);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryExam", MapType.CountryExam);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryFB", MapType.CountryFB);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllByCountry", MapType.AllByCountry);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", MapType.All);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VSRoom", MapType.VSRoom);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossAll", MapType.CrossAll);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(MapType), 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.PushMapType(L, (MapType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "OpenCountry"))
			{
			translator.PushMapType(L, MapType.OpenCountry);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleFB"))
			{
			translator.PushMapType(L, MapType.SingleFB);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MultipleFB"))
			{
			translator.PushMapType(L, MapType.MultipleFB);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyFB"))
			{
			translator.PushMapType(L, MapType.FamilyFB);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyWarFB"))
			{
			translator.PushMapType(L, MapType.FamilyWarFB);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryExam"))
			{
			translator.PushMapType(L, MapType.CountryExam);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryFB"))
			{
			translator.PushMapType(L, MapType.CountryFB);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AllByCountry"))
			{
			translator.PushMapType(L, MapType.AllByCountry);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
			{
			translator.PushMapType(L, MapType.All);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "VSRoom"))
			{
			translator.PushMapType(L, MapType.VSRoom);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossAll"))
			{
			translator.PushMapType(L, MapType.CrossAll);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for MapType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for MapType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class GuideTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(GuideType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(GuideType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(GuideType), L, null, 3, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NewBie", GuideType.NewBie);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Functional", GuideType.Functional);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(GuideType), 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.PushGuideType(L, (GuideType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "NewBie"))
			{
			translator.PushGuideType(L, GuideType.NewBie);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Functional"))
			{
			translator.PushGuideType(L, GuideType.Functional);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for GuideType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for GuideType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class GuideTriggerTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(GuideTriggerType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(GuideTriggerType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(GuideTriggerType), L, null, 28, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", GuideTriggerType.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FunctionOpen", GuideTriggerType.FunctionOpen);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ManualFunctionOpen", GuideTriggerType.ManualFunctionOpen);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Level", GuideTriggerType.Level);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", GuideTriggerType.Treasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipQuality", GuideTriggerType.EquipQuality);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Item", GuideTriggerType.Item);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureDungeon", GuideTriggerType.TreasureDungeon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Map", GuideTriggerType.Map);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneInlay", GuideTriggerType.RuneInlay);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmSitDown", GuideTriggerType.RealmSitDown);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ItemCompound", GuideTriggerType.ItemCompound);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HangUpResult", GuideTriggerType.HangUpResult);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureCollectSoul", GuideTriggerType.TreasureCollectSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureAwaken", GuideTriggerType.TreasureAwaken);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pray", GuideTriggerType.Pray);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VIPExperience", GuideTriggerType.VIPExperience);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLandBuyTimes", GuideTriggerType.FairyLandBuyTimes);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamAutoAccept", GuideTriggerType.TeamAutoAccept);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialExchange", GuideTriggerType.TrialExchange);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanAccept", GuideTriggerType.QuestCanAccept);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanDo", GuideTriggerType.QuestCanDo);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanAward", GuideTriggerType.QuestCanAward);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestLimit", GuideTriggerType.QuestLimit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestContinue", GuideTriggerType.QuestContinue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestCando", GuideTriggerType.BranchQuestCando);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestCanAward", GuideTriggerType.BranchQuestCanAward);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(GuideTriggerType), 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.PushGuideTriggerType(L, (GuideTriggerType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FunctionOpen"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.FunctionOpen);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ManualFunctionOpen"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.ManualFunctionOpen);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Level"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.Level);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.Treasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipQuality"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.EquipQuality);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Item"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.Item);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureDungeon"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.TreasureDungeon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Map"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.Map);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneInlay"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.RuneInlay);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmSitDown"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.RealmSitDown);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ItemCompound"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.ItemCompound);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HangUpResult"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.HangUpResult);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureCollectSoul"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.TreasureCollectSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureAwaken"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.TreasureAwaken);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pray"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.Pray);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "VIPExperience"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.VIPExperience);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLandBuyTimes"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.FairyLandBuyTimes);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamAutoAccept"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.TeamAutoAccept);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialExchange"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.TrialExchange);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanAccept"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.QuestCanAccept);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanDo"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.QuestCanDo);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanAward"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.QuestCanAward);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestLimit"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.QuestLimit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestContinue"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.QuestContinue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BranchQuestCando"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.BranchQuestCando);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BranchQuestCanAward"))
			{
			translator.PushGuideTriggerType(L, GuideTriggerType.BranchQuestCanAward);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for GuideTriggerType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for GuideTriggerType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class FuncPowerTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(FuncPowerType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(FuncPowerType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(FuncPowerType), L, null, 26, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Role", FuncPowerType.Role);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip", FuncPowerType.Equip);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Plus", FuncPowerType.Plus);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stone", FuncPowerType.Stone);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Reiki", FuncPowerType.Reiki);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", FuncPowerType.Wing);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wash", FuncPowerType.Wash);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", FuncPowerType.Pet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horse", FuncPowerType.Horse);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", FuncPowerType.Realm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GodWeapon", FuncPowerType.GodWeapon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Title", FuncPowerType.Title);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rune", FuncPowerType.Rune);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Star", FuncPowerType.Star);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Human", FuncPowerType.Human);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy", FuncPowerType.Alchemy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", FuncPowerType.Demon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", FuncPowerType.Fairy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetSoul", FuncPowerType.PetSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HorseSoul", FuncPowerType.HorseSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dogz", FuncPowerType.Dogz);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoul", FuncPowerType.GatherSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "King", FuncPowerType.King);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionDress", FuncPowerType.FashionDress);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyEquip", FuncPowerType.JadeDynastyEquip);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(FuncPowerType), 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.PushFuncPowerType(L, (FuncPowerType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Role"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Role);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Equip);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Plus"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Plus);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Stone"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Stone);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Reiki"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Reiki);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Wing);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wash"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Wash);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Pet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Horse"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Horse);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Realm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GodWeapon"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.GodWeapon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Title"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Title);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Rune"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Rune);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Star"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Star);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Human"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Human);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Alchemy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Demon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Fairy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetSoul"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.PetSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HorseSoul"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.HorseSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Dogz"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.Dogz);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoul"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.GatherSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "King"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.King);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionDress"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.FashionDress);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyEquip"))
			{
			translator.PushFuncPowerType(L, FuncPowerType.JadeDynastyEquip);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for FuncPowerType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for FuncPowerType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class E_AtkTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(E_AtkType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(E_AtkType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(E_AtkType), L, null, 13, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Special", E_AtkType.Special);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Single", E_AtkType.Single);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Multiple", E_AtkType.Multiple);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Transmit", E_AtkType.Transmit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClearHatred", E_AtkType.ClearHatred);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleHatred", E_AtkType.SingleHatred);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultipleBuff", E_AtkType.MultipleBuff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Summon", E_AtkType.Summon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleRecoverAtkPer", E_AtkType.SingleRecoverAtkPer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FastMove", E_AtkType.FastMove);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlashMove", E_AtkType.FlashMove);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RushAttack", E_AtkType.RushAttack);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(E_AtkType), 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.PushE_AtkType(L, (E_AtkType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Special"))
			{
			translator.PushE_AtkType(L, E_AtkType.Special);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Single"))
			{
			translator.PushE_AtkType(L, E_AtkType.Single);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Multiple"))
			{
			translator.PushE_AtkType(L, E_AtkType.Multiple);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Transmit"))
			{
			translator.PushE_AtkType(L, E_AtkType.Transmit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ClearHatred"))
			{
			translator.PushE_AtkType(L, E_AtkType.ClearHatred);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleHatred"))
			{
			translator.PushE_AtkType(L, E_AtkType.SingleHatred);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MultipleBuff"))
			{
			translator.PushE_AtkType(L, E_AtkType.MultipleBuff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Summon"))
			{
			translator.PushE_AtkType(L, E_AtkType.Summon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleRecoverAtkPer"))
			{
			translator.PushE_AtkType(L, E_AtkType.SingleRecoverAtkPer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FastMove"))
			{
			translator.PushE_AtkType(L, E_AtkType.FastMove);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FlashMove"))
			{
			translator.PushE_AtkType(L, E_AtkType.FlashMove);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RushAttack"))
			{
			translator.PushE_AtkType(L, E_AtkType.RushAttack);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for E_AtkType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for E_AtkType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class GameObjTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(GameObjType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(GameObjType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(GameObjType), L, null, 7, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotNone", GameObjType.gotNone);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotPlayer", GameObjType.gotPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotNPC", GameObjType.gotNPC);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotItem", GameObjType.gotItem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotFlyObj", GameObjType.gotFlyObj);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotMax", GameObjType.gotMax);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(GameObjType), 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.PushGameObjType(L, (GameObjType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "gotNone"))
			{
			translator.PushGameObjType(L, GameObjType.gotNone);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "gotPlayer"))
			{
			translator.PushGameObjType(L, GameObjType.gotPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "gotNPC"))
			{
			translator.PushGameObjType(L, GameObjType.gotNPC);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "gotItem"))
			{
			translator.PushGameObjType(L, GameObjType.gotItem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "gotFlyObj"))
			{
			translator.PushGameObjType(L, GameObjType.gotFlyObj);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "gotMax"))
			{
			translator.PushGameObjType(L, GameObjType.gotMax);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for GameObjType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for GameObjType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class HurtAttackTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(HurtAttackType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(HurtAttackType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(HurtAttackType), L, null, 17, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", HurtAttackType.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Recovery", HurtAttackType.Recovery);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BounceHurt", HurtAttackType.BounceHurt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bleed", HurtAttackType.Bleed);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Parry", HurtAttackType.Parry);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DoubleHit", HurtAttackType.DoubleHit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHit", HurtAttackType.SuperHit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHit", HurtAttackType.LuckyHit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Miss", HurtAttackType.Miss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Immune", HurtAttackType.Immune);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Suppress", HurtAttackType.Suppress);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZhanSha", HurtAttackType.ZhanSha);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZhuXianAtk", HurtAttackType.ZhuXianAtk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FinalKill", HurtAttackType.FinalKill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeadlyHit", HurtAttackType.DeadlyHit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ThumpHit", HurtAttackType.ThumpHit);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(HurtAttackType), 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.PushHurtAttackType(L, (HurtAttackType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Recovery"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.Recovery);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BounceHurt"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.BounceHurt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Bleed"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.Bleed);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Parry"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.Parry);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DoubleHit"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.DoubleHit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHit"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.SuperHit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHit"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.LuckyHit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Miss"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.Miss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Immune"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.Immune);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Suppress"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.Suppress);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZhanSha"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.ZhanSha);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ZhuXianAtk"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.ZhuXianAtk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FinalKill"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.FinalKill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DeadlyHit"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.DeadlyHit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ThumpHit"))
			{
			translator.PushHurtAttackType(L, HurtAttackType.ThumpHit);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for HurtAttackType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for HurtAttackType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class DungeonTargetTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(DungeonTargetType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DungeonTargetType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(DungeonTargetType), L, null, 13, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NPC", DungeonTargetType.NPC);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Exp", DungeonTargetType.Exp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Score", DungeonTargetType.Score);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Money", DungeonTargetType.Money);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wave", DungeonTargetType.Wave);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcTotal", DungeonTargetType.NpcTotal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stage", DungeonTargetType.Stage);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NPCDialogue", DungeonTargetType.NPCDialogue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VictorySumCnt", DungeonTargetType.VictorySumCnt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StageVictoryCnt", DungeonTargetType.StageVictoryCnt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collect", DungeonTargetType.Collect);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AttackCount", DungeonTargetType.AttackCount);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(DungeonTargetType), 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.PushDungeonTargetType(L, (DungeonTargetType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "NPC"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.NPC);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Exp"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.Exp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Score"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.Score);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Money"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.Money);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wave"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.Wave);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcTotal"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.NpcTotal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Stage"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.Stage);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NPCDialogue"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.NPCDialogue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "VictorySumCnt"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.VictorySumCnt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "StageVictoryCnt"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.StageVictoryCnt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Collect"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.Collect);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AttackCount"))
			{
			translator.PushDungeonTargetType(L, DungeonTargetType.AttackCount);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for DungeonTargetType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for DungeonTargetType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class AchievementTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(AchievementType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(AchievementType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(AchievementType), L, null, 65, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Level", AchievementType.Level);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPower", AchievementType.FightPower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainLine", AchievementType.MainLine);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonster", AchievementType.KillMonster);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DailyQuest", AchievementType.DailyQuest);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyQuest", AchievementType.FairyQuest);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobRank", AchievementType.JobRank);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MagicWeaponLevel", AchievementType.MagicWeaponLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountCount", AchievementType.MountCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountLevel", AchievementType.MountLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetCount", AchievementType.PetCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetLevel", AchievementType.PetLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectGold", AchievementType.CollectGold);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectBindDiamond", AchievementType.CollectBindDiamond);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectDiamond", AchievementType.CollectDiamond);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AccumulativeSignIn", AchievementType.AccumulativeSignIn);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ContinuousSignIn", AchievementType.ContinuousSignIn);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PackbackGrid", AchievementType.PackbackGrid);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FriendCount", AchievementType.FriendCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldChat", AchievementType.WorldChat);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SaleItem", AchievementType.SaleItem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BuyItem", AchievementType.BuyItem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dead", AchievementType.Dead);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClearRedName", AchievementType.ClearRedName);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillPlayer", AchievementType.KillPlayer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthenCount", AchievementType.StrengthenCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipStrengthenLevel", AchievementType.EquipStrengthenLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldBoss", AchievementType.WorldBoss);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CircleQuest", AchievementType.CircleQuest);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureDungeon", AchievementType.TreasureDungeon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JoinGuild", AchievementType.JoinGuild);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JoinTeam", AchievementType.JoinTeam);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectTreasure", AchievementType.CollectTreasure);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeKilledCount", AchievementType.BeKilledCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrayCount", AchievementType.PrayCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillNPC", AchievementType.KillNPC);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindWorldMap", AchievementType.FindWorldMap);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PutonEquipPlace", AchievementType.PutonEquipPlace);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PutonEquipQuality", AchievementType.PutonEquipQuality);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MissionTranfer", AchievementType.MissionTranfer);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PropertyAdd", AchievementType.PropertyAdd);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", AchievementType.RuneTower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", AchievementType.Mount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetRune", AchievementType.GetRune);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneLevel", AchievementType.RuneLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyArea", AchievementType.FairyArea);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeItem", AchievementType.ComposeItem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InlayGem", AchievementType.InlayGem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin", AchievementType.Kylin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", AchievementType.Realm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RefiningDan", AchievementType.RefiningDan);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ActivevalueAward", AchievementType.ActivevalueAward);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureLevel", AchievementType.TreasureLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGroundKillCnt", AchievementType.AncientBattleGroundKillCnt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGroundMultiKill", AchievementType.AncientBattleGroundMultiKill);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnLockPet", AchievementType.UnLockPet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetRank", AchievementType.PetRank);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetRanks", AchievementType.PetRanks);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LifeGemInlay", AchievementType.LifeGemInlay);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AttackGemInlay", AchievementType.AttackGemInlay);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairylandExp", AchievementType.FairylandExp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NuwaGradeS", AchievementType.NuwaGradeS);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AnyMountLevel", AchievementType.AnyMountLevel);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DvsFWinningStreak", AchievementType.DvsFWinningStreak);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(AchievementType), 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.PushAchievementType(L, (AchievementType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Level"))
			{
			translator.PushAchievementType(L, AchievementType.Level);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPower"))
			{
			translator.PushAchievementType(L, AchievementType.FightPower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MainLine"))
			{
			translator.PushAchievementType(L, AchievementType.MainLine);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonster"))
			{
			translator.PushAchievementType(L, AchievementType.KillMonster);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DailyQuest"))
			{
			translator.PushAchievementType(L, AchievementType.DailyQuest);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyQuest"))
			{
			translator.PushAchievementType(L, AchievementType.FairyQuest);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JobRank"))
			{
			translator.PushAchievementType(L, AchievementType.JobRank);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MagicWeaponLevel"))
			{
			translator.PushAchievementType(L, AchievementType.MagicWeaponLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MountCount"))
			{
			translator.PushAchievementType(L, AchievementType.MountCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MountLevel"))
			{
			translator.PushAchievementType(L, AchievementType.MountLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetCount"))
			{
			translator.PushAchievementType(L, AchievementType.PetCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetLevel"))
			{
			translator.PushAchievementType(L, AchievementType.PetLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectGold"))
			{
			translator.PushAchievementType(L, AchievementType.CollectGold);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectBindDiamond"))
			{
			translator.PushAchievementType(L, AchievementType.CollectBindDiamond);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectDiamond"))
			{
			translator.PushAchievementType(L, AchievementType.CollectDiamond);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AccumulativeSignIn"))
			{
			translator.PushAchievementType(L, AchievementType.AccumulativeSignIn);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ContinuousSignIn"))
			{
			translator.PushAchievementType(L, AchievementType.ContinuousSignIn);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PackbackGrid"))
			{
			translator.PushAchievementType(L, AchievementType.PackbackGrid);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FriendCount"))
			{
			translator.PushAchievementType(L, AchievementType.FriendCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldChat"))
			{
			translator.PushAchievementType(L, AchievementType.WorldChat);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SaleItem"))
			{
			translator.PushAchievementType(L, AchievementType.SaleItem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BuyItem"))
			{
			translator.PushAchievementType(L, AchievementType.BuyItem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Dead"))
			{
			translator.PushAchievementType(L, AchievementType.Dead);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ClearRedName"))
			{
			translator.PushAchievementType(L, AchievementType.ClearRedName);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillPlayer"))
			{
			translator.PushAchievementType(L, AchievementType.KillPlayer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthenCount"))
			{
			translator.PushAchievementType(L, AchievementType.StrengthenCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipStrengthenLevel"))
			{
			translator.PushAchievementType(L, AchievementType.EquipStrengthenLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldBoss"))
			{
			translator.PushAchievementType(L, AchievementType.WorldBoss);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CircleQuest"))
			{
			translator.PushAchievementType(L, AchievementType.CircleQuest);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureDungeon"))
			{
			translator.PushAchievementType(L, AchievementType.TreasureDungeon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JoinGuild"))
			{
			translator.PushAchievementType(L, AchievementType.JoinGuild);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JoinTeam"))
			{
			translator.PushAchievementType(L, AchievementType.JoinTeam);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectTreasure"))
			{
			translator.PushAchievementType(L, AchievementType.CollectTreasure);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "BeKilledCount"))
			{
			translator.PushAchievementType(L, AchievementType.BeKilledCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PrayCount"))
			{
			translator.PushAchievementType(L, AchievementType.PrayCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "KillNPC"))
			{
			translator.PushAchievementType(L, AchievementType.KillNPC);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FindWorldMap"))
			{
			translator.PushAchievementType(L, AchievementType.FindWorldMap);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PutonEquipPlace"))
			{
			translator.PushAchievementType(L, AchievementType.PutonEquipPlace);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PutonEquipQuality"))
			{
			translator.PushAchievementType(L, AchievementType.PutonEquipQuality);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "MissionTranfer"))
			{
			translator.PushAchievementType(L, AchievementType.MissionTranfer);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PropertyAdd"))
			{
			translator.PushAchievementType(L, AchievementType.PropertyAdd);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
			{
			translator.PushAchievementType(L, AchievementType.RuneTower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
			{
			translator.PushAchievementType(L, AchievementType.Mount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GetRune"))
			{
			translator.PushAchievementType(L, AchievementType.GetRune);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneLevel"))
			{
			translator.PushAchievementType(L, AchievementType.RuneLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyArea"))
			{
			translator.PushAchievementType(L, AchievementType.FairyArea);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeItem"))
			{
			translator.PushAchievementType(L, AchievementType.ComposeItem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "InlayGem"))
			{
			translator.PushAchievementType(L, AchievementType.InlayGem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin"))
			{
			translator.PushAchievementType(L, AchievementType.Kylin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
			{
			translator.PushAchievementType(L, AchievementType.Realm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RefiningDan"))
			{
			translator.PushAchievementType(L, AchievementType.RefiningDan);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ActivevalueAward"))
			{
			translator.PushAchievementType(L, AchievementType.ActivevalueAward);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureLevel"))
			{
			translator.PushAchievementType(L, AchievementType.TreasureLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGroundKillCnt"))
			{
			translator.PushAchievementType(L, AchievementType.AncientBattleGroundKillCnt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGroundMultiKill"))
			{
			translator.PushAchievementType(L, AchievementType.AncientBattleGroundMultiKill);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "UnLockPet"))
			{
			translator.PushAchievementType(L, AchievementType.UnLockPet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetRank"))
			{
			translator.PushAchievementType(L, AchievementType.PetRank);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PetRanks"))
			{
			translator.PushAchievementType(L, AchievementType.PetRanks);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LifeGemInlay"))
			{
			translator.PushAchievementType(L, AchievementType.LifeGemInlay);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AttackGemInlay"))
			{
			translator.PushAchievementType(L, AchievementType.AttackGemInlay);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FairylandExp"))
			{
			translator.PushAchievementType(L, AchievementType.FairylandExp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "NuwaGradeS"))
			{
			translator.PushAchievementType(L, AchievementType.NuwaGradeS);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "AnyMountLevel"))
			{
			translator.PushAchievementType(L, AchievementType.AnyMountLevel);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "DvsFWinningStreak"))
			{
			translator.PushAchievementType(L, AchievementType.DvsFWinningStreak);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for AchievementType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for AchievementType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class ItemTimeTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(ItemTimeType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ItemTimeType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(ItemTimeType), L, null, 3, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipedTime", ItemTimeType.EquipedTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealityTime", ItemTimeType.RealityTime);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(ItemTimeType), 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.PushItemTimeType(L, (ItemTimeType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "EquipedTime"))
			{
			translator.PushItemTimeType(L, ItemTimeType.EquipedTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RealityTime"))
			{
			translator.PushItemTimeType(L, ItemTimeType.RealityTime);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for ItemTimeType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for ItemTimeType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class TitleBtnStateWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(TitleBtnState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(TitleBtnState), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(TitleBtnState), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", TitleBtnState.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Click", TitleBtnState.Click);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Locked", TitleBtnState.Locked);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(TitleBtnState), 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.PushTitleBtnState(L, (TitleBtnState)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushTitleBtnState(L, TitleBtnState.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Click"))
			{
			translator.PushTitleBtnState(L, TitleBtnState.Click);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Locked"))
			{
			translator.PushTitleBtnState(L, TitleBtnState.Locked);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for TitleBtnState!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for TitleBtnState! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class LegendAttrTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(LegendAttrType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(LegendAttrType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(LegendAttrType), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", LegendAttrType.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pursuit", LegendAttrType.Pursuit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fixed", LegendAttrType.Fixed);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(LegendAttrType), 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.PushLegendAttrType(L, (LegendAttrType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushLegendAttrType(L, LegendAttrType.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pursuit"))
			{
			translator.PushLegendAttrType(L, LegendAttrType.Pursuit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fixed"))
			{
			translator.PushLegendAttrType(L, LegendAttrType.Fixed);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for LegendAttrType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for LegendAttrType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class ServerStateWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(ServerState), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ServerState), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(ServerState), L, null, 6, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Maintain", ServerState.Maintain);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", ServerState.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Busy", ServerState.Busy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hot", ServerState.Hot);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Predicted", ServerState.Predicted);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(ServerState), 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.PushServerState(L, (ServerState)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Maintain"))
			{
			translator.PushServerState(L, ServerState.Maintain);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushServerState(L, ServerState.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Busy"))
			{
			translator.PushServerState(L, ServerState.Busy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Hot"))
			{
			translator.PushServerState(L, ServerState.Hot);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Predicted"))
			{
			translator.PushServerState(L, ServerState.Predicted);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for ServerState!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for ServerState! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class ItemUseDataKeyWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(ItemUseDataKey), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ItemUseDataKey), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(ItemUseDataKey), L, null, 29, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "mapLoaction", ItemUseDataKey.mapLoaction);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "legendAttrID", ItemUseDataKey.legendAttrID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemCount", ItemUseDataKey.itemCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "legendAttrValue", ItemUseDataKey.legendAttrValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "outOfPrintAttrID", ItemUseDataKey.outOfPrintAttrID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "outOfPrintAttrValue", ItemUseDataKey.outOfPrintAttrValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemColor", ItemUseDataKey.itemColor);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "cancelUseLimit", ItemUseDataKey.cancelUseLimit);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "source", ItemUseDataKey.source);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingMaterialItemID", ItemUseDataKey.wingMaterialItemID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingMaterialItemCount", ItemUseDataKey.wingMaterialItemCount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "suiteLV", ItemUseDataKey.suiteLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "dogzEquipPlus", ItemUseDataKey.dogzEquipPlus);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "hasOpenCnt", ItemUseDataKey.hasOpenCnt);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemDecompound", ItemUseDataKey.itemDecompound);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "createItemLoginDay", ItemUseDataKey.createItemLoginDay);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "lastOpenItemLoginDay", ItemUseDataKey.lastOpenItemLoginDay);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "runeLV", ItemUseDataKey.runeLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "birthChartLV", ItemUseDataKey.birthChartLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingProgressValue", ItemUseDataKey.wingProgressValue);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "createTime", ItemUseDataKey.createTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "totalTime", ItemUseDataKey.totalTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "auctionItemCreateTime", ItemUseDataKey.auctionItemCreateTime);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_NPCID", ItemUseDataKey.pet_NPCID);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_ClassLV", ItemUseDataKey.pet_ClassLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_State", ItemUseDataKey.pet_State);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_QualityLV", ItemUseDataKey.pet_QualityLV);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_Skill", ItemUseDataKey.pet_Skill);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(ItemUseDataKey), 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.PushItemUseDataKey(L, (ItemUseDataKey)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "mapLoaction"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.mapLoaction);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "legendAttrID"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.legendAttrID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "itemCount"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.itemCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "legendAttrValue"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.legendAttrValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "outOfPrintAttrID"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.outOfPrintAttrID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "outOfPrintAttrValue"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.outOfPrintAttrValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "itemColor"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.itemColor);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "cancelUseLimit"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.cancelUseLimit);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "source"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.source);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "wingMaterialItemID"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.wingMaterialItemID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "wingMaterialItemCount"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.wingMaterialItemCount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "suiteLV"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.suiteLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "dogzEquipPlus"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.dogzEquipPlus);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "hasOpenCnt"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.hasOpenCnt);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "itemDecompound"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.itemDecompound);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "createItemLoginDay"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.createItemLoginDay);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "lastOpenItemLoginDay"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.lastOpenItemLoginDay);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "runeLV"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.runeLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "birthChartLV"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.birthChartLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "wingProgressValue"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.wingProgressValue);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "createTime"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.createTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "totalTime"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.totalTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "auctionItemCreateTime"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.auctionItemCreateTime);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_NPCID"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.pet_NPCID);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_ClassLV"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.pet_ClassLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_State"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.pet_State);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_QualityLV"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.pet_QualityLV);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_Skill"))
			{
			translator.PushItemUseDataKey(L, ItemUseDataKey.pet_Skill);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for ItemUseDataKey!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for ItemUseDataKey! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class ItemOperateTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(ItemOperateType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ItemOperateType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(ItemOperateType), L, null, 24, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "makeUse", ItemOperateType.makeUse);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putOn", ItemOperateType.putOn);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "dismantle", ItemOperateType.dismantle);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "split", ItemOperateType.split);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putAway", ItemOperateType.putAway);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "compose", ItemOperateType.compose);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "sell", ItemOperateType.sell);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putOff", ItemOperateType.putOff);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putIn", ItemOperateType.putIn);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putOut", ItemOperateType.putOut);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "exchange", ItemOperateType.exchange);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buy", ItemOperateType.buy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putItemout", ItemOperateType.putItemout);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "renewal", ItemOperateType.renewal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "refine", ItemOperateType.refine);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LevelUp", ItemOperateType.LevelUp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Resolve", ItemOperateType.Resolve);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wear", ItemOperateType.Wear);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Replace", ItemOperateType.Replace);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "strength", ItemOperateType.strength);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "inlay", ItemOperateType.inlay);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "train", ItemOperateType.train);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "star", ItemOperateType.star);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(ItemOperateType), 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.PushItemOperateType(L, (ItemOperateType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "makeUse"))
			{
			translator.PushItemOperateType(L, ItemOperateType.makeUse);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "putOn"))
			{
			translator.PushItemOperateType(L, ItemOperateType.putOn);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "dismantle"))
			{
			translator.PushItemOperateType(L, ItemOperateType.dismantle);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "split"))
			{
			translator.PushItemOperateType(L, ItemOperateType.split);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "putAway"))
			{
			translator.PushItemOperateType(L, ItemOperateType.putAway);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "compose"))
			{
			translator.PushItemOperateType(L, ItemOperateType.compose);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "sell"))
			{
			translator.PushItemOperateType(L, ItemOperateType.sell);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "putOff"))
			{
			translator.PushItemOperateType(L, ItemOperateType.putOff);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "putIn"))
			{
			translator.PushItemOperateType(L, ItemOperateType.putIn);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "putOut"))
			{
			translator.PushItemOperateType(L, ItemOperateType.putOut);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "exchange"))
			{
			translator.PushItemOperateType(L, ItemOperateType.exchange);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "buy"))
			{
			translator.PushItemOperateType(L, ItemOperateType.buy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "putItemout"))
			{
			translator.PushItemOperateType(L, ItemOperateType.putItemout);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "renewal"))
			{
			translator.PushItemOperateType(L, ItemOperateType.renewal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "refine"))
			{
			translator.PushItemOperateType(L, ItemOperateType.refine);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "LevelUp"))
			{
			translator.PushItemOperateType(L, ItemOperateType.LevelUp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Resolve"))
			{
			translator.PushItemOperateType(L, ItemOperateType.Resolve);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Wear"))
			{
			translator.PushItemOperateType(L, ItemOperateType.Wear);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Replace"))
			{
			translator.PushItemOperateType(L, ItemOperateType.Replace);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "strength"))
			{
			translator.PushItemOperateType(L, ItemOperateType.strength);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "inlay"))
			{
			translator.PushItemOperateType(L, ItemOperateType.inlay);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "train"))
			{
			translator.PushItemOperateType(L, ItemOperateType.train);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "star"))
			{
			translator.PushItemOperateType(L, ItemOperateType.star);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for ItemOperateType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for ItemOperateType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class ItemWinTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(ItemWinType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ItemWinType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(ItemWinType), L, null, 12, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemWin", ItemWinType.itemWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "boxWin", ItemWinType.boxWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "equipWin", ItemWinType.equipWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingsWin", ItemWinType.wingsWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "guardWin", ItemWinType.guardWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buyItemWin", ItemWinType.buyItemWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buyBoxWin", ItemWinType.buyBoxWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "petMatWin", ItemWinType.petMatWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buyPetMatWin", ItemWinType.buyPetMatWin);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gatherSoul", ItemWinType.gatherSoul);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kingTreasure", ItemWinType.kingTreasure);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(ItemWinType), 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.PushItemWinType(L, (ItemWinType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "itemWin"))
			{
			translator.PushItemWinType(L, ItemWinType.itemWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "boxWin"))
			{
			translator.PushItemWinType(L, ItemWinType.boxWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "equipWin"))
			{
			translator.PushItemWinType(L, ItemWinType.equipWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "wingsWin"))
			{
			translator.PushItemWinType(L, ItemWinType.wingsWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "guardWin"))
			{
			translator.PushItemWinType(L, ItemWinType.guardWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "buyItemWin"))
			{
			translator.PushItemWinType(L, ItemWinType.buyItemWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "buyBoxWin"))
			{
			translator.PushItemWinType(L, ItemWinType.buyBoxWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "petMatWin"))
			{
			translator.PushItemWinType(L, ItemWinType.petMatWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "buyPetMatWin"))
			{
			translator.PushItemWinType(L, ItemWinType.buyPetMatWin);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "gatherSoul"))
			{
			translator.PushItemWinType(L, ItemWinType.gatherSoul);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "kingTreasure"))
			{
			translator.PushItemWinType(L, ItemWinType.kingTreasure);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for ItemWinType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for ItemWinType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class ItemTipChildTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(ItemTipChildType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(ItemTipChildType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(ItemTipChildType), L, null, 7, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", ItemTipChildType.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Buy", ItemTipChildType.Buy);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionWarehouseDonation", ItemTipChildType.UnionWarehouseDonation);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionWarehouseExchange", ItemTipChildType.UnionWarehouseExchange);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetEquipPath", ItemTipChildType.GetEquipPath);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetWingsPath", ItemTipChildType.GetWingsPath);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(ItemTipChildType), 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.PushItemTipChildType(L, (ItemTipChildType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushItemTipChildType(L, ItemTipChildType.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Buy"))
			{
			translator.PushItemTipChildType(L, ItemTipChildType.Buy);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionWarehouseDonation"))
			{
			translator.PushItemTipChildType(L, ItemTipChildType.UnionWarehouseDonation);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionWarehouseExchange"))
			{
			translator.PushItemTipChildType(L, ItemTipChildType.UnionWarehouseExchange);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GetEquipPath"))
			{
			translator.PushItemTipChildType(L, ItemTipChildType.GetEquipPath);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "GetWingsPath"))
			{
			translator.PushItemTipChildType(L, ItemTipChildType.GetWingsPath);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for ItemTipChildType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for ItemTipChildType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class InstalledAssetWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(InstalledAsset), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(InstalledAsset), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(InstalledAsset), L, null, 5, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NullAsset", InstalledAsset.NullAsset);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HalfAsset", InstalledAsset.HalfAsset);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FullAsset", InstalledAsset.FullAsset);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IngoreDownLoad", InstalledAsset.IngoreDownLoad);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(InstalledAsset), 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.PushInstalledAsset(L, (InstalledAsset)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "NullAsset"))
			{
			translator.PushInstalledAsset(L, InstalledAsset.NullAsset);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "HalfAsset"))
			{
			translator.PushInstalledAsset(L, InstalledAsset.HalfAsset);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "FullAsset"))
			{
			translator.PushInstalledAsset(L, InstalledAsset.FullAsset);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "IngoreDownLoad"))
			{
			translator.PushInstalledAsset(L, InstalledAsset.IngoreDownLoad);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for InstalledAsset!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for InstalledAsset! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class VersionAuthorityWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(VersionAuthority), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(VersionAuthority), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(VersionAuthority), L, null, 3, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InterTest", VersionAuthority.InterTest);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Release", VersionAuthority.Release);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(VersionAuthority), 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.PushVersionAuthority(L, (VersionAuthority)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "InterTest"))
			{
			translator.PushVersionAuthority(L, VersionAuthority.InterTest);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Release"))
			{
			translator.PushVersionAuthority(L, VersionAuthority.Release);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for VersionAuthority!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for VersionAuthority! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class FootAudioTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(FootAudioType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(FootAudioType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(FootAudioType), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Walk", FootAudioType.Walk);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ride", FootAudioType.Ride);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fly", FootAudioType.Fly);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(FootAudioType), 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.PushFootAudioType(L, (FootAudioType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "Walk"))
			{
			translator.PushFootAudioType(L, FootAudioType.Walk);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Ride"))
			{
			translator.PushFootAudioType(L, FootAudioType.Ride);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Fly"))
			{
			translator.PushFootAudioType(L, FootAudioType.Fly);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for FootAudioType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for FootAudioType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class AttackFailTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(AttackFailType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(AttackFailType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(AttackFailType), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFail_Other", AttackFailType.SkillFail_Other);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFail_CD", AttackFailType.SkillFail_CD);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFail_AtkInterval", AttackFailType.SkillFail_AtkInterval);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(AttackFailType), 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.PushAttackFailType(L, (AttackFailType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFail_Other"))
			{
			translator.PushAttackFailType(L, AttackFailType.SkillFail_Other);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFail_CD"))
			{
			translator.PushAttackFailType(L, AttackFailType.SkillFail_CD);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFail_AtkInterval"))
			{
			translator.PushAttackFailType(L, AttackFailType.SkillFail_AtkInterval);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for AttackFailType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for AttackFailType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class DungeonFightStageWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(DungeonFightStage), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(DungeonFightStage), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(DungeonFightStage), L, null, 7, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", DungeonFightStage.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Prepare", DungeonFightStage.Prepare);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", DungeonFightStage.Normal);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PickUp", DungeonFightStage.PickUp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExitPrepare", DungeonFightStage.ExitPrepare);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodAreaNearDead", DungeonFightStage.ElderGodAreaNearDead);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(DungeonFightStage), 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.PushDungeonFightStage(L, (DungeonFightStage)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushDungeonFightStage(L, DungeonFightStage.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Prepare"))
			{
			translator.PushDungeonFightStage(L, DungeonFightStage.Prepare);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
			{
			translator.PushDungeonFightStage(L, DungeonFightStage.Normal);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "PickUp"))
			{
			translator.PushDungeonFightStage(L, DungeonFightStage.PickUp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ExitPrepare"))
			{
			translator.PushDungeonFightStage(L, DungeonFightStage.ExitPrepare);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodAreaNearDead"))
			{
			translator.PushDungeonFightStage(L, DungeonFightStage.ElderGodAreaNearDead);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for DungeonFightStage!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for DungeonFightStage! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class RankTypeWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(RankType), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(RankType), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(RankType), L, null, 24, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPower", RankType.FightPower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job1FightPower", RankType.Job1FightPower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job2FightPower", RankType.Job2FightPower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job3FightPower", RankType.Job3FightPower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Level", RankType.Level);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", RankType.Mount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", RankType.Pet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", RankType.RuneTower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OfflineExp", RankType.OfflineExp);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", RankType.Realm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerStrengthen", RankType.OpenServerStrengthen);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerMount", RankType.OpenServerMount);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGem", RankType.OpenServerGem);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerLv", RankType.OpenServerLv);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRealm", RankType.OpenServerRealm);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerFightPower", RankType.OpenServerFightPower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_BT_FCCostGold", RankType.Def_BT_FCCostGold);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRune", RankType.OpenServerRune);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGodWeapon", RankType.OpenServerGodWeapon);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRecharge", RankType.OpenServerRecharge);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerPet", RankType.OpenServerPet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyTower", RankType.JadeDynastyTower);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_BT_NewFCCostGold", RankType.Def_BT_NewFCCostGold);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(RankType), 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.PushRankType(L, (RankType)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "FightPower"))
			{
			translator.PushRankType(L, RankType.FightPower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Job1FightPower"))
			{
			translator.PushRankType(L, RankType.Job1FightPower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Job2FightPower"))
			{
			translator.PushRankType(L, RankType.Job2FightPower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Job3FightPower"))
			{
			translator.PushRankType(L, RankType.Job3FightPower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Level"))
			{
			translator.PushRankType(L, RankType.Level);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
			{
			translator.PushRankType(L, RankType.Mount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
			{
			translator.PushRankType(L, RankType.Pet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
			{
			translator.PushRankType(L, RankType.RuneTower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OfflineExp"))
			{
			translator.PushRankType(L, RankType.OfflineExp);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
			{
			translator.PushRankType(L, RankType.Realm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerStrengthen"))
			{
			translator.PushRankType(L, RankType.OpenServerStrengthen);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerMount"))
			{
			translator.PushRankType(L, RankType.OpenServerMount);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGem"))
			{
			translator.PushRankType(L, RankType.OpenServerGem);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerLv"))
			{
			translator.PushRankType(L, RankType.OpenServerLv);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRealm"))
			{
			translator.PushRankType(L, RankType.OpenServerRealm);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerFightPower"))
			{
			translator.PushRankType(L, RankType.OpenServerFightPower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_BT_FCCostGold"))
			{
			translator.PushRankType(L, RankType.Def_BT_FCCostGold);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRune"))
			{
			translator.PushRankType(L, RankType.OpenServerRune);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGodWeapon"))
			{
			translator.PushRankType(L, RankType.OpenServerGodWeapon);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRecharge"))
			{
			translator.PushRankType(L, RankType.OpenServerRecharge);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerPet"))
			{
			translator.PushRankType(L, RankType.OpenServerPet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyTower"))
			{
			translator.PushRankType(L, RankType.JadeDynastyTower);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_BT_NewFCCostGold"))
			{
			translator.PushRankType(L, RankType.Def_BT_NewFCCostGold);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for RankType!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for RankType! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			public class PetOrMountWrap
			{
			public static void __Register(RealStatePtr L)
			{
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			Utils.BeginObjectRegister(typeof(PetOrMount), L, translator, 0, 0, 0, 0);
			Utils.EndObjectRegister(typeof(PetOrMount), L, translator, null, null, null, null, null);

			Utils.BeginClassRegister(typeof(PetOrMount), L, null, 4, 0, 0);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", PetOrMount.None);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", PetOrMount.Pet);

			Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", PetOrMount.Mount);

			Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);

			Utils.EndClassRegister(typeof(PetOrMount), 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.PushPetOrMount(L, (PetOrMount)LuaAPI.xlua_tointeger(L, 1));
			}

			else if(lua_type == LuaTypes.LUA_TSTRING)
			{
			if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
			{
			translator.PushPetOrMount(L, PetOrMount.None);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
			{
			translator.PushPetOrMount(L, PetOrMount.Pet);
			}
			else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
			{
			translator.PushPetOrMount(L, PetOrMount.Mount);
			}
			else
			{
			return LuaAPI.luaL_error(L, "invalid string for PetOrMount!");
			}
			}

			else
			{
			return LuaAPI.luaL_error(L, "invalid lua type for PetOrMount! Expect number or string, got + " + lua_type);
			}

			return 1;
			}
			}

			}