#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class TimeUtilityWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(TimeUtility);
			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 18, 15, 1);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "OnRefreshCreateRoleTime", _m_OnRefreshCreateRoleTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OnRefreshServerTime", _m_OnRefreshServerTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "OnRefreshServerOpenDay", _m_OnRefreshServerOpenDay_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SyncServerTime", _m_SyncServerTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTime", _m_GetTime_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondsToHMS", _m_SecondsToHMS_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondsToMS", _m_SecondsToMS_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondsToDHMSCHS", _m_SecondsToDHMSCHS_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondsToTitleDHMS", _m_SecondsToTitleDHMS_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondsToHMSCHSRetain", _m_SecondsToHMSCHSRetain_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondsToDHMS", _m_SecondsToDHMS_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SecondsToConsumeRebate", _m_SecondsToConsumeRebate_xlua_st_);
            
			Utils.RegisterFunc(L, Utils.CLS_IDX, "OnCreateRoleTimeRefresh", _e_OnCreateRoleTimeRefresh);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "OnServerTimeRefresh", _e_OnServerTimeRefresh);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "OnServerOpenDayRefresh", _e_OnServerOpenDayRefresh);
			
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OriginalTime", TimeUtility.OriginalTime);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClientOriginalTime", TimeUtility.ClientOriginalTime);
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ServerNow", _g_get_ServerNow);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Year", _g_get_Year);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Month", _g_get_Month);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Day", _g_get_Day);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Hour", _g_get_Hour);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Minute", _g_get_Minute);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Second", _g_get_Second);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "AllSeconds", _g_get_AllSeconds);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "OpenDay", _g_get_OpenDay);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsMixServer", _g_get_IsMixServer);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MixOpenDay", _g_get_MixOpenDay);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "OpenWeekCnt", _g_get_OpenWeekCnt);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "createRoleTime", _g_get_createRoleTime);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "CreateDays", _g_get_CreateDays);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "openServerDayOfWeek", _g_get_openServerDayOfWeek);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "openServerDayOfWeek", _s_set_openServerDayOfWeek);
            
			
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            return LuaAPI.luaL_error(L, "TimeUtility does not have a constructor!");
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnRefreshCreateRoleTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    HA124_tagMCPlayerInfo __package = (HA124_tagMCPlayerInfo)translator.GetObject(L, 1, typeof(HA124_tagMCPlayerInfo));
                    
                    TimeUtility.OnRefreshCreateRoleTime( __package );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnRefreshServerTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    HA004_tagServerDateTime _vNetData = (HA004_tagServerDateTime)translator.GetObject(L, 1, typeof(HA004_tagServerDateTime));
                    
                    TimeUtility.OnRefreshServerTime( _vNetData );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnRefreshServerOpenDay_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    HA005_tagOpenServerDay _package = (HA005_tagOpenServerDay)translator.GetObject(L, 1, typeof(HA005_tagOpenServerDay));
                    
                    TimeUtility.OnRefreshServerOpenDay( _package );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SyncServerTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    TimeUtility.SyncServerTime(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTime_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    uint _seconds = LuaAPI.xlua_touint(L, 1);
                    
                        System.DateTime gen_ret = TimeUtility.GetTime( _seconds );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondsToHMS_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = TimeUtility.SecondsToHMS( __seconds );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondsToMS_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = TimeUtility.SecondsToMS( __seconds );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondsToDHMSCHS_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = TimeUtility.SecondsToDHMSCHS( __seconds );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondsToTitleDHMS_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = TimeUtility.SecondsToTitleDHMS( __seconds );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondsToHMSCHSRetain_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) 
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    bool __hour = LuaAPI.lua_toboolean(L, 2);
                    bool __min = LuaAPI.lua_toboolean(L, 3);
                    bool __sec = LuaAPI.lua_toboolean(L, 4);
                    
                        string gen_ret = TimeUtility.SecondsToHMSCHSRetain( __seconds, __hour, __min, __sec );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) 
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    bool __hour = LuaAPI.lua_toboolean(L, 2);
                    bool __min = LuaAPI.lua_toboolean(L, 3);
                    
                        string gen_ret = TimeUtility.SecondsToHMSCHSRetain( __seconds, __hour, __min );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    bool __hour = LuaAPI.lua_toboolean(L, 2);
                    
                        string gen_ret = TimeUtility.SecondsToHMSCHSRetain( __seconds, __hour );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = TimeUtility.SecondsToHMSCHSRetain( __seconds );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to TimeUtility.SecondsToHMSCHSRetain!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondsToDHMS_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = TimeUtility.SecondsToDHMS( __seconds );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SecondsToConsumeRebate_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int __seconds = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = TimeUtility.SecondsToConsumeRebate( __seconds );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ServerNow(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, TimeUtility.ServerNow);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Year(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.Year);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Month(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.Month);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Day(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.Day);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Hour(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.Hour);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Minute(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.Minute);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_Second(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.Second);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AllSeconds(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.AllSeconds);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_OpenDay(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.OpenDay);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsMixServer(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, TimeUtility.IsMixServer);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MixOpenDay(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.MixOpenDay);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_OpenWeekCnt(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.OpenWeekCnt);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_createRoleTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, TimeUtility.createRoleTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_CreateDays(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, TimeUtility.CreateDays);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_openServerDayOfWeek(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, TimeUtility.openServerDayOfWeek);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_openServerDayOfWeek(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.DayOfWeek gen_value;translator.Get(L, 1, out gen_value);
				TimeUtility.openServerDayOfWeek = gen_value;
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
		
		
		
		
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_OnCreateRoleTimeRefresh(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    int gen_param_count = LuaAPI.lua_gettop(L);
                System.Action gen_delegate = translator.GetDelegate<System.Action>(L, 2);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#2 need System.Action!");
                }
                
				
				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) {
					TimeUtility.OnCreateRoleTimeRefresh += gen_delegate;
					return 0;
				} 
				
				
				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) {
					TimeUtility.OnCreateRoleTimeRefresh -= gen_delegate;
					return 0;
				} 
				
			} catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
			return LuaAPI.luaL_error(L, "invalid arguments to TimeUtility.OnCreateRoleTimeRefresh!");
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_OnServerTimeRefresh(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    int gen_param_count = LuaAPI.lua_gettop(L);
                System.Action gen_delegate = translator.GetDelegate<System.Action>(L, 2);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#2 need System.Action!");
                }
                
				
				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) {
					TimeUtility.OnServerTimeRefresh += gen_delegate;
					return 0;
				} 
				
				
				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) {
					TimeUtility.OnServerTimeRefresh -= gen_delegate;
					return 0;
				} 
				
			} catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
			return LuaAPI.luaL_error(L, "invalid arguments to TimeUtility.OnServerTimeRefresh!");
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_OnServerOpenDayRefresh(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    int gen_param_count = LuaAPI.lua_gettop(L);
                System.Action gen_delegate = translator.GetDelegate<System.Action>(L, 2);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#2 need System.Action!");
                }
                
				
				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) {
					TimeUtility.OnServerOpenDayRefresh += gen_delegate;
					return 0;
				} 
				
				
				if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) {
					TimeUtility.OnServerOpenDayRefresh -= gen_delegate;
					return 0;
				} 
				
			} catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
			return LuaAPI.luaL_error(L, "invalid arguments to TimeUtility.OnServerOpenDayRefresh!");
        }
        
    }
}