#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 comadjustsdkAdjustUtilsWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(com.adjust.sdk.AdjustUtils);
			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 14, 37, 37);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertLogLevel", _m_ConvertLogLevel_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertBool", _m_ConvertBool_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertDouble", _m_ConvertDouble_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertInt", _m_ConvertInt_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertLong", _m_ConvertLong_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertListToJson", _m_ConvertListToJson_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetJsonResponseCompact", _m_GetJsonResponseCompact_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetJsonString", _m_GetJsonString_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteJsonResponseDictionary", _m_WriteJsonResponseDictionary_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "TryGetValue", _m_TryGetValue_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkad4ConversionValue", _m_GetSkad4ConversionValue_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkad4CoarseValue", _m_GetSkad4CoarseValue_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkad4LockWindow", _m_GetSkad4LockWindow_xlua_st_);
            
			
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyAdid", _g_get_KeyAdid);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyMessage", _g_get_KeyMessage);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyNetwork", _g_get_KeyNetwork);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyAdgroup", _g_get_KeyAdgroup);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCampaign", _g_get_KeyCampaign);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCreative", _g_get_KeyCreative);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyWillRetry", _g_get_KeyWillRetry);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTimestamp", _g_get_KeyTimestamp);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCallbackId", _g_get_KeyCallbackId);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyEventToken", _g_get_KeyEventToken);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyClickLabel", _g_get_KeyClickLabel);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTrackerName", _g_get_KeyTrackerName);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTrackerToken", _g_get_KeyTrackerToken);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyJsonResponse", _g_get_KeyJsonResponse);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCostType", _g_get_KeyCostType);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCostAmount", _g_get_KeyCostAmount);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCostCurrency", _g_get_KeyCostCurrency);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyFbInstallReferrer", _g_get_KeyFbInstallReferrer);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeySkadConversionValue", _g_get_KeySkadConversionValue);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeySkadCoarseValue", _g_get_KeySkadCoarseValue);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeySkadLockWindow", _g_get_KeySkadLockWindow);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsBaseUrl", _g_get_KeyTestOptionsBaseUrl);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsGdprUrl", _g_get_KeyTestOptionsGdprUrl);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsSubscriptionUrl", _g_get_KeyTestOptionsSubscriptionUrl);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsExtraPath", _g_get_KeyTestOptionsExtraPath);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsBasePath", _g_get_KeyTestOptionsBasePath);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsGdprPath", _g_get_KeyTestOptionsGdprPath);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsDeleteState", _g_get_KeyTestOptionsDeleteState);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsUseTestConnectionOptions", _g_get_KeyTestOptionsUseTestConnectionOptions);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsTimerIntervalInMilliseconds", _g_get_KeyTestOptionsTimerIntervalInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsTimerStartInMilliseconds", _g_get_KeyTestOptionsTimerStartInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsSessionIntervalInMilliseconds", _g_get_KeyTestOptionsSessionIntervalInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsSubsessionIntervalInMilliseconds", _g_get_KeyTestOptionsSubsessionIntervalInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsTeardown", _g_get_KeyTestOptionsTeardown);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsNoBackoffWait", _g_get_KeyTestOptionsNoBackoffWait);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsiAdFrameworkEnabled", _g_get_KeyTestOptionsiAdFrameworkEnabled);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsAdServicesFrameworkEnabled", _g_get_KeyTestOptionsAdServicesFrameworkEnabled);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyAdid", _s_set_KeyAdid);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyMessage", _s_set_KeyMessage);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyNetwork", _s_set_KeyNetwork);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyAdgroup", _s_set_KeyAdgroup);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCampaign", _s_set_KeyCampaign);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCreative", _s_set_KeyCreative);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyWillRetry", _s_set_KeyWillRetry);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTimestamp", _s_set_KeyTimestamp);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCallbackId", _s_set_KeyCallbackId);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyEventToken", _s_set_KeyEventToken);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyClickLabel", _s_set_KeyClickLabel);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTrackerName", _s_set_KeyTrackerName);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTrackerToken", _s_set_KeyTrackerToken);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyJsonResponse", _s_set_KeyJsonResponse);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCostType", _s_set_KeyCostType);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCostAmount", _s_set_KeyCostAmount);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCostCurrency", _s_set_KeyCostCurrency);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyFbInstallReferrer", _s_set_KeyFbInstallReferrer);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeySkadConversionValue", _s_set_KeySkadConversionValue);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeySkadCoarseValue", _s_set_KeySkadCoarseValue);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeySkadLockWindow", _s_set_KeySkadLockWindow);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsBaseUrl", _s_set_KeyTestOptionsBaseUrl);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsGdprUrl", _s_set_KeyTestOptionsGdprUrl);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsSubscriptionUrl", _s_set_KeyTestOptionsSubscriptionUrl);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsExtraPath", _s_set_KeyTestOptionsExtraPath);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsBasePath", _s_set_KeyTestOptionsBasePath);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsGdprPath", _s_set_KeyTestOptionsGdprPath);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsDeleteState", _s_set_KeyTestOptionsDeleteState);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsUseTestConnectionOptions", _s_set_KeyTestOptionsUseTestConnectionOptions);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsTimerIntervalInMilliseconds", _s_set_KeyTestOptionsTimerIntervalInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsTimerStartInMilliseconds", _s_set_KeyTestOptionsTimerStartInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsSessionIntervalInMilliseconds", _s_set_KeyTestOptionsSessionIntervalInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsSubsessionIntervalInMilliseconds", _s_set_KeyTestOptionsSubsessionIntervalInMilliseconds);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsTeardown", _s_set_KeyTestOptionsTeardown);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsNoBackoffWait", _s_set_KeyTestOptionsNoBackoffWait);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsiAdFrameworkEnabled", _s_set_KeyTestOptionsiAdFrameworkEnabled);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsAdServicesFrameworkEnabled", _s_set_KeyTestOptionsAdServicesFrameworkEnabled);
            
			
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1)
				{
					
					var gen_ret = new com.adjust.sdk.AdjustUtils();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
			}
            return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustUtils constructor!");
            
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ConvertLogLevel_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Nullable<com.adjust.sdk.AdjustLogLevel> _logLevel;translator.Get(L, 1, out _logLevel);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.ConvertLogLevel( _logLevel );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ConvertBool_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Nullable<bool> _value;translator.Get(L, 1, out _value);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.ConvertBool( _value );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ConvertDouble_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Nullable<double> _value;translator.Get(L, 1, out _value);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.ConvertDouble( _value );
                        LuaAPI.lua_pushnumber(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_ConvertInt_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Nullable<int> _value;translator.Get(L, 1, out _value);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.ConvertInt( _value );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ConvertLong_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Nullable<long> _value;translator.Get(L, 1, out _value);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.ConvertLong( _value );
                        LuaAPI.lua_pushint64(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_ConvertListToJson_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Collections.Generic.List<string> _list = (System.Collections.Generic.List<string>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<string>));
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.ConvertListToJson( _list );
                        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_GetJsonResponseCompact_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Collections.Generic.Dictionary<string, object> _dictionary = (System.Collections.Generic.Dictionary<string, object>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<string, object>));
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.GetJsonResponseCompact( _dictionary );
                        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_GetJsonString_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    com.adjust.sdk.JSONNode _node = (com.adjust.sdk.JSONNode)translator.GetObject(L, 1, typeof(com.adjust.sdk.JSONNode));
                    string _key = LuaAPI.lua_tostring(L, 2);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.GetJsonString( _node, _key );
                        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_WriteJsonResponseDictionary_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    com.adjust.sdk.JSONClass _jsonObject = (com.adjust.sdk.JSONClass)translator.GetObject(L, 1, typeof(com.adjust.sdk.JSONClass));
                    System.Collections.Generic.Dictionary<string, object> _output = (System.Collections.Generic.Dictionary<string, object>)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary<string, object>));
                    
                    com.adjust.sdk.AdjustUtils.WriteJsonResponseDictionary( _jsonObject, _output );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TryGetValue_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Collections.Generic.Dictionary<string, string> _dictionary = (System.Collections.Generic.Dictionary<string, string>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<string, string>));
                    string _key = LuaAPI.lua_tostring(L, 2);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.TryGetValue( _dictionary, _key );
                        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_GetSkad4ConversionValue_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _conversionValueUpdate = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.GetSkad4ConversionValue( _conversionValueUpdate );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSkad4CoarseValue_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _conversionValueUpdate = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.GetSkad4CoarseValue( _conversionValueUpdate );
                        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_GetSkad4LockWindow_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    string _conversionValueUpdate = LuaAPI.lua_tostring(L, 1);
                    
                        var gen_ret = com.adjust.sdk.AdjustUtils.GetSkad4LockWindow( _conversionValueUpdate );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyAdid(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyAdid);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyMessage(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyMessage);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyNetwork(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyNetwork);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyAdgroup(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyAdgroup);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyCampaign(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCampaign);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyCreative(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCreative);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyWillRetry(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyWillRetry);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTimestamp(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTimestamp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyCallbackId(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCallbackId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyEventToken(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyEventToken);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyClickLabel(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyClickLabel);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTrackerName(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTrackerName);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTrackerToken(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTrackerToken);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyJsonResponse(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyJsonResponse);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyCostType(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCostType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyCostAmount(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCostAmount);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyCostCurrency(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCostCurrency);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyFbInstallReferrer(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyFbInstallReferrer);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeySkadConversionValue(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeySkadConversionValue);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeySkadCoarseValue(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeySkadCoarseValue);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeySkadLockWindow(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeySkadLockWindow);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsBaseUrl(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsBaseUrl);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsGdprUrl(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprUrl);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsSubscriptionUrl(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsSubscriptionUrl);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsExtraPath(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsExtraPath);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsBasePath(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsBasePath);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsGdprPath(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprPath);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsDeleteState(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsDeleteState);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsUseTestConnectionOptions(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsUseTestConnectionOptions);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsTimerIntervalInMilliseconds(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerIntervalInMilliseconds);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsTimerStartInMilliseconds(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerStartInMilliseconds);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsSessionIntervalInMilliseconds(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsSessionIntervalInMilliseconds);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsSubsessionIntervalInMilliseconds(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsSubsessionIntervalInMilliseconds);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsTeardown(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsTeardown);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsNoBackoffWait(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsNoBackoffWait);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsiAdFrameworkEnabled(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsiAdFrameworkEnabled);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_KeyTestOptionsAdServicesFrameworkEnabled(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsAdServicesFrameworkEnabled);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyAdid(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyAdid = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyMessage(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyMessage = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyNetwork(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyNetwork = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyAdgroup(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyAdgroup = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyCampaign(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyCampaign = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyCreative(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyCreative = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyWillRetry(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyWillRetry = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTimestamp(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTimestamp = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyCallbackId(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyCallbackId = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyEventToken(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyEventToken = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyClickLabel(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyClickLabel = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTrackerName(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTrackerName = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTrackerToken(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTrackerToken = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyJsonResponse(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyJsonResponse = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyCostType(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyCostType = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyCostAmount(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyCostAmount = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyCostCurrency(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyCostCurrency = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyFbInstallReferrer(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyFbInstallReferrer = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeySkadConversionValue(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeySkadConversionValue = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeySkadCoarseValue(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeySkadCoarseValue = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeySkadLockWindow(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeySkadLockWindow = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsBaseUrl(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsBaseUrl = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsGdprUrl(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprUrl = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsSubscriptionUrl(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsSubscriptionUrl = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsExtraPath(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsExtraPath = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsBasePath(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsBasePath = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsGdprPath(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprPath = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsDeleteState(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsDeleteState = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsUseTestConnectionOptions(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsUseTestConnectionOptions = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsTimerIntervalInMilliseconds(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerIntervalInMilliseconds = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsTimerStartInMilliseconds(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerStartInMilliseconds = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsSessionIntervalInMilliseconds(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsSessionIntervalInMilliseconds = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsSubsessionIntervalInMilliseconds(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsSubsessionIntervalInMilliseconds = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsTeardown(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsTeardown = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsNoBackoffWait(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsNoBackoffWait = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsiAdFrameworkEnabled(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsiAdFrameworkEnabled = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_KeyTestOptionsAdServicesFrameworkEnabled(RealStatePtr L)
        {
		    try {
                
			    com.adjust.sdk.AdjustUtils.KeyTestOptionsAdServicesFrameworkEnabled = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
		
		
		
		
    }
}