fix(ci): tentative fix for compiler out of heap space (#1746)

src/lua/natives/lua_native_binding.hpp

@@ -4,4 +4,50 @@
 namespace lua::native
 {
 	void init_native_binding(sol::state& L);
+
+	void init_native_binding_SYSTEM(sol::state& L);
+	void init_native_binding_APP(sol::state& L);
+	void init_native_binding_AUDIO(sol::state& L);
+	void init_native_binding_BRAIN(sol::state& L);
+	void init_native_binding_CAM(sol::state& L);
+	void init_native_binding_CLOCK(sol::state& L);
+	void init_native_binding_CUTSCENE(sol::state& L);
+	void init_native_binding_DATAFILE(sol::state& L);
+	void init_native_binding_DECORATOR(sol::state& L);
+	void init_native_binding_DLC(sol::state& L);
+	void init_native_binding_ENTITY(sol::state& L);
+	void init_native_binding_EVENT(sol::state& L);
+	void init_native_binding_FILES(sol::state& L);
+	void init_native_binding_FIRE(sol::state& L);
+	void init_native_binding_GRAPHICS(sol::state& L);
+	void init_native_binding_HUD(sol::state& L);
+	void init_native_binding_INTERIOR(sol::state& L);
+	void init_native_binding_ITEMSET(sol::state& L);
+	void init_native_binding_LOADINGSCREEN(sol::state& L);
+	void init_native_binding_LOCALIZATION(sol::state& L);
+	void init_native_binding_MISC(sol::state& L);
+	void init_native_binding_MOBILE(sol::state& L);
+	void init_native_binding_MONEY(sol::state& L);
+	void init_native_binding_NETSHOPPING(sol::state& L);
+	void init_native_binding_NETWORK(sol::state& L);
+	void init_native_binding_OBJECT(sol::state& L);
+	void init_native_binding_PAD(sol::state& L);
+	void init_native_binding_PATHFIND(sol::state& L);
+	void init_native_binding_PED(sol::state& L);
+	void init_native_binding_PHYSICS(sol::state& L);
+	void init_native_binding_PLAYER(sol::state& L);
+	void init_native_binding_RECORDING(sol::state& L);
+	void init_native_binding_REPLAY(sol::state& L);
+	void init_native_binding_SAVEMIGRATION(sol::state& L);
+	void init_native_binding_SCRIPT(sol::state& L);
+	void init_native_binding_SECURITY(sol::state& L);
+	void init_native_binding_SHAPETEST(sol::state& L);
+	void init_native_binding_SOCIALCLUB(sol::state& L);
+	void init_native_binding_STATS(sol::state& L);
+	void init_native_binding_STREAMING(sol::state& L);
+	void init_native_binding_TASK(sol::state& L);
+	void init_native_binding_VEHICLE(sol::state& L);
+	void init_native_binding_WATER(sol::state& L);
+	void init_native_binding_WEAPON(sol::state& L);
+	void init_native_binding_ZONE(sol::state& L);
 }

src/lua/natives/lua_native_binding_APP.cpp

@@ -0,0 +1,120 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static bool LUA_NATIVE_APP_APP_DATA_VALID(  )
+	{
+		auto retval = (bool)APP::APP_DATA_VALID();
+		return retval;
+	}
+
+	static int LUA_NATIVE_APP_APP_GET_INT( const char* property )
+	{
+		auto retval = APP::APP_GET_INT(property);
+		return retval;
+	}
+
+	static float LUA_NATIVE_APP_APP_GET_FLOAT( const char* property )
+	{
+		auto retval = APP::APP_GET_FLOAT(property);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_APP_APP_GET_STRING( const char* property )
+	{
+		auto retval = APP::APP_GET_STRING(property);
+		return retval;
+	}
+
+	static void LUA_NATIVE_APP_APP_SET_INT( const char* property, int value )
+	{
+		APP::APP_SET_INT(property, value);
+	}
+
+	static void LUA_NATIVE_APP_APP_SET_FLOAT( const char* property, float value )
+	{
+		APP::APP_SET_FLOAT(property, value);
+	}
+
+	static void LUA_NATIVE_APP_APP_SET_STRING( const char* property, const char* value )
+	{
+		APP::APP_SET_STRING(property, value);
+	}
+
+	static void LUA_NATIVE_APP_APP_SET_APP( const char* appName )
+	{
+		APP::APP_SET_APP(appName);
+	}
+
+	static void LUA_NATIVE_APP_APP_SET_BLOCK( const char* blockName )
+	{
+		APP::APP_SET_BLOCK(blockName);
+	}
+
+	static void LUA_NATIVE_APP_APP_CLEAR_BLOCK(  )
+	{
+		APP::APP_CLEAR_BLOCK();
+	}
+
+	static void LUA_NATIVE_APP_APP_CLOSE_APP(  )
+	{
+		APP::APP_CLOSE_APP();
+	}
+
+	static void LUA_NATIVE_APP_APP_CLOSE_BLOCK(  )
+	{
+		APP::APP_CLOSE_BLOCK();
+	}
+
+	static bool LUA_NATIVE_APP_APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT(  )
+	{
+		auto retval = (bool)APP::APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_APP_APP_HAS_SYNCED_DATA( const char* appName )
+	{
+		auto retval = (bool)APP::APP_HAS_SYNCED_DATA(appName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_APP_APP_SAVE_DATA(  )
+	{
+		APP::APP_SAVE_DATA();
+	}
+
+	static int LUA_NATIVE_APP_APP_GET_DELETED_FILE_STATUS(  )
+	{
+		auto retval = APP::APP_GET_DELETED_FILE_STATUS();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_APP_APP_DELETE_APP_DATA( const char* appName )
+	{
+		auto retval = (bool)APP::APP_DELETE_APP_DATA(appName);
+		return retval;
+	}
+
+	void init_native_binding_APP(sol::state& L)
+	{
+		auto APP = L["APP"].get_or_create<sol::table>();
+		APP.set_function("APP_DATA_VALID", LUA_NATIVE_APP_APP_DATA_VALID);
+		APP.set_function("APP_GET_INT", LUA_NATIVE_APP_APP_GET_INT);
+		APP.set_function("APP_GET_FLOAT", LUA_NATIVE_APP_APP_GET_FLOAT);
+		APP.set_function("APP_GET_STRING", LUA_NATIVE_APP_APP_GET_STRING);
+		APP.set_function("APP_SET_INT", LUA_NATIVE_APP_APP_SET_INT);
+		APP.set_function("APP_SET_FLOAT", LUA_NATIVE_APP_APP_SET_FLOAT);
+		APP.set_function("APP_SET_STRING", LUA_NATIVE_APP_APP_SET_STRING);
+		APP.set_function("APP_SET_APP", LUA_NATIVE_APP_APP_SET_APP);
+		APP.set_function("APP_SET_BLOCK", LUA_NATIVE_APP_APP_SET_BLOCK);
+		APP.set_function("APP_CLEAR_BLOCK", LUA_NATIVE_APP_APP_CLEAR_BLOCK);
+		APP.set_function("APP_CLOSE_APP", LUA_NATIVE_APP_APP_CLOSE_APP);
+		APP.set_function("APP_CLOSE_BLOCK", LUA_NATIVE_APP_APP_CLOSE_BLOCK);
+		APP.set_function("APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT", LUA_NATIVE_APP_APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT);
+		APP.set_function("APP_HAS_SYNCED_DATA", LUA_NATIVE_APP_APP_HAS_SYNCED_DATA);
+		APP.set_function("APP_SAVE_DATA", LUA_NATIVE_APP_APP_SAVE_DATA);
+		APP.set_function("APP_GET_DELETED_FILE_STATUS", LUA_NATIVE_APP_APP_GET_DELETED_FILE_STATUS);
+		APP.set_function("APP_DELETE_APP_DATA", LUA_NATIVE_APP_APP_DELETE_APP_DATA);
+	}
+}

src/lua/natives/lua_native_binding_BRAIN.cpp

@@ -0,0 +1,78 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_BRAIN_ADD_SCRIPT_TO_RANDOM_PED( const char* name, Hash model, float p2, float p3 )
+	{
+		BRAIN::ADD_SCRIPT_TO_RANDOM_PED(name, model, p2, p3);
+	}
+
+	static void LUA_NATIVE_BRAIN_REGISTER_OBJECT_SCRIPT_BRAIN( const char* scriptName, Hash modelHash, int p2, float activationRange, int p4, int p5 )
+	{
+		BRAIN::REGISTER_OBJECT_SCRIPT_BRAIN(scriptName, modelHash, p2, activationRange, p4, p5);
+	}
+
+	static bool LUA_NATIVE_BRAIN_IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE( Object object )
+	{
+		auto retval = (bool)BRAIN::IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE(object);
+		return retval;
+	}
+
+	static void LUA_NATIVE_BRAIN_REGISTER_WORLD_POINT_SCRIPT_BRAIN( const char* scriptName, float activationRange, int p2 )
+	{
+		BRAIN::REGISTER_WORLD_POINT_SCRIPT_BRAIN(scriptName, activationRange, p2);
+	}
+
+	static bool LUA_NATIVE_BRAIN_IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE(  )
+	{
+		auto retval = (bool)BRAIN::IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_BRAIN_ENABLE_SCRIPT_BRAIN_SET( int brainSet )
+	{
+		BRAIN::ENABLE_SCRIPT_BRAIN_SET(brainSet);
+	}
+
+	static void LUA_NATIVE_BRAIN_DISABLE_SCRIPT_BRAIN_SET( int brainSet )
+	{
+		BRAIN::DISABLE_SCRIPT_BRAIN_SET(brainSet);
+	}
+
+	static void LUA_NATIVE_BRAIN_REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE(  )
+	{
+		BRAIN::REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE();
+	}
+
+	static void LUA_NATIVE_BRAIN_REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE(  )
+	{
+		BRAIN::REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE();
+	}
+
+	static void LUA_NATIVE_BRAIN_REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE( const char* scriptName )
+	{
+		BRAIN::REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE(scriptName);
+	}
+
+	static void LUA_NATIVE_BRAIN_REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE( const char* scriptName )
+	{
+		BRAIN::REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE(scriptName);
+	}
+
+	void init_native_binding_BRAIN(sol::state& L)
+	{
+		auto BRAIN = L["BRAIN"].get_or_create<sol::table>();
+		BRAIN.set_function("ADD_SCRIPT_TO_RANDOM_PED", LUA_NATIVE_BRAIN_ADD_SCRIPT_TO_RANDOM_PED);
+		BRAIN.set_function("REGISTER_OBJECT_SCRIPT_BRAIN", LUA_NATIVE_BRAIN_REGISTER_OBJECT_SCRIPT_BRAIN);
+		BRAIN.set_function("IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE", LUA_NATIVE_BRAIN_IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE);
+		BRAIN.set_function("REGISTER_WORLD_POINT_SCRIPT_BRAIN", LUA_NATIVE_BRAIN_REGISTER_WORLD_POINT_SCRIPT_BRAIN);
+		BRAIN.set_function("IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE", LUA_NATIVE_BRAIN_IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE);
+		BRAIN.set_function("ENABLE_SCRIPT_BRAIN_SET", LUA_NATIVE_BRAIN_ENABLE_SCRIPT_BRAIN_SET);
+		BRAIN.set_function("DISABLE_SCRIPT_BRAIN_SET", LUA_NATIVE_BRAIN_DISABLE_SCRIPT_BRAIN_SET);
+		BRAIN.set_function("REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE", LUA_NATIVE_BRAIN_REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE);
+		BRAIN.set_function("REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE", LUA_NATIVE_BRAIN_REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE);
+		BRAIN.set_function("REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE", LUA_NATIVE_BRAIN_REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE);
+		BRAIN.set_function("REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE", LUA_NATIVE_BRAIN_REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE);
+	}
+}

src/lua/natives/lua_native_binding_CLOCK.cpp

@@ -0,0 +1,141 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_CLOCK_SET_CLOCK_TIME( int hour, int minute, int second )
+	{
+		CLOCK::SET_CLOCK_TIME(hour, minute, second);
+	}
+
+	static void LUA_NATIVE_CLOCK_PAUSE_CLOCK( bool toggle )
+	{
+		CLOCK::PAUSE_CLOCK(toggle);
+	}
+
+	static void LUA_NATIVE_CLOCK_ADVANCE_CLOCK_TIME_TO( int hour, int minute, int second )
+	{
+		CLOCK::ADVANCE_CLOCK_TIME_TO(hour, minute, second);
+	}
+
+	static void LUA_NATIVE_CLOCK_ADD_TO_CLOCK_TIME( int hours, int minutes, int seconds )
+	{
+		CLOCK::ADD_TO_CLOCK_TIME(hours, minutes, seconds);
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_HOURS(  )
+	{
+		auto retval = CLOCK::GET_CLOCK_HOURS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_MINUTES(  )
+	{
+		auto retval = CLOCK::GET_CLOCK_MINUTES();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_SECONDS(  )
+	{
+		auto retval = CLOCK::GET_CLOCK_SECONDS();
+		return retval;
+	}
+
+	static void LUA_NATIVE_CLOCK_SET_CLOCK_DATE( int day, int month, int year )
+	{
+		CLOCK::SET_CLOCK_DATE(day, month, year);
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_WEEK(  )
+	{
+		auto retval = CLOCK::GET_CLOCK_DAY_OF_WEEK();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_MONTH(  )
+	{
+		auto retval = CLOCK::GET_CLOCK_DAY_OF_MONTH();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_MONTH(  )
+	{
+		auto retval = CLOCK::GET_CLOCK_MONTH();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_YEAR(  )
+	{
+		auto retval = CLOCK::GET_CLOCK_YEAR();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CLOCK_GET_MILLISECONDS_PER_GAME_MINUTE(  )
+	{
+		auto retval = CLOCK::GET_MILLISECONDS_PER_GAME_MINUTE();
+		return retval;
+	}
+
+	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_POSIX_TIME( int year, int month, int day, int hour, int minute, int second )
+	{
+		std::tuple<int, int, int, int, int, int> return_values;
+		CLOCK::GET_POSIX_TIME(&year, &month, &day, &hour, &minute, &second);
+		std::get<0>(return_values) = year;
+		std::get<1>(return_values) = month;
+		std::get<2>(return_values) = day;
+		std::get<3>(return_values) = hour;
+		std::get<4>(return_values) = minute;
+		std::get<5>(return_values) = second;
+
+		return return_values;
+	}
+
+	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_UTC_TIME( int year, int month, int day, int hour, int minute, int second )
+	{
+		std::tuple<int, int, int, int, int, int> return_values;
+		CLOCK::GET_UTC_TIME(&year, &month, &day, &hour, &minute, &second);
+		std::get<0>(return_values) = year;
+		std::get<1>(return_values) = month;
+		std::get<2>(return_values) = day;
+		std::get<3>(return_values) = hour;
+		std::get<4>(return_values) = minute;
+		std::get<5>(return_values) = second;
+
+		return return_values;
+	}
+
+	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_LOCAL_TIME( int year, int month, int day, int hour, int minute, int second )
+	{
+		std::tuple<int, int, int, int, int, int> return_values;
+		CLOCK::GET_LOCAL_TIME(&year, &month, &day, &hour, &minute, &second);
+		std::get<0>(return_values) = year;
+		std::get<1>(return_values) = month;
+		std::get<2>(return_values) = day;
+		std::get<3>(return_values) = hour;
+		std::get<4>(return_values) = minute;
+		std::get<5>(return_values) = second;
+
+		return return_values;
+	}
+
+	void init_native_binding_CLOCK(sol::state& L)
+	{
+		auto CLOCK = L["CLOCK"].get_or_create<sol::table>();
+		CLOCK.set_function("SET_CLOCK_TIME", LUA_NATIVE_CLOCK_SET_CLOCK_TIME);
+		CLOCK.set_function("PAUSE_CLOCK", LUA_NATIVE_CLOCK_PAUSE_CLOCK);
+		CLOCK.set_function("ADVANCE_CLOCK_TIME_TO", LUA_NATIVE_CLOCK_ADVANCE_CLOCK_TIME_TO);
+		CLOCK.set_function("ADD_TO_CLOCK_TIME", LUA_NATIVE_CLOCK_ADD_TO_CLOCK_TIME);
+		CLOCK.set_function("GET_CLOCK_HOURS", LUA_NATIVE_CLOCK_GET_CLOCK_HOURS);
+		CLOCK.set_function("GET_CLOCK_MINUTES", LUA_NATIVE_CLOCK_GET_CLOCK_MINUTES);
+		CLOCK.set_function("GET_CLOCK_SECONDS", LUA_NATIVE_CLOCK_GET_CLOCK_SECONDS);
+		CLOCK.set_function("SET_CLOCK_DATE", LUA_NATIVE_CLOCK_SET_CLOCK_DATE);
+		CLOCK.set_function("GET_CLOCK_DAY_OF_WEEK", LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_WEEK);
+		CLOCK.set_function("GET_CLOCK_DAY_OF_MONTH", LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_MONTH);
+		CLOCK.set_function("GET_CLOCK_MONTH", LUA_NATIVE_CLOCK_GET_CLOCK_MONTH);
+		CLOCK.set_function("GET_CLOCK_YEAR", LUA_NATIVE_CLOCK_GET_CLOCK_YEAR);
+		CLOCK.set_function("GET_MILLISECONDS_PER_GAME_MINUTE", LUA_NATIVE_CLOCK_GET_MILLISECONDS_PER_GAME_MINUTE);
+		CLOCK.set_function("GET_POSIX_TIME", LUA_NATIVE_CLOCK_GET_POSIX_TIME);
+		CLOCK.set_function("GET_UTC_TIME", LUA_NATIVE_CLOCK_GET_UTC_TIME);
+		CLOCK.set_function("GET_LOCAL_TIME", LUA_NATIVE_CLOCK_GET_LOCAL_TIME);
+	}
+}

src/lua/natives/lua_native_binding_CUTSCENE.cpp

@@ -0,0 +1,361 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE( const char* cutsceneName, int flags )
+	{
+		CUTSCENE::REQUEST_CUTSCENE(cutsceneName, flags);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE_WITH_PLAYBACK_LIST( const char* cutsceneName, int playbackFlags, int flags )
+	{
+		CUTSCENE::REQUEST_CUTSCENE_WITH_PLAYBACK_LIST(cutsceneName, playbackFlags, flags);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_REMOVE_CUTSCENE(  )
+	{
+		CUTSCENE::REMOVE_CUTSCENE();
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_LOADED(  )
+	{
+		auto retval = (bool)CUTSCENE::HAS_CUTSCENE_LOADED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_HAS_THIS_CUTSCENE_LOADED( const char* cutsceneName )
+	{
+		auto retval = (bool)CUTSCENE::HAS_THIS_CUTSCENE_LOADED(cutsceneName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_SCRIPT_CAN_START_CUTSCENE( int threadId )
+	{
+		CUTSCENE::SET_SCRIPT_CAN_START_CUTSCENE(threadId);
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY(  )
+	{
+		auto retval = (bool)CUTSCENE::CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYBACK_FLAG_SET( int flag )
+	{
+		auto retval = (bool)CUTSCENE::IS_CUTSCENE_PLAYBACK_FLAG_SET(flag);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ENTITY_STREAMING_FLAGS( const char* cutsceneEntName, int p1, int p2 )
+	{
+		CUTSCENE::SET_CUTSCENE_ENTITY_STREAMING_FLAGS(cutsceneEntName, p1, p2);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_REQUEST_CUT_FILE( const char* cutsceneName )
+	{
+		CUTSCENE::REQUEST_CUT_FILE(cutsceneName);
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUT_FILE_LOADED( const char* cutsceneName )
+	{
+		auto retval = (bool)CUTSCENE::HAS_CUT_FILE_LOADED(cutsceneName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_REMOVE_CUT_FILE( const char* cutsceneName )
+	{
+		CUTSCENE::REMOVE_CUT_FILE(cutsceneName);
+	}
+
+	static int LUA_NATIVE_CUTSCENE_GET_CUT_FILE_CONCAT_COUNT( const char* cutsceneName )
+	{
+		auto retval = CUTSCENE::GET_CUT_FILE_CONCAT_COUNT(cutsceneName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_START_CUTSCENE( int flags )
+	{
+		CUTSCENE::START_CUTSCENE(flags);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_START_CUTSCENE_AT_COORDS( float x, float y, float z, int flags )
+	{
+		CUTSCENE::START_CUTSCENE_AT_COORDS(x, y, z, flags);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_STOP_CUTSCENE( bool p0 )
+	{
+		CUTSCENE::STOP_CUTSCENE(p0);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_STOP_CUTSCENE_IMMEDIATELY(  )
+	{
+		CUTSCENE::STOP_CUTSCENE_IMMEDIATELY();
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN( float x, float y, float z, float p3, int p4 )
+	{
+		CUTSCENE::SET_CUTSCENE_ORIGIN(x, y, z, p3, p4);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN_AND_ORIENTATION( float x1, float y1, float z1, float x2, float y2, float z2, int p6 )
+	{
+		CUTSCENE::SET_CUTSCENE_ORIGIN_AND_ORIENTATION(x1, y1, z1, x2, y2, z2, p6);
+	}
+
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TIME(  )
+	{
+		auto retval = CUTSCENE::GET_CUTSCENE_TIME();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TOTAL_DURATION(  )
+	{
+		auto retval = CUTSCENE::GET_CUTSCENE_TOTAL_DURATION();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_END_TIME(  )
+	{
+		auto retval = CUTSCENE::GET_CUTSCENE_END_TIME();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_PLAY_DURATION(  )
+	{
+		auto retval = CUTSCENE::GET_CUTSCENE_PLAY_DURATION();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_WAS_CUTSCENE_SKIPPED(  )
+	{
+		auto retval = (bool)CUTSCENE::WAS_CUTSCENE_SKIPPED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_FINISHED(  )
+	{
+		auto retval = (bool)CUTSCENE::HAS_CUTSCENE_FINISHED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_ACTIVE(  )
+	{
+		auto retval = (bool)CUTSCENE::IS_CUTSCENE_ACTIVE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYING(  )
+	{
+		auto retval = (bool)CUTSCENE::IS_CUTSCENE_PLAYING();
+		return retval;
+	}
+
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_SECTION_PLAYING(  )
+	{
+		auto retval = CUTSCENE::GET_CUTSCENE_SECTION_PLAYING();
+		return retval;
+	}
+
+	static Entity LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	{
+		auto retval = CUTSCENE::GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY(cutsceneEntName, modelHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_CONCAT_SECTION_PLAYING(  )
+	{
+		auto retval = CUTSCENE::GET_CUTSCENE_CONCAT_SECTION_PLAYING();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_AUTHORIZED( const char* cutsceneName )
+	{
+		auto retval = (bool)CUTSCENE::IS_CUTSCENE_AUTHORIZED(cutsceneName);
+		return retval;
+	}
+
+	static int LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_HANDLE_EXIST( int cutsceneHandle )
+	{
+		auto retval = CUTSCENE::DOES_CUTSCENE_HANDLE_EXIST(cutsceneHandle);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_REGISTER_ENTITY_FOR_CUTSCENE( Ped cutscenePed, const char* cutsceneEntName, int p2, Hash modelHash, int p4 )
+	{
+		CUTSCENE::REGISTER_ENTITY_FOR_CUTSCENE(cutscenePed, cutsceneEntName, p2, modelHash, p4);
+	}
+
+	static Entity LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_REGISTERED_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	{
+		auto retval = CUTSCENE::GET_ENTITY_INDEX_OF_REGISTERED_ENTITY(cutsceneEntName, modelHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE( Hash modelHash )
+	{
+		CUTSCENE::SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE(modelHash);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_TRIGGER_AREA( float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		CUTSCENE::SET_CUTSCENE_TRIGGER_AREA(x1, y1, z1, x2, y2, z2);
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	{
+		auto retval = (bool)CUTSCENE::CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY(cutsceneEntName, modelHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	{
+		auto retval = (bool)CUTSCENE::CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(cutsceneEntName, modelHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_CAMERA( bool p0 )
+	{
+		auto retval = (bool)CUTSCENE::CAN_SET_EXIT_STATE_FOR_CAMERA(p0);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_PAD_CAN_SHAKE_DURING_CUTSCENE( bool toggle )
+	{
+		CUTSCENE::SET_PAD_CAN_SHAKE_DURING_CUTSCENE(toggle);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_FADE_VALUES( bool p0, bool p1, bool p2, bool p3 )
+	{
+		CUTSCENE::SET_CUTSCENE_FADE_VALUES(p0, p1, p2, p3);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE( bool p0, bool p1, bool p2, bool p3 )
+	{
+		CUTSCENE::SET_CUTSCENE_MULTIHEAD_FADE(p0, p1, p2, p3);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE_MANUAL( bool p0 )
+	{
+		CUTSCENE::SET_CUTSCENE_MULTIHEAD_FADE_MANUAL(p0);
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_IS_MULTIHEAD_FADE_UP(  )
+	{
+		auto retval = (bool)CUTSCENE::IS_MULTIHEAD_FADE_UP();
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED( bool p0 )
+	{
+		CUTSCENE::NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED(p0);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE( bool p0 )
+	{
+		CUTSCENE::SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE(p0);
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_CAN_USE_MOBILE_PHONE_DURING_CUTSCENE(  )
+	{
+		auto retval = (bool)CUTSCENE::CAN_USE_MOBILE_PHONE_DURING_CUTSCENE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_CAN_BE_SKIPPED( bool p0 )
+	{
+		CUTSCENE::SET_CUTSCENE_CAN_BE_SKIPPED(p0);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE(  )
+	{
+		CUTSCENE::SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE();
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION( const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash )
+	{
+		CUTSCENE::SET_CUTSCENE_PED_COMPONENT_VARIATION(cutsceneEntName, componentId, drawableId, textureId, modelHash);
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED( const char* cutsceneEntName, Ped ped, Hash modelHash )
+	{
+		CUTSCENE::SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED(cutsceneEntName, ped, modelHash);
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_ENTITY_EXIST( const char* cutsceneEntName, Hash modelHash )
+	{
+		auto retval = (bool)CUTSCENE::DOES_CUTSCENE_ENTITY_EXIST(cutsceneEntName, modelHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_PROP_VARIATION( const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash )
+	{
+		CUTSCENE::SET_CUTSCENE_PED_PROP_VARIATION(cutsceneEntName, componentId, drawableId, textureId, modelHash);
+	}
+
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_CUT_THIS_FRAME(  )
+	{
+		auto retval = (bool)CUTSCENE::HAS_CUTSCENE_CUT_THIS_FRAME();
+		return retval;
+	}
+
+	void init_native_binding_CUTSCENE(sol::state& L)
+	{
+		auto CUTSCENE = L["CUTSCENE"].get_or_create<sol::table>();
+		CUTSCENE.set_function("REQUEST_CUTSCENE", LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE);
+		CUTSCENE.set_function("REQUEST_CUTSCENE_WITH_PLAYBACK_LIST", LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE_WITH_PLAYBACK_LIST);
+		CUTSCENE.set_function("REMOVE_CUTSCENE", LUA_NATIVE_CUTSCENE_REMOVE_CUTSCENE);
+		CUTSCENE.set_function("HAS_CUTSCENE_LOADED", LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_LOADED);
+		CUTSCENE.set_function("HAS_THIS_CUTSCENE_LOADED", LUA_NATIVE_CUTSCENE_HAS_THIS_CUTSCENE_LOADED);
+		CUTSCENE.set_function("SET_SCRIPT_CAN_START_CUTSCENE", LUA_NATIVE_CUTSCENE_SET_SCRIPT_CAN_START_CUTSCENE);
+		CUTSCENE.set_function("CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY", LUA_NATIVE_CUTSCENE_CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY);
+		CUTSCENE.set_function("IS_CUTSCENE_PLAYBACK_FLAG_SET", LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYBACK_FLAG_SET);
+		CUTSCENE.set_function("SET_CUTSCENE_ENTITY_STREAMING_FLAGS", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ENTITY_STREAMING_FLAGS);
+		CUTSCENE.set_function("REQUEST_CUT_FILE", LUA_NATIVE_CUTSCENE_REQUEST_CUT_FILE);
+		CUTSCENE.set_function("HAS_CUT_FILE_LOADED", LUA_NATIVE_CUTSCENE_HAS_CUT_FILE_LOADED);
+		CUTSCENE.set_function("REMOVE_CUT_FILE", LUA_NATIVE_CUTSCENE_REMOVE_CUT_FILE);
+		CUTSCENE.set_function("GET_CUT_FILE_CONCAT_COUNT", LUA_NATIVE_CUTSCENE_GET_CUT_FILE_CONCAT_COUNT);
+		CUTSCENE.set_function("START_CUTSCENE", LUA_NATIVE_CUTSCENE_START_CUTSCENE);
+		CUTSCENE.set_function("START_CUTSCENE_AT_COORDS", LUA_NATIVE_CUTSCENE_START_CUTSCENE_AT_COORDS);
+		CUTSCENE.set_function("STOP_CUTSCENE", LUA_NATIVE_CUTSCENE_STOP_CUTSCENE);
+		CUTSCENE.set_function("STOP_CUTSCENE_IMMEDIATELY", LUA_NATIVE_CUTSCENE_STOP_CUTSCENE_IMMEDIATELY);
+		CUTSCENE.set_function("SET_CUTSCENE_ORIGIN", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN);
+		CUTSCENE.set_function("SET_CUTSCENE_ORIGIN_AND_ORIENTATION", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN_AND_ORIENTATION);
+		CUTSCENE.set_function("GET_CUTSCENE_TIME", LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TIME);
+		CUTSCENE.set_function("GET_CUTSCENE_TOTAL_DURATION", LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TOTAL_DURATION);
+		CUTSCENE.set_function("GET_CUTSCENE_END_TIME", LUA_NATIVE_CUTSCENE_GET_CUTSCENE_END_TIME);
+		CUTSCENE.set_function("GET_CUTSCENE_PLAY_DURATION", LUA_NATIVE_CUTSCENE_GET_CUTSCENE_PLAY_DURATION);
+		CUTSCENE.set_function("WAS_CUTSCENE_SKIPPED", LUA_NATIVE_CUTSCENE_WAS_CUTSCENE_SKIPPED);
+		CUTSCENE.set_function("HAS_CUTSCENE_FINISHED", LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_FINISHED);
+		CUTSCENE.set_function("IS_CUTSCENE_ACTIVE", LUA_NATIVE_CUTSCENE_IS_CUTSCENE_ACTIVE);
+		CUTSCENE.set_function("IS_CUTSCENE_PLAYING", LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYING);
+		CUTSCENE.set_function("GET_CUTSCENE_SECTION_PLAYING", LUA_NATIVE_CUTSCENE_GET_CUTSCENE_SECTION_PLAYING);
+		CUTSCENE.set_function("GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY", LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY);
+		CUTSCENE.set_function("GET_CUTSCENE_CONCAT_SECTION_PLAYING", LUA_NATIVE_CUTSCENE_GET_CUTSCENE_CONCAT_SECTION_PLAYING);
+		CUTSCENE.set_function("IS_CUTSCENE_AUTHORIZED", LUA_NATIVE_CUTSCENE_IS_CUTSCENE_AUTHORIZED);
+		CUTSCENE.set_function("DOES_CUTSCENE_HANDLE_EXIST", LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_HANDLE_EXIST);
+		CUTSCENE.set_function("REGISTER_ENTITY_FOR_CUTSCENE", LUA_NATIVE_CUTSCENE_REGISTER_ENTITY_FOR_CUTSCENE);
+		CUTSCENE.set_function("GET_ENTITY_INDEX_OF_REGISTERED_ENTITY", LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_REGISTERED_ENTITY);
+		CUTSCENE.set_function("SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE", LUA_NATIVE_CUTSCENE_SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE);
+		CUTSCENE.set_function("SET_CUTSCENE_TRIGGER_AREA", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_TRIGGER_AREA);
+		CUTSCENE.set_function("CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY", LUA_NATIVE_CUTSCENE_CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY);
+		CUTSCENE.set_function("CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY", LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY);
+		CUTSCENE.set_function("CAN_SET_EXIT_STATE_FOR_CAMERA", LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_CAMERA);
+		CUTSCENE.set_function("SET_PAD_CAN_SHAKE_DURING_CUTSCENE", LUA_NATIVE_CUTSCENE_SET_PAD_CAN_SHAKE_DURING_CUTSCENE);
+		CUTSCENE.set_function("SET_CUTSCENE_FADE_VALUES", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_FADE_VALUES);
+		CUTSCENE.set_function("SET_CUTSCENE_MULTIHEAD_FADE", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE);
+		CUTSCENE.set_function("SET_CUTSCENE_MULTIHEAD_FADE_MANUAL", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE_MANUAL);
+		CUTSCENE.set_function("IS_MULTIHEAD_FADE_UP", LUA_NATIVE_CUTSCENE_IS_MULTIHEAD_FADE_UP);
+		CUTSCENE.set_function("NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED", LUA_NATIVE_CUTSCENE_NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED);
+		CUTSCENE.set_function("SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE", LUA_NATIVE_CUTSCENE_SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE);
+		CUTSCENE.set_function("CAN_USE_MOBILE_PHONE_DURING_CUTSCENE", LUA_NATIVE_CUTSCENE_CAN_USE_MOBILE_PHONE_DURING_CUTSCENE);
+		CUTSCENE.set_function("SET_CUTSCENE_CAN_BE_SKIPPED", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_CAN_BE_SKIPPED);
+		CUTSCENE.set_function("SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE", LUA_NATIVE_CUTSCENE_SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE);
+		CUTSCENE.set_function("SET_CUTSCENE_PED_COMPONENT_VARIATION", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION);
+		CUTSCENE.set_function("SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED);
+		CUTSCENE.set_function("DOES_CUTSCENE_ENTITY_EXIST", LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_ENTITY_EXIST);
+		CUTSCENE.set_function("SET_CUTSCENE_PED_PROP_VARIATION", LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_PROP_VARIATION);
+		CUTSCENE.set_function("HAS_CUTSCENE_CUT_THIS_FRAME", LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_CUT_THIS_FRAME);
+	}
+}

src/lua/natives/lua_native_binding_DATAFILE.cpp

@@ -0,0 +1,468 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_DATAFILE_DATAFILE_WATCH_REQUEST_ID( int requestId )
+	{
+		DATAFILE::DATAFILE_WATCH_REQUEST_ID(requestId);
+	}
+
+	static void LUA_NATIVE_DATAFILE_DATAFILE_CLEAR_WATCH_LIST(  )
+	{
+		DATAFILE::DATAFILE_CLEAR_WATCH_LIST();
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_IS_VALID_REQUEST_ID( int index )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_IS_VALID_REQUEST_ID(index);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_HAS_LOADED_FILE_DATA( int requestId )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_HAS_LOADED_FILE_DATA(requestId);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_HAS_VALID_FILE_DATA( int requestId )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_HAS_VALID_FILE_DATA(requestId);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_ACTIVE_FILE( int requestId, Any p1 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_SELECT_ACTIVE_FILE(requestId, p1);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_DELETE_REQUESTED_FILE( int requestId )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_DELETE_REQUESTED_FILE(requestId);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_UGC_CREATE_CONTENT( Any data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, bool publish, Any p7 )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)DATAFILE::UGC_CREATE_CONTENT(&data, dataCount, contentName, description, tagsCsv, contentTypeName, publish, p7);
+		std::get<1>(return_values) = data;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_UGC_CREATE_MISSION( const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, bool publish, Any p5 )
+	{
+		auto retval = (bool)DATAFILE::UGC_CREATE_MISSION(contentName, description, tagsCsv, contentTypeName, publish, p5);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_UGC_UPDATE_CONTENT( const char* contentId, Any data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p7 )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)DATAFILE::UGC_UPDATE_CONTENT(contentId, &data, dataCount, contentName, description, tagsCsv, contentTypeName, p7);
+		std::get<1>(return_values) = data;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_UGC_UPDATE_MISSION( const char* contentId, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p5 )
+	{
+		auto retval = (bool)DATAFILE::UGC_UPDATE_MISSION(contentId, contentName, description, tagsCsv, contentTypeName, p5);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_UGC_SET_PLAYER_DATA( const char* contentId, float rating, const char* contentTypeName, Any p3 )
+	{
+		auto retval = (bool)DATAFILE::UGC_SET_PLAYER_DATA(contentId, rating, contentTypeName, p3);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_DATA( int p0, Any p1 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_SELECT_UGC_DATA(p0, p1);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_STATS( int p0, bool p1, Any p2 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_SELECT_UGC_STATS(p0, p1, p2);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_PLAYER_DATA( int p0, Any p1 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_SELECT_UGC_PLAYER_DATA(p0, p1);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_CREATOR_STATS( int p0, Any p1 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_SELECT_CREATOR_STATS(p0, p1);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC( const char* filename, Any p1 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_LOAD_OFFLINE_UGC(filename, p1);
+		return retval;
+	}
+
+	static void LUA_NATIVE_DATAFILE_DATAFILE_CREATE( int p0 )
+	{
+		DATAFILE::DATAFILE_CREATE(p0);
+	}
+
+	static void LUA_NATIVE_DATAFILE_DATAFILE_DELETE( int p0 )
+	{
+		DATAFILE::DATAFILE_DELETE(p0);
+	}
+
+	static void LUA_NATIVE_DATAFILE_DATAFILE_STORE_MISSION_HEADER( int p0 )
+	{
+		DATAFILE::DATAFILE_STORE_MISSION_HEADER(p0);
+	}
+
+	static void LUA_NATIVE_DATAFILE_DATAFILE_FLUSH_MISSION_HEADER(  )
+	{
+		DATAFILE::DATAFILE_FLUSH_MISSION_HEADER();
+	}
+
+	static Any* LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT( int p0 )
+	{
+		auto retval = DATAFILE::DATAFILE_GET_FILE_DICT(p0);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_START_SAVE_TO_CLOUD( const char* filename, Any p1 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_START_SAVE_TO_CLOUD(filename, p1);
+		return retval;
+	}
+
+	static std::tuple<bool, bool> LUA_NATIVE_DATAFILE_DATAFILE_UPDATE_SAVE_TO_CLOUD( bool p0 )
+	{
+		std::tuple<bool, bool> return_values;
+		std::get<0>(return_values) = (bool)DATAFILE::DATAFILE_UPDATE_SAVE_TO_CLOUD((BOOL*)&p0);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_IS_SAVE_PENDING(  )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_IS_SAVE_PENDING();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE( Any p0, Any p1 )
+	{
+		auto retval = (bool)DATAFILE::DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE(p0, p1);
+		return retval;
+	}
+
+	static void LUA_NATIVE_DATAFILE_DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE( Any p0 )
+	{
+		DATAFILE::DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE(p0);
+	}
+
+	static Any* LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE( Any p0 )
+	{
+		auto retval = DATAFILE::DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE(p0);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_BOOL( Any objectData, const char* key, bool value )
+	{
+		DATAFILE::DATADICT_SET_BOOL(&objectData, key, value);
+		return objectData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_INT( Any objectData, const char* key, int value )
+	{
+		DATAFILE::DATADICT_SET_INT(&objectData, key, value);
+		return objectData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_FLOAT( Any objectData, const char* key, float value )
+	{
+		DATAFILE::DATADICT_SET_FLOAT(&objectData, key, value);
+		return objectData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_STRING( Any objectData, const char* key, const char* value )
+	{
+		DATAFILE::DATADICT_SET_STRING(&objectData, key, value);
+		return objectData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_VECTOR( Any objectData, const char* key, float valueX, float valueY, float valueZ )
+	{
+		DATAFILE::DATADICT_SET_VECTOR(&objectData, key, valueX, valueY, valueZ);
+		return objectData;
+	}
+
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_CREATE_DICT( Any objectData, const char* key )
+	{
+		std::tuple<Any*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_CREATE_DICT(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_CREATE_ARRAY( Any objectData, const char* key )
+	{
+		std::tuple<Any*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_CREATE_ARRAY(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_BOOL( Any objectData, const char* key )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)DATAFILE::DATADICT_GET_BOOL(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_INT( Any objectData, const char* key )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_GET_INT(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<float, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_FLOAT( Any objectData, const char* key )
+	{
+		std::tuple<float, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_GET_FLOAT(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<const char*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_STRING( Any objectData, const char* key )
+	{
+		std::tuple<const char*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_GET_STRING(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<Vector3, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_VECTOR( Any objectData, const char* key )
+	{
+		std::tuple<Vector3, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_GET_VECTOR(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_DICT( Any objectData, const char* key )
+	{
+		std::tuple<Any*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_GET_DICT(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_ARRAY( Any objectData, const char* key )
+	{
+		std::tuple<Any*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_GET_ARRAY(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_TYPE( Any objectData, const char* key )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATADICT_GET_TYPE(&objectData, key);
+		std::get<1>(return_values) = objectData;
+
+		return return_values;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_BOOL( Any arrayData, bool value )
+	{
+		DATAFILE::DATAARRAY_ADD_BOOL(&arrayData, value);
+		return arrayData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_INT( Any arrayData, int value )
+	{
+		DATAFILE::DATAARRAY_ADD_INT(&arrayData, value);
+		return arrayData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_FLOAT( Any arrayData, float value )
+	{
+		DATAFILE::DATAARRAY_ADD_FLOAT(&arrayData, value);
+		return arrayData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_STRING( Any arrayData, const char* value )
+	{
+		DATAFILE::DATAARRAY_ADD_STRING(&arrayData, value);
+		return arrayData;
+	}
+
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_VECTOR( Any arrayData, float valueX, float valueY, float valueZ )
+	{
+		DATAFILE::DATAARRAY_ADD_VECTOR(&arrayData, valueX, valueY, valueZ);
+		return arrayData;
+	}
+
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_ADD_DICT( Any arrayData )
+	{
+		std::tuple<Any*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_ADD_DICT(&arrayData);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_BOOL( Any arrayData, int arrayIndex )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)DATAFILE::DATAARRAY_GET_BOOL(&arrayData, arrayIndex);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_INT( Any arrayData, int arrayIndex )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_INT(&arrayData, arrayIndex);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<float, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_FLOAT( Any arrayData, int arrayIndex )
+	{
+		std::tuple<float, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_FLOAT(&arrayData, arrayIndex);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<const char*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_STRING( Any arrayData, int arrayIndex )
+	{
+		std::tuple<const char*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_STRING(&arrayData, arrayIndex);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<Vector3, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_VECTOR( Any arrayData, int arrayIndex )
+	{
+		std::tuple<Vector3, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_VECTOR(&arrayData, arrayIndex);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_DICT( Any arrayData, int arrayIndex )
+	{
+		std::tuple<Any*, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_DICT(&arrayData, arrayIndex);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_COUNT( Any arrayData )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_COUNT(&arrayData);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_TYPE( Any arrayData, int arrayIndex )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_TYPE(&arrayData, arrayIndex);
+		std::get<1>(return_values) = arrayData;
+
+		return return_values;
+	}
+
+	void init_native_binding_DATAFILE(sol::state& L)
+	{
+		auto DATAFILE = L["DATAFILE"].get_or_create<sol::table>();
+		DATAFILE.set_function("DATAFILE_WATCH_REQUEST_ID", LUA_NATIVE_DATAFILE_DATAFILE_WATCH_REQUEST_ID);
+		DATAFILE.set_function("DATAFILE_CLEAR_WATCH_LIST", LUA_NATIVE_DATAFILE_DATAFILE_CLEAR_WATCH_LIST);
+		DATAFILE.set_function("DATAFILE_IS_VALID_REQUEST_ID", LUA_NATIVE_DATAFILE_DATAFILE_IS_VALID_REQUEST_ID);
+		DATAFILE.set_function("DATAFILE_HAS_LOADED_FILE_DATA", LUA_NATIVE_DATAFILE_DATAFILE_HAS_LOADED_FILE_DATA);
+		DATAFILE.set_function("DATAFILE_HAS_VALID_FILE_DATA", LUA_NATIVE_DATAFILE_DATAFILE_HAS_VALID_FILE_DATA);
+		DATAFILE.set_function("DATAFILE_SELECT_ACTIVE_FILE", LUA_NATIVE_DATAFILE_DATAFILE_SELECT_ACTIVE_FILE);
+		DATAFILE.set_function("DATAFILE_DELETE_REQUESTED_FILE", LUA_NATIVE_DATAFILE_DATAFILE_DELETE_REQUESTED_FILE);
+		DATAFILE.set_function("UGC_CREATE_CONTENT", LUA_NATIVE_DATAFILE_UGC_CREATE_CONTENT);
+		DATAFILE.set_function("UGC_CREATE_MISSION", LUA_NATIVE_DATAFILE_UGC_CREATE_MISSION);
+		DATAFILE.set_function("UGC_UPDATE_CONTENT", LUA_NATIVE_DATAFILE_UGC_UPDATE_CONTENT);
+		DATAFILE.set_function("UGC_UPDATE_MISSION", LUA_NATIVE_DATAFILE_UGC_UPDATE_MISSION);
+		DATAFILE.set_function("UGC_SET_PLAYER_DATA", LUA_NATIVE_DATAFILE_UGC_SET_PLAYER_DATA);
+		DATAFILE.set_function("DATAFILE_SELECT_UGC_DATA", LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_DATA);
+		DATAFILE.set_function("DATAFILE_SELECT_UGC_STATS", LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_STATS);
+		DATAFILE.set_function("DATAFILE_SELECT_UGC_PLAYER_DATA", LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_PLAYER_DATA);
+		DATAFILE.set_function("DATAFILE_SELECT_CREATOR_STATS", LUA_NATIVE_DATAFILE_DATAFILE_SELECT_CREATOR_STATS);
+		DATAFILE.set_function("DATAFILE_LOAD_OFFLINE_UGC", LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC);
+		DATAFILE.set_function("DATAFILE_CREATE", LUA_NATIVE_DATAFILE_DATAFILE_CREATE);
+		DATAFILE.set_function("DATAFILE_DELETE", LUA_NATIVE_DATAFILE_DATAFILE_DELETE);
+		DATAFILE.set_function("DATAFILE_STORE_MISSION_HEADER", LUA_NATIVE_DATAFILE_DATAFILE_STORE_MISSION_HEADER);
+		DATAFILE.set_function("DATAFILE_FLUSH_MISSION_HEADER", LUA_NATIVE_DATAFILE_DATAFILE_FLUSH_MISSION_HEADER);
+		DATAFILE.set_function("DATAFILE_GET_FILE_DICT", LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT);
+		DATAFILE.set_function("DATAFILE_START_SAVE_TO_CLOUD", LUA_NATIVE_DATAFILE_DATAFILE_START_SAVE_TO_CLOUD);
+		DATAFILE.set_function("DATAFILE_UPDATE_SAVE_TO_CLOUD", LUA_NATIVE_DATAFILE_DATAFILE_UPDATE_SAVE_TO_CLOUD);
+		DATAFILE.set_function("DATAFILE_IS_SAVE_PENDING", LUA_NATIVE_DATAFILE_DATAFILE_IS_SAVE_PENDING);
+		DATAFILE.set_function("DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE", LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE);
+		DATAFILE.set_function("DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE", LUA_NATIVE_DATAFILE_DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE);
+		DATAFILE.set_function("DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE", LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE);
+		DATAFILE.set_function("DATADICT_SET_BOOL", LUA_NATIVE_DATAFILE_DATADICT_SET_BOOL);
+		DATAFILE.set_function("DATADICT_SET_INT", LUA_NATIVE_DATAFILE_DATADICT_SET_INT);
+		DATAFILE.set_function("DATADICT_SET_FLOAT", LUA_NATIVE_DATAFILE_DATADICT_SET_FLOAT);
+		DATAFILE.set_function("DATADICT_SET_STRING", LUA_NATIVE_DATAFILE_DATADICT_SET_STRING);
+		DATAFILE.set_function("DATADICT_SET_VECTOR", LUA_NATIVE_DATAFILE_DATADICT_SET_VECTOR);
+		DATAFILE.set_function("DATADICT_CREATE_DICT", LUA_NATIVE_DATAFILE_DATADICT_CREATE_DICT);
+		DATAFILE.set_function("DATADICT_CREATE_ARRAY", LUA_NATIVE_DATAFILE_DATADICT_CREATE_ARRAY);
+		DATAFILE.set_function("DATADICT_GET_BOOL", LUA_NATIVE_DATAFILE_DATADICT_GET_BOOL);
+		DATAFILE.set_function("DATADICT_GET_INT", LUA_NATIVE_DATAFILE_DATADICT_GET_INT);
+		DATAFILE.set_function("DATADICT_GET_FLOAT", LUA_NATIVE_DATAFILE_DATADICT_GET_FLOAT);
+		DATAFILE.set_function("DATADICT_GET_STRING", LUA_NATIVE_DATAFILE_DATADICT_GET_STRING);
+		DATAFILE.set_function("DATADICT_GET_VECTOR", LUA_NATIVE_DATAFILE_DATADICT_GET_VECTOR);
+		DATAFILE.set_function("DATADICT_GET_DICT", LUA_NATIVE_DATAFILE_DATADICT_GET_DICT);
+		DATAFILE.set_function("DATADICT_GET_ARRAY", LUA_NATIVE_DATAFILE_DATADICT_GET_ARRAY);
+		DATAFILE.set_function("DATADICT_GET_TYPE", LUA_NATIVE_DATAFILE_DATADICT_GET_TYPE);
+		DATAFILE.set_function("DATAARRAY_ADD_BOOL", LUA_NATIVE_DATAFILE_DATAARRAY_ADD_BOOL);
+		DATAFILE.set_function("DATAARRAY_ADD_INT", LUA_NATIVE_DATAFILE_DATAARRAY_ADD_INT);
+		DATAFILE.set_function("DATAARRAY_ADD_FLOAT", LUA_NATIVE_DATAFILE_DATAARRAY_ADD_FLOAT);
+		DATAFILE.set_function("DATAARRAY_ADD_STRING", LUA_NATIVE_DATAFILE_DATAARRAY_ADD_STRING);
+		DATAFILE.set_function("DATAARRAY_ADD_VECTOR", LUA_NATIVE_DATAFILE_DATAARRAY_ADD_VECTOR);
+		DATAFILE.set_function("DATAARRAY_ADD_DICT", LUA_NATIVE_DATAFILE_DATAARRAY_ADD_DICT);
+		DATAFILE.set_function("DATAARRAY_GET_BOOL", LUA_NATIVE_DATAFILE_DATAARRAY_GET_BOOL);
+		DATAFILE.set_function("DATAARRAY_GET_INT", LUA_NATIVE_DATAFILE_DATAARRAY_GET_INT);
+		DATAFILE.set_function("DATAARRAY_GET_FLOAT", LUA_NATIVE_DATAFILE_DATAARRAY_GET_FLOAT);
+		DATAFILE.set_function("DATAARRAY_GET_STRING", LUA_NATIVE_DATAFILE_DATAARRAY_GET_STRING);
+		DATAFILE.set_function("DATAARRAY_GET_VECTOR", LUA_NATIVE_DATAFILE_DATAARRAY_GET_VECTOR);
+		DATAFILE.set_function("DATAARRAY_GET_DICT", LUA_NATIVE_DATAFILE_DATAARRAY_GET_DICT);
+		DATAFILE.set_function("DATAARRAY_GET_COUNT", LUA_NATIVE_DATAFILE_DATAARRAY_GET_COUNT);
+		DATAFILE.set_function("DATAARRAY_GET_TYPE", LUA_NATIVE_DATAFILE_DATAARRAY_GET_TYPE);
+	}
+}

src/lua/natives/lua_native_binding_DECORATOR.cpp

@@ -0,0 +1,92 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_TIME( Entity entity, const char* propertyName, int timestamp )
+	{
+		auto retval = (bool)DECORATOR::DECOR_SET_TIME(entity, propertyName, timestamp);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_BOOL( Entity entity, const char* propertyName, bool value )
+	{
+		auto retval = (bool)DECORATOR::DECOR_SET_BOOL(entity, propertyName, value);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_FLOAT( Entity entity, const char* propertyName, float value )
+	{
+		auto retval = (bool)DECORATOR::DECOR_SET_FLOAT(entity, propertyName, value);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_INT( Entity entity, const char* propertyName, int value )
+	{
+		auto retval = (bool)DECORATOR::DECOR_SET_INT(entity, propertyName, value);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DECORATOR_DECOR_GET_BOOL( Entity entity, const char* propertyName )
+	{
+		auto retval = (bool)DECORATOR::DECOR_GET_BOOL(entity, propertyName);
+		return retval;
+	}
+
+	static float LUA_NATIVE_DECORATOR_DECOR_GET_FLOAT( Entity entity, const char* propertyName )
+	{
+		auto retval = DECORATOR::DECOR_GET_FLOAT(entity, propertyName);
+		return retval;
+	}
+
+	static int LUA_NATIVE_DECORATOR_DECOR_GET_INT( Entity entity, const char* propertyName )
+	{
+		auto retval = DECORATOR::DECOR_GET_INT(entity, propertyName);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DECORATOR_DECOR_EXIST_ON( Entity entity, const char* propertyName )
+	{
+		auto retval = (bool)DECORATOR::DECOR_EXIST_ON(entity, propertyName);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DECORATOR_DECOR_REMOVE( Entity entity, const char* propertyName )
+	{
+		auto retval = (bool)DECORATOR::DECOR_REMOVE(entity, propertyName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_DECORATOR_DECOR_REGISTER( const char* propertyName, int type )
+	{
+		DECORATOR::DECOR_REGISTER(propertyName, type);
+	}
+
+	static bool LUA_NATIVE_DECORATOR_DECOR_IS_REGISTERED_AS_TYPE( const char* propertyName, int type )
+	{
+		auto retval = (bool)DECORATOR::DECOR_IS_REGISTERED_AS_TYPE(propertyName, type);
+		return retval;
+	}
+
+	static void LUA_NATIVE_DECORATOR_DECOR_REGISTER_LOCK(  )
+	{
+		DECORATOR::DECOR_REGISTER_LOCK();
+	}
+
+	void init_native_binding_DECORATOR(sol::state& L)
+	{
+		auto DECORATOR = L["DECORATOR"].get_or_create<sol::table>();
+		DECORATOR.set_function("DECOR_SET_TIME", LUA_NATIVE_DECORATOR_DECOR_SET_TIME);
+		DECORATOR.set_function("DECOR_SET_BOOL", LUA_NATIVE_DECORATOR_DECOR_SET_BOOL);
+		DECORATOR.set_function("DECOR_SET_FLOAT", LUA_NATIVE_DECORATOR_DECOR_SET_FLOAT);
+		DECORATOR.set_function("DECOR_SET_INT", LUA_NATIVE_DECORATOR_DECOR_SET_INT);
+		DECORATOR.set_function("DECOR_GET_BOOL", LUA_NATIVE_DECORATOR_DECOR_GET_BOOL);
+		DECORATOR.set_function("DECOR_GET_FLOAT", LUA_NATIVE_DECORATOR_DECOR_GET_FLOAT);
+		DECORATOR.set_function("DECOR_GET_INT", LUA_NATIVE_DECORATOR_DECOR_GET_INT);
+		DECORATOR.set_function("DECOR_EXIST_ON", LUA_NATIVE_DECORATOR_DECOR_EXIST_ON);
+		DECORATOR.set_function("DECOR_REMOVE", LUA_NATIVE_DECORATOR_DECOR_REMOVE);
+		DECORATOR.set_function("DECOR_REGISTER", LUA_NATIVE_DECORATOR_DECOR_REGISTER);
+		DECORATOR.set_function("DECOR_IS_REGISTERED_AS_TYPE", LUA_NATIVE_DECORATOR_DECOR_IS_REGISTERED_AS_TYPE);
+		DECORATOR.set_function("DECOR_REGISTER_LOCK", LUA_NATIVE_DECORATOR_DECOR_REGISTER_LOCK);
+	}
+}

src/lua/natives/lua_native_binding_DLC.cpp

@@ -0,0 +1,88 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static bool LUA_NATIVE_DLC_ARE_ANY_CCS_PENDING(  )
+	{
+		auto retval = (bool)DLC::ARE_ANY_CCS_PENDING();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DLC_IS_DLC_PRESENT( Hash dlcHash )
+	{
+		auto retval = (bool)DLC::IS_DLC_PRESENT(dlcHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DLC_DLC_CHECK_CLOUD_DATA_CORRECT(  )
+	{
+		auto retval = (bool)DLC::DLC_CHECK_CLOUD_DATA_CORRECT();
+		return retval;
+	}
+
+	static int LUA_NATIVE_DLC_GET_EXTRACONTENT_CLOUD_RESULT(  )
+	{
+		auto retval = DLC::GET_EXTRACONTENT_CLOUD_RESULT();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DLC_DLC_CHECK_COMPAT_PACK_CONFIGURATION(  )
+	{
+		auto retval = (bool)DLC::DLC_CHECK_COMPAT_PACK_CONFIGURATION();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DLC_GET_EVER_HAD_BAD_PACK_ORDER(  )
+	{
+		auto retval = (bool)DLC::GET_EVER_HAD_BAD_PACK_ORDER();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DLC_GET_IS_LOADING_SCREEN_ACTIVE(  )
+	{
+		auto retval = (bool)DLC::GET_IS_LOADING_SCREEN_ACTIVE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_DLC_GET_IS_INITIAL_LOADING_SCREEN_ACTIVE(  )
+	{
+		auto retval = (bool)DLC::GET_IS_INITIAL_LOADING_SCREEN_ACTIVE();
+		return retval;
+	}
+
+	static std::tuple<bool, bool> LUA_NATIVE_DLC_HAS_CLOUD_REQUESTS_FINISHED( bool p0, int unused )
+	{
+		std::tuple<bool, bool> return_values;
+		std::get<0>(return_values) = (bool)DLC::HAS_CLOUD_REQUESTS_FINISHED((BOOL*)&p0, unused);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_DLC_ON_ENTER_SP(  )
+	{
+		DLC::ON_ENTER_SP();
+	}
+
+	static void LUA_NATIVE_DLC_ON_ENTER_MP(  )
+	{
+		DLC::ON_ENTER_MP();
+	}
+
+	void init_native_binding_DLC(sol::state& L)
+	{
+		auto DLC = L["DLC"].get_or_create<sol::table>();
+		DLC.set_function("ARE_ANY_CCS_PENDING", LUA_NATIVE_DLC_ARE_ANY_CCS_PENDING);
+		DLC.set_function("IS_DLC_PRESENT", LUA_NATIVE_DLC_IS_DLC_PRESENT);
+		DLC.set_function("DLC_CHECK_CLOUD_DATA_CORRECT", LUA_NATIVE_DLC_DLC_CHECK_CLOUD_DATA_CORRECT);
+		DLC.set_function("GET_EXTRACONTENT_CLOUD_RESULT", LUA_NATIVE_DLC_GET_EXTRACONTENT_CLOUD_RESULT);
+		DLC.set_function("DLC_CHECK_COMPAT_PACK_CONFIGURATION", LUA_NATIVE_DLC_DLC_CHECK_COMPAT_PACK_CONFIGURATION);
+		DLC.set_function("GET_EVER_HAD_BAD_PACK_ORDER", LUA_NATIVE_DLC_GET_EVER_HAD_BAD_PACK_ORDER);
+		DLC.set_function("GET_IS_LOADING_SCREEN_ACTIVE", LUA_NATIVE_DLC_GET_IS_LOADING_SCREEN_ACTIVE);
+		DLC.set_function("GET_IS_INITIAL_LOADING_SCREEN_ACTIVE", LUA_NATIVE_DLC_GET_IS_INITIAL_LOADING_SCREEN_ACTIVE);
+		DLC.set_function("HAS_CLOUD_REQUESTS_FINISHED", LUA_NATIVE_DLC_HAS_CLOUD_REQUESTS_FINISHED);
+		DLC.set_function("ON_ENTER_SP", LUA_NATIVE_DLC_ON_ENTER_SP);
+		DLC.set_function("ON_ENTER_MP", LUA_NATIVE_DLC_ON_ENTER_MP);
+	}
+}

src/lua/natives/lua_native_binding_EVENT.cpp

@@ -0,0 +1,92 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_EVENT_SET_DECISION_MAKER( Ped ped, Hash name )
+	{
+		EVENT::SET_DECISION_MAKER(ped, name);
+	}
+
+	static void LUA_NATIVE_EVENT_CLEAR_DECISION_MAKER_EVENT_RESPONSE( Hash name, int eventType )
+	{
+		EVENT::CLEAR_DECISION_MAKER_EVENT_RESPONSE(name, eventType);
+	}
+
+	static void LUA_NATIVE_EVENT_BLOCK_DECISION_MAKER_EVENT( Hash name, int eventType )
+	{
+		EVENT::BLOCK_DECISION_MAKER_EVENT(name, eventType);
+	}
+
+	static void LUA_NATIVE_EVENT_UNBLOCK_DECISION_MAKER_EVENT( Hash name, int eventType )
+	{
+		EVENT::UNBLOCK_DECISION_MAKER_EVENT(name, eventType);
+	}
+
+	static int LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_AT_POSITION( int eventType, float x, float y, float z, float duration )
+	{
+		auto retval = EVENT::ADD_SHOCKING_EVENT_AT_POSITION(eventType, x, y, z, duration);
+		return retval;
+	}
+
+	static int LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_FOR_ENTITY( int eventType, Entity entity, float duration )
+	{
+		auto retval = EVENT::ADD_SHOCKING_EVENT_FOR_ENTITY(eventType, entity, duration);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_EVENT_IS_SHOCKING_EVENT_IN_SPHERE( int eventType, float x, float y, float z, float radius )
+	{
+		auto retval = (bool)EVENT::IS_SHOCKING_EVENT_IN_SPHERE(eventType, x, y, z, radius);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT( ScrHandle event )
+	{
+		auto retval = (bool)EVENT::REMOVE_SHOCKING_EVENT(event);
+		return retval;
+	}
+
+	static void LUA_NATIVE_EVENT_REMOVE_ALL_SHOCKING_EVENTS( bool p0 )
+	{
+		EVENT::REMOVE_ALL_SHOCKING_EVENTS(p0);
+	}
+
+	static void LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS(  )
+	{
+		EVENT::REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS();
+	}
+
+	static void LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME(  )
+	{
+		EVENT::SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME();
+	}
+
+	static void LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME( int eventType )
+	{
+		EVENT::SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME(eventType);
+	}
+
+	static void LUA_NATIVE_EVENT_SUPPRESS_AGITATION_EVENTS_NEXT_FRAME(  )
+	{
+		EVENT::SUPPRESS_AGITATION_EVENTS_NEXT_FRAME();
+	}
+
+	void init_native_binding_EVENT(sol::state& L)
+	{
+		auto EVENT = L["EVENT"].get_or_create<sol::table>();
+		EVENT.set_function("SET_DECISION_MAKER", LUA_NATIVE_EVENT_SET_DECISION_MAKER);
+		EVENT.set_function("CLEAR_DECISION_MAKER_EVENT_RESPONSE", LUA_NATIVE_EVENT_CLEAR_DECISION_MAKER_EVENT_RESPONSE);
+		EVENT.set_function("BLOCK_DECISION_MAKER_EVENT", LUA_NATIVE_EVENT_BLOCK_DECISION_MAKER_EVENT);
+		EVENT.set_function("UNBLOCK_DECISION_MAKER_EVENT", LUA_NATIVE_EVENT_UNBLOCK_DECISION_MAKER_EVENT);
+		EVENT.set_function("ADD_SHOCKING_EVENT_AT_POSITION", LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_AT_POSITION);
+		EVENT.set_function("ADD_SHOCKING_EVENT_FOR_ENTITY", LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_FOR_ENTITY);
+		EVENT.set_function("IS_SHOCKING_EVENT_IN_SPHERE", LUA_NATIVE_EVENT_IS_SHOCKING_EVENT_IN_SPHERE);
+		EVENT.set_function("REMOVE_SHOCKING_EVENT", LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT);
+		EVENT.set_function("REMOVE_ALL_SHOCKING_EVENTS", LUA_NATIVE_EVENT_REMOVE_ALL_SHOCKING_EVENTS);
+		EVENT.set_function("REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS", LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS);
+		EVENT.set_function("SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME", LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME);
+		EVENT.set_function("SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME", LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME);
+		EVENT.set_function("SUPPRESS_AGITATION_EVENTS_NEXT_FRAME", LUA_NATIVE_EVENT_SUPPRESS_AGITATION_EVENTS_NEXT_FRAME);
+	}
+}

src/lua/natives/lua_native_binding_FILES.cpp

@@ -0,0 +1,395 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static int LUA_NATIVE_FILES_GET_NUM_TATTOO_SHOP_DLC_ITEMS( int character )
+	{
+		auto retval = FILES::GET_NUM_TATTOO_SHOP_DLC_ITEMS(character);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_DATA( int characterType, int decorationIndex, Any outComponent )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_TATTOO_SHOP_DLC_ITEM_DATA(characterType, decorationIndex, &outComponent);
+		std::get<1>(return_values) = outComponent;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_INDEX( Hash overlayHash, Any p1, int character )
+	{
+		auto retval = FILES::GET_TATTOO_SHOP_DLC_ITEM_INDEX(overlayHash, p1, character);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_FILES_INIT_SHOP_PED_COMPONENT( Any outComponent )
+	{
+		FILES::INIT_SHOP_PED_COMPONENT(&outComponent);
+		return outComponent;
+	}
+
+	static Any LUA_NATIVE_FILES_INIT_SHOP_PED_PROP( Any outProp )
+	{
+		FILES::INIT_SHOP_PED_PROP(&outProp);
+		return outProp;
+	}
+
+	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY( int p0, int p1, int p2, int p3 )
+	{
+		auto retval = FILES::SETUP_SHOP_PED_APPAREL_QUERY(p0, p1, p2, p3);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY_TU( int character, int p1, int p2, bool p3, int p4, int componentId )
+	{
+		auto retval = FILES::SETUP_SHOP_PED_APPAREL_QUERY_TU(character, p1, p2, p3, p4, componentId);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT( int componentId, Any outComponent )
+	{
+		FILES::GET_SHOP_PED_QUERY_COMPONENT(componentId, &outComponent);
+		return outComponent;
+	}
+
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT_INDEX( Hash componentHash )
+	{
+		auto retval = FILES::GET_SHOP_PED_QUERY_COMPONENT_INDEX(componentHash);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_COMPONENT( Hash componentHash, Any outComponent )
+	{
+		FILES::GET_SHOP_PED_COMPONENT(componentHash, &outComponent);
+		return outComponent;
+	}
+
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP( int componentId, Any outProp )
+	{
+		FILES::GET_SHOP_PED_QUERY_PROP(componentId, &outProp);
+		return outProp;
+	}
+
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP_INDEX( Hash componentHash )
+	{
+		auto retval = FILES::GET_SHOP_PED_QUERY_PROP_INDEX(componentHash);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_PROP( Hash componentHash, Any outProp )
+	{
+		FILES::GET_SHOP_PED_PROP(componentHash, &outProp);
+		return outProp;
+	}
+
+	static Hash LUA_NATIVE_FILES_GET_HASH_NAME_FOR_COMPONENT( Entity entity, int componentId, int drawableVariant, int textureVariant )
+	{
+		auto retval = FILES::GET_HASH_NAME_FOR_COMPONENT(entity, componentId, drawableVariant, textureVariant);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_FILES_GET_HASH_NAME_FOR_PROP( Entity entity, int componentId, int propIndex, int propTextureIndex )
+	{
+		auto retval = FILES::GET_HASH_NAME_FOR_PROP(entity, componentId, propIndex, propTextureIndex);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT( Hash componentHash )
+	{
+		auto retval = FILES::GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT(componentHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT( Hash propHash )
+	{
+		auto retval = FILES::GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT(propHash);
+		return retval;
+	}
+
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_VARIANT_COMPONENT( Hash componentHash, int variantComponentIndex, Hash nameHash, int enumValue, int componentType )
+	{
+		std::tuple<Hash, int, int> return_values;
+		FILES::GET_VARIANT_COMPONENT(componentHash, variantComponentIndex, &nameHash, &enumValue, &componentType);
+		std::get<0>(return_values) = nameHash;
+		std::get<1>(return_values) = enumValue;
+		std::get<2>(return_values) = componentType;
+
+		return return_values;
+	}
+
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_VARIANT_PROP( Hash componentHash, int variantPropIndex, Hash nameHash, int enumValue, int anchorPoint )
+	{
+		std::tuple<Hash, int, int> return_values;
+		FILES::GET_VARIANT_PROP(componentHash, variantPropIndex, &nameHash, &enumValue, &anchorPoint);
+		std::get<0>(return_values) = nameHash;
+		std::get<1>(return_values) = enumValue;
+		std::get<2>(return_values) = anchorPoint;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT( Hash componentHash )
+	{
+		auto retval = FILES::GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT(componentHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT( Hash componentHash )
+	{
+		auto retval = FILES::GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT(componentHash);
+		return retval;
+	}
+
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_FORCED_COMPONENT( Hash componentHash, int forcedComponentIndex, Hash nameHash, int enumValue, int componentType )
+	{
+		std::tuple<Hash, int, int> return_values;
+		FILES::GET_FORCED_COMPONENT(componentHash, forcedComponentIndex, &nameHash, &enumValue, &componentType);
+		std::get<0>(return_values) = nameHash;
+		std::get<1>(return_values) = enumValue;
+		std::get<2>(return_values) = componentType;
+
+		return return_values;
+	}
+
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_FORCED_PROP( Hash componentHash, int forcedPropIndex, Hash nameHash, int enumValue, int anchorPoint )
+	{
+		std::tuple<Hash, int, int> return_values;
+		FILES::GET_FORCED_PROP(componentHash, forcedPropIndex, &nameHash, &enumValue, &anchorPoint);
+		std::get<0>(return_values) = nameHash;
+		std::get<1>(return_values) = enumValue;
+		std::get<2>(return_values) = anchorPoint;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_FILES_DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG( Hash componentHash, Hash restrictionTagHash, int componentId )
+	{
+		auto retval = (bool)FILES::DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG(componentHash, restrictionTagHash, componentId);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_FILES_DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG( Ped ped, int componentId, Hash restrictionTagHash )
+	{
+		auto retval = (bool)FILES::DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG(ped, componentId, restrictionTagHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_FILES_DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG( Ped ped, int componentId, Hash restrictionTagHash )
+	{
+		auto retval = (bool)FILES::DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG(ped, componentId, restrictionTagHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_OUTFIT_QUERY( int character, bool p1 )
+	{
+		auto retval = FILES::SETUP_SHOP_PED_OUTFIT_QUERY(character, p1);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_OUTFIT( int outfitIndex, Any outfit )
+	{
+		FILES::GET_SHOP_PED_QUERY_OUTFIT(outfitIndex, &outfit);
+		return outfit;
+	}
+
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT( Any p0, Any p1 )
+	{
+		FILES::GET_SHOP_PED_OUTFIT(p0, &p1);
+		return p1;
+	}
+
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_LOCATE( Any p0 )
+	{
+		auto retval = FILES::GET_SHOP_PED_OUTFIT_LOCATE(p0);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_PROP_VARIANT( Hash outfitHash, int variantIndex, Any outPropVariant )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_SHOP_PED_OUTFIT_PROP_VARIANT(outfitHash, variantIndex, &outPropVariant);
+		std::get<1>(return_values) = outPropVariant;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT( Hash outfitHash, int variantIndex, Any outComponentVariant )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT(outfitHash, variantIndex, &outComponentVariant);
+		std::get<1>(return_values) = outComponentVariant;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_VEHICLES(  )
+	{
+		auto retval = FILES::GET_NUM_DLC_VEHICLES();
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_FILES_GET_DLC_VEHICLE_MODEL( int dlcVehicleIndex )
+	{
+		auto retval = FILES::GET_DLC_VEHICLE_MODEL(dlcVehicleIndex);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_VEHICLE_DATA( int dlcVehicleIndex, Any outData )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_DLC_VEHICLE_DATA(dlcVehicleIndex, &outData);
+		std::get<1>(return_values) = outData;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_FILES_GET_DLC_VEHICLE_FLAGS( int dlcVehicleIndex )
+	{
+		auto retval = FILES::GET_DLC_VEHICLE_FLAGS(dlcVehicleIndex);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS(  )
+	{
+		auto retval = FILES::GET_NUM_DLC_WEAPONS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS_SP(  )
+	{
+		auto retval = FILES::GET_NUM_DLC_WEAPONS_SP();
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA( int dlcWeaponIndex, Any outData )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_DATA(dlcWeaponIndex, &outData);
+		std::get<1>(return_values) = outData;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA_SP( int dlcWeaponIndex, Any outData )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_DATA_SP(dlcWeaponIndex, &outData);
+		std::get<1>(return_values) = outData;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS( int dlcWeaponIndex )
+	{
+		auto retval = FILES::GET_NUM_DLC_WEAPON_COMPONENTS(dlcWeaponIndex);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS_SP( int dlcWeaponIndex )
+	{
+		auto retval = FILES::GET_NUM_DLC_WEAPON_COMPONENTS_SP(dlcWeaponIndex);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA( int dlcWeaponIndex, int dlcWeapCompIndex, Any ComponentDataPtr )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_COMPONENT_DATA(dlcWeaponIndex, dlcWeapCompIndex, &ComponentDataPtr);
+		std::get<1>(return_values) = ComponentDataPtr;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA_SP( int dlcWeaponIndex, int dlcWeapCompIndex, Any ComponentDataPtr )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_COMPONENT_DATA_SP(dlcWeaponIndex, dlcWeapCompIndex, &ComponentDataPtr);
+		std::get<1>(return_values) = ComponentDataPtr;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_FILES_IS_CONTENT_ITEM_LOCKED( Hash itemHash )
+	{
+		auto retval = (bool)FILES::IS_CONTENT_ITEM_LOCKED(itemHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_FILES_IS_DLC_VEHICLE_MOD( Hash hash )
+	{
+		auto retval = (bool)FILES::IS_DLC_VEHICLE_MOD(hash);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_FILES_GET_DLC_VEHICLE_MOD_LOCK_HASH( Hash hash )
+	{
+		auto retval = FILES::GET_DLC_VEHICLE_MOD_LOCK_HASH(hash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_FILES_EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL( Hash hash )
+	{
+		FILES::EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL(hash);
+	}
+
+	static void LUA_NATIVE_FILES_REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL( Hash hash )
+	{
+		FILES::REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL(hash);
+	}
+
+	void init_native_binding_FILES(sol::state& L)
+	{
+		auto FILES = L["FILES"].get_or_create<sol::table>();
+		FILES.set_function("GET_NUM_TATTOO_SHOP_DLC_ITEMS", LUA_NATIVE_FILES_GET_NUM_TATTOO_SHOP_DLC_ITEMS);
+		FILES.set_function("GET_TATTOO_SHOP_DLC_ITEM_DATA", LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_DATA);
+		FILES.set_function("GET_TATTOO_SHOP_DLC_ITEM_INDEX", LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_INDEX);
+		FILES.set_function("INIT_SHOP_PED_COMPONENT", LUA_NATIVE_FILES_INIT_SHOP_PED_COMPONENT);
+		FILES.set_function("INIT_SHOP_PED_PROP", LUA_NATIVE_FILES_INIT_SHOP_PED_PROP);
+		FILES.set_function("SETUP_SHOP_PED_APPAREL_QUERY", LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY);
+		FILES.set_function("SETUP_SHOP_PED_APPAREL_QUERY_TU", LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY_TU);
+		FILES.set_function("GET_SHOP_PED_QUERY_COMPONENT", LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT);
+		FILES.set_function("GET_SHOP_PED_QUERY_COMPONENT_INDEX", LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT_INDEX);
+		FILES.set_function("GET_SHOP_PED_COMPONENT", LUA_NATIVE_FILES_GET_SHOP_PED_COMPONENT);
+		FILES.set_function("GET_SHOP_PED_QUERY_PROP", LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP);
+		FILES.set_function("GET_SHOP_PED_QUERY_PROP_INDEX", LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP_INDEX);
+		FILES.set_function("GET_SHOP_PED_PROP", LUA_NATIVE_FILES_GET_SHOP_PED_PROP);
+		FILES.set_function("GET_HASH_NAME_FOR_COMPONENT", LUA_NATIVE_FILES_GET_HASH_NAME_FOR_COMPONENT);
+		FILES.set_function("GET_HASH_NAME_FOR_PROP", LUA_NATIVE_FILES_GET_HASH_NAME_FOR_PROP);
+		FILES.set_function("GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT", LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT);
+		FILES.set_function("GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT", LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT);
+		FILES.set_function("GET_VARIANT_COMPONENT", LUA_NATIVE_FILES_GET_VARIANT_COMPONENT);
+		FILES.set_function("GET_VARIANT_PROP", LUA_NATIVE_FILES_GET_VARIANT_PROP);
+		FILES.set_function("GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT", LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT);
+		FILES.set_function("GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT", LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT);
+		FILES.set_function("GET_FORCED_COMPONENT", LUA_NATIVE_FILES_GET_FORCED_COMPONENT);
+		FILES.set_function("GET_FORCED_PROP", LUA_NATIVE_FILES_GET_FORCED_PROP);
+		FILES.set_function("DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG", LUA_NATIVE_FILES_DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG);
+		FILES.set_function("DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG", LUA_NATIVE_FILES_DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG);
+		FILES.set_function("DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG", LUA_NATIVE_FILES_DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG);
+		FILES.set_function("SETUP_SHOP_PED_OUTFIT_QUERY", LUA_NATIVE_FILES_SETUP_SHOP_PED_OUTFIT_QUERY);
+		FILES.set_function("GET_SHOP_PED_QUERY_OUTFIT", LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_OUTFIT);
+		FILES.set_function("GET_SHOP_PED_OUTFIT", LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT);
+		FILES.set_function("GET_SHOP_PED_OUTFIT_LOCATE", LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_LOCATE);
+		FILES.set_function("GET_SHOP_PED_OUTFIT_PROP_VARIANT", LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_PROP_VARIANT);
+		FILES.set_function("GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT", LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT);
+		FILES.set_function("GET_NUM_DLC_VEHICLES", LUA_NATIVE_FILES_GET_NUM_DLC_VEHICLES);
+		FILES.set_function("GET_DLC_VEHICLE_MODEL", LUA_NATIVE_FILES_GET_DLC_VEHICLE_MODEL);
+		FILES.set_function("GET_DLC_VEHICLE_DATA", LUA_NATIVE_FILES_GET_DLC_VEHICLE_DATA);
+		FILES.set_function("GET_DLC_VEHICLE_FLAGS", LUA_NATIVE_FILES_GET_DLC_VEHICLE_FLAGS);
+		FILES.set_function("GET_NUM_DLC_WEAPONS", LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS);
+		FILES.set_function("GET_NUM_DLC_WEAPONS_SP", LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS_SP);
+		FILES.set_function("GET_DLC_WEAPON_DATA", LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA);
+		FILES.set_function("GET_DLC_WEAPON_DATA_SP", LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA_SP);
+		FILES.set_function("GET_NUM_DLC_WEAPON_COMPONENTS", LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS);
+		FILES.set_function("GET_NUM_DLC_WEAPON_COMPONENTS_SP", LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS_SP);
+		FILES.set_function("GET_DLC_WEAPON_COMPONENT_DATA", LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA);
+		FILES.set_function("GET_DLC_WEAPON_COMPONENT_DATA_SP", LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA_SP);
+		FILES.set_function("IS_CONTENT_ITEM_LOCKED", LUA_NATIVE_FILES_IS_CONTENT_ITEM_LOCKED);
+		FILES.set_function("IS_DLC_VEHICLE_MOD", LUA_NATIVE_FILES_IS_DLC_VEHICLE_MOD);
+		FILES.set_function("GET_DLC_VEHICLE_MOD_LOCK_HASH", LUA_NATIVE_FILES_GET_DLC_VEHICLE_MOD_LOCK_HASH);
+		FILES.set_function("EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL", LUA_NATIVE_FILES_EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL);
+		FILES.set_function("REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL", LUA_NATIVE_FILES_REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL);
+	}
+}

src/lua/natives/lua_native_binding_FIRE.cpp

@@ -0,0 +1,132 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static FireId LUA_NATIVE_FIRE_START_SCRIPT_FIRE( float X, float Y, float Z, int maxChildren, bool isGasFire )
+	{
+		auto retval = FIRE::START_SCRIPT_FIRE(X, Y, Z, maxChildren, isGasFire);
+		return retval;
+	}
+
+	static void LUA_NATIVE_FIRE_REMOVE_SCRIPT_FIRE( FireId fireHandle )
+	{
+		FIRE::REMOVE_SCRIPT_FIRE(fireHandle);
+	}
+
+	static FireId LUA_NATIVE_FIRE_START_ENTITY_FIRE( Entity entity )
+	{
+		auto retval = FIRE::START_ENTITY_FIRE(entity);
+		return retval;
+	}
+
+	static void LUA_NATIVE_FIRE_STOP_ENTITY_FIRE( Entity entity )
+	{
+		FIRE::STOP_ENTITY_FIRE(entity);
+	}
+
+	static bool LUA_NATIVE_FIRE_IS_ENTITY_ON_FIRE( Entity entity )
+	{
+		auto retval = (bool)FIRE::IS_ENTITY_ON_FIRE(entity);
+		return retval;
+	}
+
+	static int LUA_NATIVE_FIRE_GET_NUMBER_OF_FIRES_IN_RANGE( float x, float y, float z, float radius )
+	{
+		auto retval = FIRE::GET_NUMBER_OF_FIRES_IN_RANGE(x, y, z, radius);
+		return retval;
+	}
+
+	static void LUA_NATIVE_FIRE_SET_FLAMMABILITY_MULTIPLIER( float p0 )
+	{
+		FIRE::SET_FLAMMABILITY_MULTIPLIER(p0);
+	}
+
+	static void LUA_NATIVE_FIRE_STOP_FIRE_IN_RANGE( float x, float y, float z, float radius )
+	{
+		FIRE::STOP_FIRE_IN_RANGE(x, y, z, radius);
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_FIRE_GET_CLOSEST_FIRE_POS( Vector3 outPosition, float x, float y, float z )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)FIRE::GET_CLOSEST_FIRE_POS(&outPosition, x, y, z);
+		std::get<1>(return_values) = outPosition;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_FIRE_ADD_EXPLOSION( float x, float y, float z, int explosionType, float damageScale, bool isAudible, bool isInvisible, float cameraShake, bool noDamage )
+	{
+		FIRE::ADD_EXPLOSION(x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake, noDamage);
+	}
+
+	static void LUA_NATIVE_FIRE_ADD_OWNED_EXPLOSION( Ped ped, float x, float y, float z, int explosionType, float damageScale, bool isAudible, bool isInvisible, float cameraShake )
+	{
+		FIRE::ADD_OWNED_EXPLOSION(ped, x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake);
+	}
+
+	static void LUA_NATIVE_FIRE_ADD_EXPLOSION_WITH_USER_VFX( float x, float y, float z, int explosionType, Hash explosionFx, float damageScale, bool isAudible, bool isInvisible, float cameraShake )
+	{
+		FIRE::ADD_EXPLOSION_WITH_USER_VFX(x, y, z, explosionType, explosionFx, damageScale, isAudible, isInvisible, cameraShake);
+	}
+
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = (bool)FIRE::IS_EXPLOSION_IN_AREA(explosionType, x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_ACTIVE_IN_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = (bool)FIRE::IS_EXPLOSION_ACTIVE_IN_AREA(explosionType, x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_SPHERE( int explosionType, float x, float y, float z, float radius )
+	{
+		auto retval = (bool)FIRE::IS_EXPLOSION_IN_SPHERE(explosionType, x, y, z, radius);
+		return retval;
+	}
+
+	static Entity LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_SPHERE( int explosionType, float x, float y, float z, float radius )
+	{
+		auto retval = FIRE::GET_OWNER_OF_EXPLOSION_IN_SPHERE(explosionType, x, y, z, radius);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_ANGLED_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float width )
+	{
+		auto retval = (bool)FIRE::IS_EXPLOSION_IN_ANGLED_AREA(explosionType, x1, y1, z1, x2, y2, z2, width);
+		return retval;
+	}
+
+	static Entity LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float radius )
+	{
+		auto retval = FIRE::GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA(explosionType, x1, y1, z1, x2, y2, z2, radius);
+		return retval;
+	}
+
+	void init_native_binding_FIRE(sol::state& L)
+	{
+		auto FIRE = L["FIRE"].get_or_create<sol::table>();
+		FIRE.set_function("START_SCRIPT_FIRE", LUA_NATIVE_FIRE_START_SCRIPT_FIRE);
+		FIRE.set_function("REMOVE_SCRIPT_FIRE", LUA_NATIVE_FIRE_REMOVE_SCRIPT_FIRE);
+		FIRE.set_function("START_ENTITY_FIRE", LUA_NATIVE_FIRE_START_ENTITY_FIRE);
+		FIRE.set_function("STOP_ENTITY_FIRE", LUA_NATIVE_FIRE_STOP_ENTITY_FIRE);
+		FIRE.set_function("IS_ENTITY_ON_FIRE", LUA_NATIVE_FIRE_IS_ENTITY_ON_FIRE);
+		FIRE.set_function("GET_NUMBER_OF_FIRES_IN_RANGE", LUA_NATIVE_FIRE_GET_NUMBER_OF_FIRES_IN_RANGE);
+		FIRE.set_function("SET_FLAMMABILITY_MULTIPLIER", LUA_NATIVE_FIRE_SET_FLAMMABILITY_MULTIPLIER);
+		FIRE.set_function("STOP_FIRE_IN_RANGE", LUA_NATIVE_FIRE_STOP_FIRE_IN_RANGE);
+		FIRE.set_function("GET_CLOSEST_FIRE_POS", LUA_NATIVE_FIRE_GET_CLOSEST_FIRE_POS);
+		FIRE.set_function("ADD_EXPLOSION", LUA_NATIVE_FIRE_ADD_EXPLOSION);
+		FIRE.set_function("ADD_OWNED_EXPLOSION", LUA_NATIVE_FIRE_ADD_OWNED_EXPLOSION);
+		FIRE.set_function("ADD_EXPLOSION_WITH_USER_VFX", LUA_NATIVE_FIRE_ADD_EXPLOSION_WITH_USER_VFX);
+		FIRE.set_function("IS_EXPLOSION_IN_AREA", LUA_NATIVE_FIRE_IS_EXPLOSION_IN_AREA);
+		FIRE.set_function("IS_EXPLOSION_ACTIVE_IN_AREA", LUA_NATIVE_FIRE_IS_EXPLOSION_ACTIVE_IN_AREA);
+		FIRE.set_function("IS_EXPLOSION_IN_SPHERE", LUA_NATIVE_FIRE_IS_EXPLOSION_IN_SPHERE);
+		FIRE.set_function("GET_OWNER_OF_EXPLOSION_IN_SPHERE", LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_SPHERE);
+		FIRE.set_function("IS_EXPLOSION_IN_ANGLED_AREA", LUA_NATIVE_FIRE_IS_EXPLOSION_IN_ANGLED_AREA);
+		FIRE.set_function("GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA", LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA);
+	}
+}

src/lua/natives/lua_native_binding_INTERIOR.cpp

@@ -0,0 +1,305 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static float LUA_NATIVE_INTERIOR_GET_INTERIOR_HEADING( Interior interior )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_HEADING(interior);
+		return retval;
+	}
+
+	static std::tuple<Vector3, Hash> LUA_NATIVE_INTERIOR_GET_INTERIOR_LOCATION_AND_NAMEHASH( Interior interior, Vector3 position, Hash nameHash )
+	{
+		std::tuple<Vector3, Hash> return_values;
+		INTERIOR::GET_INTERIOR_LOCATION_AND_NAMEHASH(interior, &position, &nameHash);
+		std::get<0>(return_values) = position;
+		std::get<1>(return_values) = nameHash;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_INTERIOR_GET_INTERIOR_GROUP_ID( Interior interior )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_GROUP_ID(interior);
+		return retval;
+	}
+
+	static Vector3 LUA_NATIVE_INTERIOR_GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS( Interior interior, float x, float y, float z )
+	{
+		auto retval = INTERIOR::GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS(interior, x, y, z);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_SCENE(  )
+	{
+		auto retval = (bool)INTERIOR::IS_INTERIOR_SCENE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_INTERIOR_IS_VALID_INTERIOR( Interior interior )
+	{
+		auto retval = (bool)INTERIOR::IS_VALID_INTERIOR(interior);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_ENTITY( Entity entity )
+	{
+		INTERIOR::CLEAR_ROOM_FOR_ENTITY(entity);
+	}
+
+	static void LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_ENTITY( Entity entity, Interior interior, Hash roomHashKey )
+	{
+		INTERIOR::FORCE_ROOM_FOR_ENTITY(entity, interior, roomHashKey);
+	}
+
+	static Hash LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FROM_ENTITY( Entity entity )
+	{
+		auto retval = INTERIOR::GET_ROOM_KEY_FROM_ENTITY(entity);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_INTERIOR_GET_KEY_FOR_ENTITY_IN_ROOM( Entity entity )
+	{
+		auto retval = INTERIOR::GET_KEY_FOR_ENTITY_IN_ROOM(entity);
+		return retval;
+	}
+
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_ENTITY( Entity entity )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_FROM_ENTITY(entity);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_RETAIN_ENTITY_IN_INTERIOR( Entity entity, Interior interior )
+	{
+		INTERIOR::RETAIN_ENTITY_IN_INTERIOR(entity, interior);
+	}
+
+	static void LUA_NATIVE_INTERIOR_CLEAR_INTERIOR_STATE_OF_ENTITY( Entity entity )
+	{
+		INTERIOR::CLEAR_INTERIOR_STATE_OF_ENTITY(entity);
+	}
+
+	static void LUA_NATIVE_INTERIOR_FORCE_ACTIVATING_TRACKING_ON_ENTITY( Any p0, Any p1 )
+	{
+		INTERIOR::FORCE_ACTIVATING_TRACKING_ON_ENTITY(p0, p1);
+	}
+
+	static void LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_GAME_VIEWPORT( int interiorID, Hash roomHashKey )
+	{
+		INTERIOR::FORCE_ROOM_FOR_GAME_VIEWPORT(interiorID, roomHashKey);
+	}
+
+	static void LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME( const char* roomName )
+	{
+		INTERIOR::SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME(roomName);
+	}
+
+	static void LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY( Hash roomHashKey )
+	{
+		INTERIOR::SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY(roomHashKey);
+	}
+
+	static Hash LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FOR_GAME_VIEWPORT(  )
+	{
+		auto retval = INTERIOR::GET_ROOM_KEY_FOR_GAME_VIEWPORT();
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_GAME_VIEWPORT(  )
+	{
+		INTERIOR::CLEAR_ROOM_FOR_GAME_VIEWPORT();
+	}
+
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_PRIMARY_VIEW(  )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_FROM_PRIMARY_VIEW();
+		return retval;
+	}
+
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS( float x, float y, float z )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_AT_COORDS(x, y, z);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME( Pickup pickup, const char* roomName )
+	{
+		INTERIOR::ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME(pickup, roomName);
+	}
+
+	static void LUA_NATIVE_INTERIOR_PIN_INTERIOR_IN_MEMORY( Interior interior )
+	{
+		INTERIOR::PIN_INTERIOR_IN_MEMORY(interior);
+	}
+
+	static void LUA_NATIVE_INTERIOR_UNPIN_INTERIOR( Interior interior )
+	{
+		INTERIOR::UNPIN_INTERIOR(interior);
+	}
+
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_READY( Interior interior )
+	{
+		auto retval = (bool)INTERIOR::IS_INTERIOR_READY(interior);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_INTERIOR_SET_INTERIOR_IN_USE( Interior interior )
+	{
+		auto retval = (bool)INTERIOR::SET_INTERIOR_IN_USE(interior);
+		return retval;
+	}
+
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPE( float x, float y, float z, const char* interiorType )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_AT_COORDS_WITH_TYPE(x, y, z, interiorType);
+		return retval;
+	}
+
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPEHASH( float x, float y, float z, Hash typeHash )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_AT_COORDS_WITH_TYPEHASH(x, y, z, typeHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_GROUPS_USING_CAMERA(  )
+	{
+		INTERIOR::ACTIVATE_INTERIOR_GROUPS_USING_CAMERA();
+	}
+
+	static bool LUA_NATIVE_INTERIOR_IS_COLLISION_MARKED_OUTSIDE( float x, float y, float z )
+	{
+		auto retval = (bool)INTERIOR::IS_COLLISION_MARKED_OUTSIDE(x, y, z);
+		return retval;
+	}
+
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_COLLISION( float x, float y, float z )
+	{
+		auto retval = INTERIOR::GET_INTERIOR_FROM_COLLISION(x, y, z);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_ENABLE_STADIUM_PROBES_THIS_FRAME( bool toggle )
+	{
+		INTERIOR::ENABLE_STADIUM_PROBES_THIS_FRAME(toggle);
+	}
+
+	static void LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_ENTITY_SET( Interior interior, const char* entitySetName )
+	{
+		INTERIOR::ACTIVATE_INTERIOR_ENTITY_SET(interior, entitySetName);
+	}
+
+	static void LUA_NATIVE_INTERIOR_DEACTIVATE_INTERIOR_ENTITY_SET( Interior interior, const char* entitySetName )
+	{
+		INTERIOR::DEACTIVATE_INTERIOR_ENTITY_SET(interior, entitySetName);
+	}
+
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_ENTITY_SET_ACTIVE( Interior interior, const char* entitySetName )
+	{
+		auto retval = (bool)INTERIOR::IS_INTERIOR_ENTITY_SET_ACTIVE(interior, entitySetName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_SET_INTERIOR_ENTITY_SET_TINT_INDEX( Interior interior, const char* entitySetName, int color )
+	{
+		INTERIOR::SET_INTERIOR_ENTITY_SET_TINT_INDEX(interior, entitySetName, color);
+	}
+
+	static void LUA_NATIVE_INTERIOR_REFRESH_INTERIOR( Interior interior )
+	{
+		INTERIOR::REFRESH_INTERIOR(interior);
+	}
+
+	static void LUA_NATIVE_INTERIOR_ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME( Hash mapObjectHash )
+	{
+		INTERIOR::ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME(mapObjectHash);
+	}
+
+	static void LUA_NATIVE_INTERIOR_ENABLE_SHADOW_CULL_MODEL_THIS_FRAME( Hash mapObjectHash )
+	{
+		INTERIOR::ENABLE_SHADOW_CULL_MODEL_THIS_FRAME(mapObjectHash);
+	}
+
+	static void LUA_NATIVE_INTERIOR_DISABLE_INTERIOR( Interior interior, bool toggle )
+	{
+		INTERIOR::DISABLE_INTERIOR(interior, toggle);
+	}
+
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_DISABLED( Interior interior )
+	{
+		auto retval = (bool)INTERIOR::IS_INTERIOR_DISABLED(interior);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_CAP_INTERIOR( Interior interior, bool toggle )
+	{
+		INTERIOR::CAP_INTERIOR(interior, toggle);
+	}
+
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_CAPPED( Interior interior )
+	{
+		auto retval = (bool)INTERIOR::IS_INTERIOR_CAPPED(interior);
+		return retval;
+	}
+
+	static void LUA_NATIVE_INTERIOR_DISABLE_METRO_SYSTEM( bool toggle )
+	{
+		INTERIOR::DISABLE_METRO_SYSTEM(toggle);
+	}
+
+	static void LUA_NATIVE_INTERIOR_SET_IS_EXTERIOR_ONLY( Entity entity, bool toggle )
+	{
+		INTERIOR::SET_IS_EXTERIOR_ONLY(entity, toggle);
+	}
+
+	void init_native_binding_INTERIOR(sol::state& L)
+	{
+		auto INTERIOR = L["INTERIOR"].get_or_create<sol::table>();
+		INTERIOR.set_function("GET_INTERIOR_HEADING", LUA_NATIVE_INTERIOR_GET_INTERIOR_HEADING);
+		INTERIOR.set_function("GET_INTERIOR_LOCATION_AND_NAMEHASH", LUA_NATIVE_INTERIOR_GET_INTERIOR_LOCATION_AND_NAMEHASH);
+		INTERIOR.set_function("GET_INTERIOR_GROUP_ID", LUA_NATIVE_INTERIOR_GET_INTERIOR_GROUP_ID);
+		INTERIOR.set_function("GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS", LUA_NATIVE_INTERIOR_GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS);
+		INTERIOR.set_function("IS_INTERIOR_SCENE", LUA_NATIVE_INTERIOR_IS_INTERIOR_SCENE);
+		INTERIOR.set_function("IS_VALID_INTERIOR", LUA_NATIVE_INTERIOR_IS_VALID_INTERIOR);
+		INTERIOR.set_function("CLEAR_ROOM_FOR_ENTITY", LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_ENTITY);
+		INTERIOR.set_function("FORCE_ROOM_FOR_ENTITY", LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_ENTITY);
+		INTERIOR.set_function("GET_ROOM_KEY_FROM_ENTITY", LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FROM_ENTITY);
+		INTERIOR.set_function("GET_KEY_FOR_ENTITY_IN_ROOM", LUA_NATIVE_INTERIOR_GET_KEY_FOR_ENTITY_IN_ROOM);
+		INTERIOR.set_function("GET_INTERIOR_FROM_ENTITY", LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_ENTITY);
+		INTERIOR.set_function("RETAIN_ENTITY_IN_INTERIOR", LUA_NATIVE_INTERIOR_RETAIN_ENTITY_IN_INTERIOR);
+		INTERIOR.set_function("CLEAR_INTERIOR_STATE_OF_ENTITY", LUA_NATIVE_INTERIOR_CLEAR_INTERIOR_STATE_OF_ENTITY);
+		INTERIOR.set_function("FORCE_ACTIVATING_TRACKING_ON_ENTITY", LUA_NATIVE_INTERIOR_FORCE_ACTIVATING_TRACKING_ON_ENTITY);
+		INTERIOR.set_function("FORCE_ROOM_FOR_GAME_VIEWPORT", LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_GAME_VIEWPORT);
+		INTERIOR.set_function("SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME", LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME);
+		INTERIOR.set_function("SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY", LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY);
+		INTERIOR.set_function("GET_ROOM_KEY_FOR_GAME_VIEWPORT", LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FOR_GAME_VIEWPORT);
+		INTERIOR.set_function("CLEAR_ROOM_FOR_GAME_VIEWPORT", LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_GAME_VIEWPORT);
+		INTERIOR.set_function("GET_INTERIOR_FROM_PRIMARY_VIEW", LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_PRIMARY_VIEW);
+		INTERIOR.set_function("GET_INTERIOR_AT_COORDS", LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS);
+		INTERIOR.set_function("ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME", LUA_NATIVE_INTERIOR_ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME);
+		INTERIOR.set_function("PIN_INTERIOR_IN_MEMORY", LUA_NATIVE_INTERIOR_PIN_INTERIOR_IN_MEMORY);
+		INTERIOR.set_function("UNPIN_INTERIOR", LUA_NATIVE_INTERIOR_UNPIN_INTERIOR);
+		INTERIOR.set_function("IS_INTERIOR_READY", LUA_NATIVE_INTERIOR_IS_INTERIOR_READY);
+		INTERIOR.set_function("SET_INTERIOR_IN_USE", LUA_NATIVE_INTERIOR_SET_INTERIOR_IN_USE);
+		INTERIOR.set_function("GET_INTERIOR_AT_COORDS_WITH_TYPE", LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPE);
+		INTERIOR.set_function("GET_INTERIOR_AT_COORDS_WITH_TYPEHASH", LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPEHASH);
+		INTERIOR.set_function("ACTIVATE_INTERIOR_GROUPS_USING_CAMERA", LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_GROUPS_USING_CAMERA);
+		INTERIOR.set_function("IS_COLLISION_MARKED_OUTSIDE", LUA_NATIVE_INTERIOR_IS_COLLISION_MARKED_OUTSIDE);
+		INTERIOR.set_function("GET_INTERIOR_FROM_COLLISION", LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_COLLISION);
+		INTERIOR.set_function("ENABLE_STADIUM_PROBES_THIS_FRAME", LUA_NATIVE_INTERIOR_ENABLE_STADIUM_PROBES_THIS_FRAME);
+		INTERIOR.set_function("ACTIVATE_INTERIOR_ENTITY_SET", LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_ENTITY_SET);
+		INTERIOR.set_function("DEACTIVATE_INTERIOR_ENTITY_SET", LUA_NATIVE_INTERIOR_DEACTIVATE_INTERIOR_ENTITY_SET);
+		INTERIOR.set_function("IS_INTERIOR_ENTITY_SET_ACTIVE", LUA_NATIVE_INTERIOR_IS_INTERIOR_ENTITY_SET_ACTIVE);
+		INTERIOR.set_function("SET_INTERIOR_ENTITY_SET_TINT_INDEX", LUA_NATIVE_INTERIOR_SET_INTERIOR_ENTITY_SET_TINT_INDEX);
+		INTERIOR.set_function("REFRESH_INTERIOR", LUA_NATIVE_INTERIOR_REFRESH_INTERIOR);
+		INTERIOR.set_function("ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME", LUA_NATIVE_INTERIOR_ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME);
+		INTERIOR.set_function("ENABLE_SHADOW_CULL_MODEL_THIS_FRAME", LUA_NATIVE_INTERIOR_ENABLE_SHADOW_CULL_MODEL_THIS_FRAME);
+		INTERIOR.set_function("DISABLE_INTERIOR", LUA_NATIVE_INTERIOR_DISABLE_INTERIOR);
+		INTERIOR.set_function("IS_INTERIOR_DISABLED", LUA_NATIVE_INTERIOR_IS_INTERIOR_DISABLED);
+		INTERIOR.set_function("CAP_INTERIOR", LUA_NATIVE_INTERIOR_CAP_INTERIOR);
+		INTERIOR.set_function("IS_INTERIOR_CAPPED", LUA_NATIVE_INTERIOR_IS_INTERIOR_CAPPED);
+		INTERIOR.set_function("DISABLE_METRO_SYSTEM", LUA_NATIVE_INTERIOR_DISABLE_METRO_SYSTEM);
+		INTERIOR.set_function("SET_IS_EXTERIOR_ONLY", LUA_NATIVE_INTERIOR_SET_IS_EXTERIOR_ONLY);
+	}
+}

src/lua/natives/lua_native_binding_ITEMSET.cpp

@@ -0,0 +1,70 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static ScrHandle LUA_NATIVE_ITEMSET_CREATE_ITEMSET( bool p0 )
+	{
+		auto retval = ITEMSET::CREATE_ITEMSET(p0);
+		return retval;
+	}
+
+	static void LUA_NATIVE_ITEMSET_DESTROY_ITEMSET( ScrHandle itemset )
+	{
+		ITEMSET::DESTROY_ITEMSET(itemset);
+	}
+
+	static bool LUA_NATIVE_ITEMSET_IS_ITEMSET_VALID( ScrHandle itemset )
+	{
+		auto retval = (bool)ITEMSET::IS_ITEMSET_VALID(itemset);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_ITEMSET_ADD_TO_ITEMSET( ScrHandle item, ScrHandle itemset )
+	{
+		auto retval = (bool)ITEMSET::ADD_TO_ITEMSET(item, itemset);
+		return retval;
+	}
+
+	static void LUA_NATIVE_ITEMSET_REMOVE_FROM_ITEMSET( ScrHandle item, ScrHandle itemset )
+	{
+		ITEMSET::REMOVE_FROM_ITEMSET(item, itemset);
+	}
+
+	static int LUA_NATIVE_ITEMSET_GET_ITEMSET_SIZE( ScrHandle itemset )
+	{
+		auto retval = ITEMSET::GET_ITEMSET_SIZE(itemset);
+		return retval;
+	}
+
+	static ScrHandle LUA_NATIVE_ITEMSET_GET_INDEXED_ITEM_IN_ITEMSET( int index, ScrHandle itemset )
+	{
+		auto retval = ITEMSET::GET_INDEXED_ITEM_IN_ITEMSET(index, itemset);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_ITEMSET_IS_IN_ITEMSET( ScrHandle item, ScrHandle itemset )
+	{
+		auto retval = (bool)ITEMSET::IS_IN_ITEMSET(item, itemset);
+		return retval;
+	}
+
+	static void LUA_NATIVE_ITEMSET_CLEAN_ITEMSET( ScrHandle itemset )
+	{
+		ITEMSET::CLEAN_ITEMSET(itemset);
+	}
+
+	void init_native_binding_ITEMSET(sol::state& L)
+	{
+		auto ITEMSET = L["ITEMSET"].get_or_create<sol::table>();
+		ITEMSET.set_function("CREATE_ITEMSET", LUA_NATIVE_ITEMSET_CREATE_ITEMSET);
+		ITEMSET.set_function("DESTROY_ITEMSET", LUA_NATIVE_ITEMSET_DESTROY_ITEMSET);
+		ITEMSET.set_function("IS_ITEMSET_VALID", LUA_NATIVE_ITEMSET_IS_ITEMSET_VALID);
+		ITEMSET.set_function("ADD_TO_ITEMSET", LUA_NATIVE_ITEMSET_ADD_TO_ITEMSET);
+		ITEMSET.set_function("REMOVE_FROM_ITEMSET", LUA_NATIVE_ITEMSET_REMOVE_FROM_ITEMSET);
+		ITEMSET.set_function("GET_ITEMSET_SIZE", LUA_NATIVE_ITEMSET_GET_ITEMSET_SIZE);
+		ITEMSET.set_function("GET_INDEXED_ITEM_IN_ITEMSET", LUA_NATIVE_ITEMSET_GET_INDEXED_ITEM_IN_ITEMSET);
+		ITEMSET.set_function("IS_IN_ITEMSET", LUA_NATIVE_ITEMSET_IS_IN_ITEMSET);
+		ITEMSET.set_function("CLEAN_ITEMSET", LUA_NATIVE_ITEMSET_CLEAN_ITEMSET);
+	}
+}

src/lua/natives/lua_native_binding_LOADINGSCREEN.cpp

@@ -0,0 +1,62 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_MENU(  )
+	{
+		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_MENU();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_FREEMODE(  )
+	{
+		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_FREEMODE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER( bool toggle )
+	{
+		LOADINGSCREEN::LOBBY_SET_AUTO_MULTIPLAYER(toggle);
+	}
+
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_EVENT(  )
+	{
+		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_EVENT();
+		return retval;
+	}
+
+	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER_EVENT( bool toggle )
+	{
+		LOADINGSCREEN::LOBBY_SET_AUTO_MULTIPLAYER_EVENT(toggle);
+	}
+
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB(  )
+	{
+		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB();
+		return retval;
+	}
+
+	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MP_RANDOM_JOB( bool toggle )
+	{
+		LOADINGSCREEN::LOBBY_SET_AUTO_MP_RANDOM_JOB(toggle);
+	}
+
+	static void LUA_NATIVE_LOADINGSCREEN_SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER( bool toggle )
+	{
+		LOADINGSCREEN::SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER(toggle);
+	}
+
+	void init_native_binding_LOADINGSCREEN(sol::state& L)
+	{
+		auto LOADINGSCREEN = L["LOADINGSCREEN"].get_or_create<sol::table>();
+		LOADINGSCREEN.set_function("LOBBY_AUTO_MULTIPLAYER_MENU", LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_MENU);
+		LOADINGSCREEN.set_function("LOBBY_AUTO_MULTIPLAYER_FREEMODE", LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_FREEMODE);
+		LOADINGSCREEN.set_function("LOBBY_SET_AUTO_MULTIPLAYER", LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER);
+		LOADINGSCREEN.set_function("LOBBY_AUTO_MULTIPLAYER_EVENT", LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_EVENT);
+		LOADINGSCREEN.set_function("LOBBY_SET_AUTO_MULTIPLAYER_EVENT", LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER_EVENT);
+		LOADINGSCREEN.set_function("LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB", LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB);
+		LOADINGSCREEN.set_function("LOBBY_SET_AUTO_MP_RANDOM_JOB", LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MP_RANDOM_JOB);
+		LOADINGSCREEN.set_function("SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER", LUA_NATIVE_LOADINGSCREEN_SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER);
+	}
+}

src/lua/natives/lua_native_binding_LOCALIZATION.cpp

@@ -0,0 +1,31 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static int LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_LANGUAGE(  )
+	{
+		auto retval = LOCALIZATION::LOCALIZATION_GET_SYSTEM_LANGUAGE();
+		return retval;
+	}
+
+	static int LUA_NATIVE_LOCALIZATION_GET_CURRENT_LANGUAGE(  )
+	{
+		auto retval = LOCALIZATION::GET_CURRENT_LANGUAGE();
+		return retval;
+	}
+
+	static int LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_DATE_TYPE(  )
+	{
+		auto retval = LOCALIZATION::LOCALIZATION_GET_SYSTEM_DATE_TYPE();
+		return retval;
+	}
+
+	void init_native_binding_LOCALIZATION(sol::state& L)
+	{
+		auto LOCALIZATION = L["LOCALIZATION"].get_or_create<sol::table>();
+		LOCALIZATION.set_function("LOCALIZATION_GET_SYSTEM_LANGUAGE", LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_LANGUAGE);
+		LOCALIZATION.set_function("GET_CURRENT_LANGUAGE", LUA_NATIVE_LOCALIZATION_GET_CURRENT_LANGUAGE);
+		LOCALIZATION.set_function("LOCALIZATION_GET_SYSTEM_DATE_TYPE", LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_DATE_TYPE);
+	}
+}

src/lua/natives/lua_native_binding_MOBILE.cpp

@@ -0,0 +1,165 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_MOBILE_CREATE_MOBILE_PHONE( int phoneType )
+	{
+		MOBILE::CREATE_MOBILE_PHONE(phoneType);
+	}
+
+	static void LUA_NATIVE_MOBILE_DESTROY_MOBILE_PHONE(  )
+	{
+		MOBILE::DESTROY_MOBILE_PHONE();
+	}
+
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_SCALE( float scale )
+	{
+		MOBILE::SET_MOBILE_PHONE_SCALE(scale);
+	}
+
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_ROTATION( float rotX, float rotY, float rotZ, Any p3 )
+	{
+		MOBILE::SET_MOBILE_PHONE_ROTATION(rotX, rotY, rotZ, p3);
+	}
+
+	static Vector3 LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_ROTATION( Vector3 rotation, Vehicle p1 )
+	{
+		MOBILE::GET_MOBILE_PHONE_ROTATION(&rotation, p1);
+		return rotation;
+	}
+
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_POSITION( float posX, float posY, float posZ )
+	{
+		MOBILE::SET_MOBILE_PHONE_POSITION(posX, posY, posZ);
+	}
+
+	static Vector3 LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_POSITION( Vector3 position )
+	{
+		MOBILE::GET_MOBILE_PHONE_POSITION(&position);
+		return position;
+	}
+
+	static void LUA_NATIVE_MOBILE_SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN( bool toggle )
+	{
+		MOBILE::SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN(toggle);
+	}
+
+	static bool LUA_NATIVE_MOBILE_CAN_PHONE_BE_SEEN_ON_SCREEN(  )
+	{
+		auto retval = (bool)MOBILE::CAN_PHONE_BE_SEEN_ON_SCREEN();
+		return retval;
+	}
+
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_DOF_STATE( bool toggle )
+	{
+		MOBILE::SET_MOBILE_PHONE_DOF_STATE(toggle);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_SET_INPUT( int direction )
+	{
+		MOBILE::CELL_SET_INPUT(direction);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_HORIZONTAL_MODE_TOGGLE( bool toggle )
+	{
+		MOBILE::CELL_HORIZONTAL_MODE_TOGGLE(toggle);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE( bool p0, bool p1 )
+	{
+		MOBILE::CELL_CAM_ACTIVATE(p0, p1);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SELFIE_MODE( bool toggle )
+	{
+		MOBILE::CELL_CAM_ACTIVATE_SELFIE_MODE(toggle);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE( bool toggle )
+	{
+		MOBILE::CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE(toggle);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING( float p0 )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING(p0);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET( float horizontalPan )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET(horizontalPan);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET( float vertPan )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET(vertPan);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET( float roll )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET(roll);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING( float distanceScaling )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING(distanceScaling);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET( float yaw )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET(yaw);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET( float roll )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET(roll);
+	}
+
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET( float pitch )
+	{
+		MOBILE::CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET(pitch);
+	}
+
+	static bool LUA_NATIVE_MOBILE_CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK( Entity entity )
+	{
+		auto retval = (bool)MOBILE::CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK(entity);
+		return retval;
+	}
+
+	static int LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_RENDER_ID( int renderId )
+	{
+		MOBILE::GET_MOBILE_PHONE_RENDER_ID(&renderId);
+		return renderId;
+	}
+
+	void init_native_binding_MOBILE(sol::state& L)
+	{
+		auto MOBILE = L["MOBILE"].get_or_create<sol::table>();
+		MOBILE.set_function("CREATE_MOBILE_PHONE", LUA_NATIVE_MOBILE_CREATE_MOBILE_PHONE);
+		MOBILE.set_function("DESTROY_MOBILE_PHONE", LUA_NATIVE_MOBILE_DESTROY_MOBILE_PHONE);
+		MOBILE.set_function("SET_MOBILE_PHONE_SCALE", LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_SCALE);
+		MOBILE.set_function("SET_MOBILE_PHONE_ROTATION", LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_ROTATION);
+		MOBILE.set_function("GET_MOBILE_PHONE_ROTATION", LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_ROTATION);
+		MOBILE.set_function("SET_MOBILE_PHONE_POSITION", LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_POSITION);
+		MOBILE.set_function("GET_MOBILE_PHONE_POSITION", LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_POSITION);
+		MOBILE.set_function("SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN", LUA_NATIVE_MOBILE_SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN);
+		MOBILE.set_function("CAN_PHONE_BE_SEEN_ON_SCREEN", LUA_NATIVE_MOBILE_CAN_PHONE_BE_SEEN_ON_SCREEN);
+		MOBILE.set_function("SET_MOBILE_PHONE_DOF_STATE", LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_DOF_STATE);
+		MOBILE.set_function("CELL_SET_INPUT", LUA_NATIVE_MOBILE_CELL_SET_INPUT);
+		MOBILE.set_function("CELL_HORIZONTAL_MODE_TOGGLE", LUA_NATIVE_MOBILE_CELL_HORIZONTAL_MODE_TOGGLE);
+		MOBILE.set_function("CELL_CAM_ACTIVATE", LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE);
+		MOBILE.set_function("CELL_CAM_ACTIVATE_SELFIE_MODE", LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SELFIE_MODE);
+		MOBILE.set_function("CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE", LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET);
+		MOBILE.set_function("CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET", LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET);
+		MOBILE.set_function("CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK", LUA_NATIVE_MOBILE_CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK);
+		MOBILE.set_function("GET_MOBILE_PHONE_RENDER_ID", LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_RENDER_ID);
+	}
+}

src/lua/natives/lua_native_binding_NETSHOPPING.cpp

@@ -0,0 +1,318 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_USE_SERVER_TRANSACTIONS(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_USE_SERVER_TRANSACTIONS();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_IS_VALID( const char* name )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CATALOG_ITEM_IS_VALID(name);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID( Hash hash )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID(hash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_PRICE( Hash itemHash, Hash categoryHash, bool p2 )
+	{
+		auto retval = NETSHOPPING::NET_GAMESERVER_GET_PRICE(itemHash, categoryHash, p2);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_IS_VALID(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CATALOG_IS_VALID();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_CATALOG_CURRENT(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_IS_CATALOG_CURRENT();
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_CATALOG_CLOUD_CRC(  )
+	{
+		auto retval = NETSHOPPING::NET_GAMESERVER_GET_CATALOG_CLOUD_CRC();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_REFRESH_SERVER_CATALOG(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_REFRESH_SERVER_CATALOG();
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS( int state )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS(&state);
+		std::get<1>(return_values) = state;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_INIT_SESSION(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_INIT_SESSION();
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS( int p0 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS(&p0);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION( int charSlot )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_START_SESSION(charSlot);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_PENDING(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_START_SESSION_PENDING();
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS( int p0 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS(&p0);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE( int p0 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE(&p0);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_VALID( int charSlot )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_IS_SESSION_VALID(charSlot);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CLEAR_SESSION( int p0 )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CLEAR_SESSION(p0);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA( int charSlot )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA(charSlot);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_REFRESH_PENDING(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_IS_SESSION_REFRESH_PENDING();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_RESTART( bool inventory, bool playerbalance )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_START_SESSION_RESTART(inventory, playerbalance);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSACTION_IN_PROGRESS(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSACTION_IN_PROGRESS();
+		return retval;
+	}
+
+	static std::tuple<bool, int, bool> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS( int p0, bool p1 )
+	{
+		std::tuple<bool, int, bool> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS(&p0, (BOOL*)&p1);
+		std::get<1>(return_values) = p0;
+		std::get<2>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_START( int transactionId, Hash categoryHash, Hash actionHash, int flags )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_START(&transactionId, categoryHash, actionHash, flags);
+		std::get<1>(return_values) = transactionId;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_END(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_END();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_ACTIVE(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_IS_ACTIVE();
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_ADD_ITEM( Any itemData, int quantity )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_ADD_ITEM(&itemData, quantity);
+		std::get<1>(return_values) = itemData;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_FULL(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_IS_FULL();
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_APPLY_SERVER_DATA( Any p0, Any p1 )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_APPLY_SERVER_DATA(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CHECKOUT_START( int transactionId )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CHECKOUT_START(transactionId);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BEGIN_SERVICE( int transactionId, Hash categoryHash, Hash itemHash, Hash actionTypeHash, int value, int flags )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BEGIN_SERVICE(&transactionId, categoryHash, itemHash, actionTypeHash, value, flags);
+		std::get<1>(return_values) = transactionId;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_END_SERVICE( int transactionId )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_END_SERVICE(transactionId);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER( int slot, bool transfer, Hash reason )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_DELETE_CHARACTER(slot, transfer, reason);
+		return retval;
+	}
+
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS(  )
+	{
+		auto retval = NETSHOPPING::NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET( int charSlot, int amount )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSFER_BANK_TO_WALLET(charSlot, amount);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK( int charSlot, int amount )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSFER_WALLET_TO_BANK(charSlot, amount);
+		return retval;
+	}
+
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS(  )
+	{
+		auto retval = NETSHOPPING::NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS(  )
+	{
+		auto retval = NETSHOPPING::NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED(  )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED( int p0 )
+	{
+		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED(p0);
+		return retval;
+	}
+
+	void init_native_binding_NETSHOPPING(sol::state& L)
+	{
+		auto NETSHOPPING = L["NETSHOPPING"].get_or_create<sol::table>();
+		NETSHOPPING.set_function("NET_GAMESERVER_USE_SERVER_TRANSACTIONS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_USE_SERVER_TRANSACTIONS);
+		NETSHOPPING.set_function("NET_GAMESERVER_CATALOG_ITEM_IS_VALID", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_IS_VALID);
+		NETSHOPPING.set_function("NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID);
+		NETSHOPPING.set_function("NET_GAMESERVER_GET_PRICE", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_PRICE);
+		NETSHOPPING.set_function("NET_GAMESERVER_CATALOG_IS_VALID", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_IS_VALID);
+		NETSHOPPING.set_function("NET_GAMESERVER_IS_CATALOG_CURRENT", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_CATALOG_CURRENT);
+		NETSHOPPING.set_function("NET_GAMESERVER_GET_CATALOG_CLOUD_CRC", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_CATALOG_CLOUD_CRC);
+		NETSHOPPING.set_function("NET_GAMESERVER_REFRESH_SERVER_CATALOG", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_REFRESH_SERVER_CATALOG);
+		NETSHOPPING.set_function("NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS);
+		NETSHOPPING.set_function("NET_GAMESERVER_INIT_SESSION", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_INIT_SESSION);
+		NETSHOPPING.set_function("NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS);
+		NETSHOPPING.set_function("NET_GAMESERVER_START_SESSION", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION);
+		NETSHOPPING.set_function("NET_GAMESERVER_START_SESSION_PENDING", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_PENDING);
+		NETSHOPPING.set_function("NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS);
+		NETSHOPPING.set_function("NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE);
+		NETSHOPPING.set_function("NET_GAMESERVER_IS_SESSION_VALID", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_VALID);
+		NETSHOPPING.set_function("NET_GAMESERVER_CLEAR_SESSION", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CLEAR_SESSION);
+		NETSHOPPING.set_function("NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA);
+		NETSHOPPING.set_function("NET_GAMESERVER_IS_SESSION_REFRESH_PENDING", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_REFRESH_PENDING);
+		NETSHOPPING.set_function("NET_GAMESERVER_START_SESSION_RESTART", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_RESTART);
+		NETSHOPPING.set_function("NET_GAMESERVER_TRANSACTION_IN_PROGRESS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSACTION_IN_PROGRESS);
+		NETSHOPPING.set_function("NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS);
+		NETSHOPPING.set_function("NET_GAMESERVER_BASKET_START", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_START);
+		NETSHOPPING.set_function("NET_GAMESERVER_BASKET_END", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_END);
+		NETSHOPPING.set_function("NET_GAMESERVER_BASKET_IS_ACTIVE", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_ACTIVE);
+		NETSHOPPING.set_function("NET_GAMESERVER_BASKET_ADD_ITEM", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_ADD_ITEM);
+		NETSHOPPING.set_function("NET_GAMESERVER_BASKET_IS_FULL", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_FULL);
+		NETSHOPPING.set_function("NET_GAMESERVER_BASKET_APPLY_SERVER_DATA", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_APPLY_SERVER_DATA);
+		NETSHOPPING.set_function("NET_GAMESERVER_CHECKOUT_START", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CHECKOUT_START);
+		NETSHOPPING.set_function("NET_GAMESERVER_BEGIN_SERVICE", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BEGIN_SERVICE);
+		NETSHOPPING.set_function("NET_GAMESERVER_END_SERVICE", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_END_SERVICE);
+		NETSHOPPING.set_function("NET_GAMESERVER_DELETE_CHARACTER", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER);
+		NETSHOPPING.set_function("NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS);
+		NETSHOPPING.set_function("NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED);
+		NETSHOPPING.set_function("NET_GAMESERVER_TRANSFER_BANK_TO_WALLET", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET);
+		NETSHOPPING.set_function("NET_GAMESERVER_TRANSFER_WALLET_TO_BANK", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK);
+		NETSHOPPING.set_function("NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS);
+		NETSHOPPING.set_function("NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS);
+		NETSHOPPING.set_function("NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED);
+		NETSHOPPING.set_function("NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED", LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED);
+	}
+}

src/lua/natives/lua_native_binding_PAD.cpp

@@ -0,0 +1,330 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static bool LUA_NATIVE_PAD_IS_CONTROL_ENABLED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_CONTROL_ENABLED(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_CONTROL_PRESSED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_CONTROL_PRESSED(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_CONTROL_RELEASED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_CONTROL_RELEASED(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_CONTROL_JUST_PRESSED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_CONTROL_JUST_PRESSED(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_CONTROL_JUST_RELEASED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_CONTROL_JUST_RELEASED(control, action);
+		return retval;
+	}
+
+	static int LUA_NATIVE_PAD_GET_CONTROL_VALUE( int control, int action )
+	{
+		auto retval = PAD::GET_CONTROL_VALUE(control, action);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PAD_GET_CONTROL_NORMAL( int control, int action )
+	{
+		auto retval = PAD::GET_CONTROL_NORMAL(control, action);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PAD_SET_USE_ADJUSTED_MOUSE_COORDS( bool toggle )
+	{
+		PAD::SET_USE_ADJUSTED_MOUSE_COORDS(toggle);
+	}
+
+	static float LUA_NATIVE_PAD_GET_CONTROL_UNBOUND_NORMAL( int control, int action )
+	{
+		auto retval = PAD::GET_CONTROL_UNBOUND_NORMAL(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_SET_CONTROL_VALUE_NEXT_FRAME( int control, int action, float value )
+	{
+		auto retval = (bool)PAD::SET_CONTROL_VALUE_NEXT_FRAME(control, action, value);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_PRESSED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_DISABLED_CONTROL_PRESSED(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_RELEASED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_DISABLED_CONTROL_RELEASED(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_PRESSED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_DISABLED_CONTROL_JUST_PRESSED(control, action);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_RELEASED( int control, int action )
+	{
+		auto retval = (bool)PAD::IS_DISABLED_CONTROL_JUST_RELEASED(control, action);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PAD_GET_DISABLED_CONTROL_NORMAL( int control, int action )
+	{
+		auto retval = PAD::GET_DISABLED_CONTROL_NORMAL(control, action);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PAD_GET_DISABLED_CONTROL_UNBOUND_NORMAL( int control, int action )
+	{
+		auto retval = PAD::GET_DISABLED_CONTROL_UNBOUND_NORMAL(control, action);
+		return retval;
+	}
+
+	static int LUA_NATIVE_PAD_GET_CONTROL_HOW_LONG_AGO( int control )
+	{
+		auto retval = PAD::GET_CONTROL_HOW_LONG_AGO(control);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_USING_KEYBOARD_AND_MOUSE( int control )
+	{
+		auto retval = (bool)PAD::IS_USING_KEYBOARD_AND_MOUSE(control);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_USING_CURSOR( int control )
+	{
+		auto retval = (bool)PAD::IS_USING_CURSOR(control);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_SET_CURSOR_POSITION( float x, float y )
+	{
+		auto retval = (bool)PAD::SET_CURSOR_POSITION(x, y);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_USING_REMOTE_PLAY( int control )
+	{
+		auto retval = (bool)PAD::IS_USING_REMOTE_PLAY(control);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_HAVE_CONTROLS_CHANGED( int control )
+	{
+		auto retval = (bool)PAD::HAVE_CONTROLS_CHANGED(control);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_PAD_GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING( int control, int action, bool allowXOSwap )
+	{
+		auto retval = PAD::GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING(control, action, allowXOSwap);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_PAD_GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING( int control, int controlGroup, bool allowXOSwap )
+	{
+		auto retval = PAD::GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING(control, controlGroup, allowXOSwap);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PAD_SET_CONTROL_LIGHT_EFFECT_COLOR( int control, int red, int green, int blue )
+	{
+		PAD::SET_CONTROL_LIGHT_EFFECT_COLOR(control, red, green, blue);
+	}
+
+	static void LUA_NATIVE_PAD_CLEAR_CONTROL_LIGHT_EFFECT( int control )
+	{
+		PAD::CLEAR_CONTROL_LIGHT_EFFECT(control);
+	}
+
+	static void LUA_NATIVE_PAD_SET_CONTROL_SHAKE( int control, int duration, int frequency )
+	{
+		PAD::SET_CONTROL_SHAKE(control, duration, frequency);
+	}
+
+	static void LUA_NATIVE_PAD_SET_CONTROL_TRIGGER_SHAKE( int control, int leftDuration, int leftFrequency, int rightDuration, int rightFrequency )
+	{
+		PAD::SET_CONTROL_TRIGGER_SHAKE(control, leftDuration, leftFrequency, rightDuration, rightFrequency);
+	}
+
+	static void LUA_NATIVE_PAD_STOP_CONTROL_SHAKE( int control )
+	{
+		PAD::STOP_CONTROL_SHAKE(control);
+	}
+
+	static void LUA_NATIVE_PAD_SET_CONTROL_SHAKE_SUPPRESSED_ID( int control, int uniqueId )
+	{
+		PAD::SET_CONTROL_SHAKE_SUPPRESSED_ID(control, uniqueId);
+	}
+
+	static void LUA_NATIVE_PAD_CLEAR_CONTROL_SHAKE_SUPPRESSED_ID( int control )
+	{
+		PAD::CLEAR_CONTROL_SHAKE_SUPPRESSED_ID(control);
+	}
+
+	static bool LUA_NATIVE_PAD_IS_LOOK_INVERTED(  )
+	{
+		auto retval = (bool)PAD::IS_LOOK_INVERTED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_IS_MOUSE_LOOK_INVERTED(  )
+	{
+		auto retval = (bool)PAD::IS_MOUSE_LOOK_INVERTED();
+		return retval;
+	}
+
+	static int LUA_NATIVE_PAD_GET_LOCAL_PLAYER_AIM_STATE(  )
+	{
+		auto retval = PAD::GET_LOCAL_PLAYER_AIM_STATE();
+		return retval;
+	}
+
+	static int LUA_NATIVE_PAD_GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE(  )
+	{
+		auto retval = PAD::GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_HANDBRAKE(  )
+	{
+		auto retval = (bool)PAD::GET_IS_USING_ALTERNATE_HANDBRAKE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_DRIVEBY(  )
+	{
+		auto retval = (bool)PAD::GET_IS_USING_ALTERNATE_DRIVEBY();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_GET_ALLOW_MOVEMENT_WHILE_ZOOMED(  )
+	{
+		auto retval = (bool)PAD::GET_ALLOW_MOVEMENT_WHILE_ZOOMED();
+		return retval;
+	}
+
+	static void LUA_NATIVE_PAD_SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED( bool toggle )
+	{
+		PAD::SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED(toggle);
+	}
+
+	static void LUA_NATIVE_PAD_SET_INPUT_EXCLUSIVE( int control, int action )
+	{
+		PAD::SET_INPUT_EXCLUSIVE(control, action);
+	}
+
+	static void LUA_NATIVE_PAD_DISABLE_CONTROL_ACTION( int control, int action, bool disableRelatedActions )
+	{
+		PAD::DISABLE_CONTROL_ACTION(control, action, disableRelatedActions);
+	}
+
+	static void LUA_NATIVE_PAD_ENABLE_CONTROL_ACTION( int control, int action, bool enableRelatedActions )
+	{
+		PAD::ENABLE_CONTROL_ACTION(control, action, enableRelatedActions);
+	}
+
+	static void LUA_NATIVE_PAD_DISABLE_ALL_CONTROL_ACTIONS( int control )
+	{
+		PAD::DISABLE_ALL_CONTROL_ACTIONS(control);
+	}
+
+	static void LUA_NATIVE_PAD_ENABLE_ALL_CONTROL_ACTIONS( int control )
+	{
+		PAD::ENABLE_ALL_CONTROL_ACTIONS(control);
+	}
+
+	static bool LUA_NATIVE_PAD_INIT_PC_SCRIPTED_CONTROLS( const char* schemeName )
+	{
+		auto retval = (bool)PAD::INIT_PC_SCRIPTED_CONTROLS(schemeName);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PAD_SWITCH_PC_SCRIPTED_CONTROLS( const char* schemeName )
+	{
+		auto retval = (bool)PAD::SWITCH_PC_SCRIPTED_CONTROLS(schemeName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PAD_SHUTDOWN_PC_SCRIPTED_CONTROLS(  )
+	{
+		PAD::SHUTDOWN_PC_SCRIPTED_CONTROLS();
+	}
+
+	static void LUA_NATIVE_PAD_ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT( int control )
+	{
+		PAD::ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT(control);
+	}
+
+	void init_native_binding_PAD(sol::state& L)
+	{
+		auto PAD = L["PAD"].get_or_create<sol::table>();
+		PAD.set_function("IS_CONTROL_ENABLED", LUA_NATIVE_PAD_IS_CONTROL_ENABLED);
+		PAD.set_function("IS_CONTROL_PRESSED", LUA_NATIVE_PAD_IS_CONTROL_PRESSED);
+		PAD.set_function("IS_CONTROL_RELEASED", LUA_NATIVE_PAD_IS_CONTROL_RELEASED);
+		PAD.set_function("IS_CONTROL_JUST_PRESSED", LUA_NATIVE_PAD_IS_CONTROL_JUST_PRESSED);
+		PAD.set_function("IS_CONTROL_JUST_RELEASED", LUA_NATIVE_PAD_IS_CONTROL_JUST_RELEASED);
+		PAD.set_function("GET_CONTROL_VALUE", LUA_NATIVE_PAD_GET_CONTROL_VALUE);
+		PAD.set_function("GET_CONTROL_NORMAL", LUA_NATIVE_PAD_GET_CONTROL_NORMAL);
+		PAD.set_function("SET_USE_ADJUSTED_MOUSE_COORDS", LUA_NATIVE_PAD_SET_USE_ADJUSTED_MOUSE_COORDS);
+		PAD.set_function("GET_CONTROL_UNBOUND_NORMAL", LUA_NATIVE_PAD_GET_CONTROL_UNBOUND_NORMAL);
+		PAD.set_function("SET_CONTROL_VALUE_NEXT_FRAME", LUA_NATIVE_PAD_SET_CONTROL_VALUE_NEXT_FRAME);
+		PAD.set_function("IS_DISABLED_CONTROL_PRESSED", LUA_NATIVE_PAD_IS_DISABLED_CONTROL_PRESSED);
+		PAD.set_function("IS_DISABLED_CONTROL_RELEASED", LUA_NATIVE_PAD_IS_DISABLED_CONTROL_RELEASED);
+		PAD.set_function("IS_DISABLED_CONTROL_JUST_PRESSED", LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_PRESSED);
+		PAD.set_function("IS_DISABLED_CONTROL_JUST_RELEASED", LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_RELEASED);
+		PAD.set_function("GET_DISABLED_CONTROL_NORMAL", LUA_NATIVE_PAD_GET_DISABLED_CONTROL_NORMAL);
+		PAD.set_function("GET_DISABLED_CONTROL_UNBOUND_NORMAL", LUA_NATIVE_PAD_GET_DISABLED_CONTROL_UNBOUND_NORMAL);
+		PAD.set_function("GET_CONTROL_HOW_LONG_AGO", LUA_NATIVE_PAD_GET_CONTROL_HOW_LONG_AGO);
+		PAD.set_function("IS_USING_KEYBOARD_AND_MOUSE", LUA_NATIVE_PAD_IS_USING_KEYBOARD_AND_MOUSE);
+		PAD.set_function("IS_USING_CURSOR", LUA_NATIVE_PAD_IS_USING_CURSOR);
+		PAD.set_function("SET_CURSOR_POSITION", LUA_NATIVE_PAD_SET_CURSOR_POSITION);
+		PAD.set_function("IS_USING_REMOTE_PLAY", LUA_NATIVE_PAD_IS_USING_REMOTE_PLAY);
+		PAD.set_function("HAVE_CONTROLS_CHANGED", LUA_NATIVE_PAD_HAVE_CONTROLS_CHANGED);
+		PAD.set_function("GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING", LUA_NATIVE_PAD_GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING);
+		PAD.set_function("GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING", LUA_NATIVE_PAD_GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING);
+		PAD.set_function("SET_CONTROL_LIGHT_EFFECT_COLOR", LUA_NATIVE_PAD_SET_CONTROL_LIGHT_EFFECT_COLOR);
+		PAD.set_function("CLEAR_CONTROL_LIGHT_EFFECT", LUA_NATIVE_PAD_CLEAR_CONTROL_LIGHT_EFFECT);
+		PAD.set_function("SET_CONTROL_SHAKE", LUA_NATIVE_PAD_SET_CONTROL_SHAKE);
+		PAD.set_function("SET_CONTROL_TRIGGER_SHAKE", LUA_NATIVE_PAD_SET_CONTROL_TRIGGER_SHAKE);
+		PAD.set_function("STOP_CONTROL_SHAKE", LUA_NATIVE_PAD_STOP_CONTROL_SHAKE);
+		PAD.set_function("SET_CONTROL_SHAKE_SUPPRESSED_ID", LUA_NATIVE_PAD_SET_CONTROL_SHAKE_SUPPRESSED_ID);
+		PAD.set_function("CLEAR_CONTROL_SHAKE_SUPPRESSED_ID", LUA_NATIVE_PAD_CLEAR_CONTROL_SHAKE_SUPPRESSED_ID);
+		PAD.set_function("IS_LOOK_INVERTED", LUA_NATIVE_PAD_IS_LOOK_INVERTED);
+		PAD.set_function("IS_MOUSE_LOOK_INVERTED", LUA_NATIVE_PAD_IS_MOUSE_LOOK_INVERTED);
+		PAD.set_function("GET_LOCAL_PLAYER_AIM_STATE", LUA_NATIVE_PAD_GET_LOCAL_PLAYER_AIM_STATE);
+		PAD.set_function("GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE", LUA_NATIVE_PAD_GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE);
+		PAD.set_function("GET_IS_USING_ALTERNATE_HANDBRAKE", LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_HANDBRAKE);
+		PAD.set_function("GET_IS_USING_ALTERNATE_DRIVEBY", LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_DRIVEBY);
+		PAD.set_function("GET_ALLOW_MOVEMENT_WHILE_ZOOMED", LUA_NATIVE_PAD_GET_ALLOW_MOVEMENT_WHILE_ZOOMED);
+		PAD.set_function("SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED", LUA_NATIVE_PAD_SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED);
+		PAD.set_function("SET_INPUT_EXCLUSIVE", LUA_NATIVE_PAD_SET_INPUT_EXCLUSIVE);
+		PAD.set_function("DISABLE_CONTROL_ACTION", LUA_NATIVE_PAD_DISABLE_CONTROL_ACTION);
+		PAD.set_function("ENABLE_CONTROL_ACTION", LUA_NATIVE_PAD_ENABLE_CONTROL_ACTION);
+		PAD.set_function("DISABLE_ALL_CONTROL_ACTIONS", LUA_NATIVE_PAD_DISABLE_ALL_CONTROL_ACTIONS);
+		PAD.set_function("ENABLE_ALL_CONTROL_ACTIONS", LUA_NATIVE_PAD_ENABLE_ALL_CONTROL_ACTIONS);
+		PAD.set_function("INIT_PC_SCRIPTED_CONTROLS", LUA_NATIVE_PAD_INIT_PC_SCRIPTED_CONTROLS);
+		PAD.set_function("SWITCH_PC_SCRIPTED_CONTROLS", LUA_NATIVE_PAD_SWITCH_PC_SCRIPTED_CONTROLS);
+		PAD.set_function("SHUTDOWN_PC_SCRIPTED_CONTROLS", LUA_NATIVE_PAD_SHUTDOWN_PC_SCRIPTED_CONTROLS);
+		PAD.set_function("ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT", LUA_NATIVE_PAD_ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT);
+	}
+}

src/lua/natives/lua_native_binding_PATHFIND.cpp

@@ -0,0 +1,476 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2, bool nodeEnabled, bool unknown2 )
+	{
+		PATHFIND::SET_ROADS_IN_AREA(x1, y1, z1, x2, y2, z2, nodeEnabled, unknown2);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_IN_ANGLED_AREA( float x1, float y1, float z1, float x2, float y2, float z2, float width, bool unknown1, bool unknown2, bool unknown3 )
+	{
+		PATHFIND::SET_ROADS_IN_ANGLED_AREA(x1, y1, z1, x2, y2, z2, width, unknown1, unknown2, unknown3);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_PED_PATHS_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2, bool p6, Any p7 )
+	{
+		PATHFIND::SET_PED_PATHS_IN_AREA(x1, y1, z1, x2, y2, z2, p6, p7);
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_SAFE_COORD_FOR_PED( float x, float y, float z, bool onGround, Vector3 outPosition, int flags )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_SAFE_COORD_FOR_PED(x, y, z, onGround, &outPosition, flags);
+		std::get<1>(return_values) = outPosition;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE( float x, float y, float z, Vector3 outPosition, int nodeFlags, float p5, float p6 )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_VEHICLE_NODE(x, y, z, &outPosition, nodeFlags, p5, p6);
+		std::get<1>(return_values) = outPosition;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_CLOSEST_MAJOR_VEHICLE_NODE( float x, float y, float z, Vector3 outPosition, float unknown1, float unknown2 )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_MAJOR_VEHICLE_NODE(x, y, z, &outPosition, unknown1, unknown2);
+		std::get<1>(return_values) = outPosition;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Vector3, float> LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE_WITH_HEADING( float x, float y, float z, Vector3 outPosition, float outHeading, int nodeType, float p6, float p7 )
+	{
+		std::tuple<bool, Vector3, float> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_VEHICLE_NODE_WITH_HEADING(x, y, z, &outPosition, &outHeading, nodeType, p6, p7);
+		std::get<1>(return_values) = outPosition;
+		std::get<2>(return_values) = outHeading;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE( float x, float y, float z, int nthClosest, Vector3 outPosition, int nodeFlags, float unknown1, float unknown2 )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE(x, y, z, nthClosest, &outPosition, nodeFlags, unknown1, unknown2);
+		std::get<1>(return_values) = outPosition;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID( float x, float y, float z, int nth, int nodeFlags, float p5, float p6 )
+	{
+		auto retval = PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_ID(x, y, z, nth, nodeFlags, p5, p6);
+		return retval;
+	}
+
+	static std::tuple<bool, Vector3, float, int> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING( float x, float y, float z, int nthClosest, Vector3 outPosition, float outHeading, int outNumLanes, int nodeFlags, float unknown3, float unknown4 )
+	{
+		std::tuple<bool, Vector3, float, int> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING(x, y, z, nthClosest, &outPosition, &outHeading, &outNumLanes, nodeFlags, unknown3, unknown4);
+		std::get<1>(return_values) = outPosition;
+		std::get<2>(return_values) = outHeading;
+		std::get<3>(return_values) = outNumLanes;
+
+		return return_values;
+	}
+
+	static std::tuple<int, Vector3, float> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING( float x, float y, float z, int nthClosest, Vector3 outPosition, float outHeading, int nodeFlags, float p7, float p8 )
+	{
+		std::tuple<int, Vector3, float> return_values;
+		std::get<0>(return_values) = PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING(x, y, z, nthClosest, &outPosition, &outHeading, nodeFlags, p7, p8);
+		std::get<1>(return_values) = outPosition;
+		std::get<2>(return_values) = outHeading;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Vector3, float> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION( float x, float y, float z, float desiredX, float desiredY, float desiredZ, int nthClosest, Vector3 outPosition, float outHeading, int nodeFlags, float p10, float p11 )
+	{
+		std::tuple<bool, Vector3, float> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION(x, y, z, desiredX, desiredY, desiredZ, nthClosest, &outPosition, &outHeading, nodeFlags, p10, p11);
+		std::get<1>(return_values) = outPosition;
+		std::get<2>(return_values) = outHeading;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, int, int> LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_PROPERTIES( float x, float y, float z, int density, int flags )
+	{
+		std::tuple<bool, int, int> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_VEHICLE_NODE_PROPERTIES(x, y, z, &density, &flags);
+		std::get<1>(return_values) = density;
+		std::get<2>(return_values) = flags;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_IS_VEHICLE_NODE_ID_VALID( int vehicleNodeId )
+	{
+		auto retval = (bool)PATHFIND::IS_VEHICLE_NODE_ID_VALID(vehicleNodeId);
+		return retval;
+	}
+
+	static Vector3 LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_POSITION( int nodeId, Vector3 outPosition )
+	{
+		PATHFIND::GET_VEHICLE_NODE_POSITION(nodeId, &outPosition);
+		return outPosition;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_GPS_ALLOWED( int nodeID )
+	{
+		auto retval = (bool)PATHFIND::GET_VEHICLE_NODE_IS_GPS_ALLOWED(nodeID);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_SWITCHED_OFF( int nodeID )
+	{
+		auto retval = (bool)PATHFIND::GET_VEHICLE_NODE_IS_SWITCHED_OFF(nodeID);
+		return retval;
+	}
+
+	static std::tuple<bool, Vector3, Vector3, Any, Any, float> LUA_NATIVE_PATHFIND_GET_CLOSEST_ROAD( float x, float y, float z, float p3, int p4, Vector3 p5, Vector3 p6, Any p7, Any p8, float p9, bool p10 )
+	{
+		std::tuple<bool, Vector3, Vector3, Any, Any, float> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_ROAD(x, y, z, p3, p4, &p5, &p6, &p7, &p8, &p9, p10);
+		std::get<1>(return_values) = p5;
+		std::get<2>(return_values) = p6;
+		std::get<3>(return_values) = p7;
+		std::get<4>(return_values) = p8;
+		std::get<5>(return_values) = p9;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_LOAD_ALL_PATH_NODES( bool set )
+	{
+		auto retval = (bool)PATHFIND::LOAD_ALL_PATH_NODES(set);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_PROLOGUE_NODES( bool toggle )
+	{
+		PATHFIND::SET_ALLOW_STREAM_PROLOGUE_NODES(toggle);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_HEIST_ISLAND_NODES( int type )
+	{
+		PATHFIND::SET_ALLOW_STREAM_HEIST_ISLAND_NODES(type);
+	}
+
+	static bool LUA_NATIVE_PATHFIND_ARE_NODES_LOADED_FOR_AREA( float x1, float y1, float x2, float y2 )
+	{
+		auto retval = (bool)PATHFIND::ARE_NODES_LOADED_FOR_AREA(x1, y1, x2, y2);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_REQUEST_PATH_NODES_IN_AREA_THIS_FRAME( float x1, float y1, float x2, float y2 )
+	{
+		auto retval = (bool)PATHFIND::REQUEST_PATH_NODES_IN_AREA_THIS_FRAME(x1, y1, x2, y2);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL( float p0, float p1, float p2, float p3, float p4, float p5, Any p6 )
+	{
+		PATHFIND::SET_ROADS_BACK_TO_ORIGINAL(p0, p1, p2, p3, p4, p5, p6);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA( float x1, float y1, float z1, float x2, float y2, float z2, float width, Any p7 )
+	{
+		PATHFIND::SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(x1, y1, z1, x2, y2, z2, width, p7);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME( float multiplier )
+	{
+		PATHFIND::SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME(multiplier);
+	}
+
+	static void LUA_NATIVE_PATHFIND_ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME( Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6 )
+	{
+		PATHFIND::ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME(p0, p1, p2, p3, p4, p5, p6);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_PED_PATHS_BACK_TO_ORIGINAL( float x1, float y1, float z1, float x2, float y2, float z2, Any p6 )
+	{
+		PATHFIND::SET_PED_PATHS_BACK_TO_ORIGINAL(x1, y1, z1, x2, y2, z2, p6);
+	}
+
+	static std::tuple<bool, Vector3, int> LUA_NATIVE_PATHFIND_GET_RANDOM_VEHICLE_NODE( float x, float y, float z, float radius, bool p4, bool p5, bool p6, Vector3 outPosition, int nodeId )
+	{
+		std::tuple<bool, Vector3, int> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_RANDOM_VEHICLE_NODE(x, y, z, radius, p4, p5, p6, &outPosition, &nodeId);
+		std::get<1>(return_values) = outPosition;
+		std::get<2>(return_values) = nodeId;
+
+		return return_values;
+	}
+
+	static std::tuple<Vector3, Vector3, float> LUA_NATIVE_PATHFIND_GET_SPAWN_COORDS_FOR_VEHICLE_NODE( int nodeAddress, float towardsCoorsX, float towardsCoorsY, float towardsCoorsZ, Vector3 centrePoint, float heading )
+	{
+		std::tuple<Vector3, Vector3, float> return_values;
+		std::get<0>(return_values) = PATHFIND::GET_SPAWN_COORDS_FOR_VEHICLE_NODE(nodeAddress, towardsCoorsX, towardsCoorsY, towardsCoorsZ, &centrePoint, &heading);
+		std::get<1>(return_values) = centrePoint;
+		std::get<2>(return_values) = heading;
+
+		return return_values;
+	}
+
+	static std::tuple<Hash, Hash> LUA_NATIVE_PATHFIND_GET_STREET_NAME_AT_COORD( float x, float y, float z, Hash streetName, Hash crossingRoad )
+	{
+		std::tuple<Hash, Hash> return_values;
+		PATHFIND::GET_STREET_NAME_AT_COORD(x, y, z, &streetName, &crossingRoad);
+		std::get<0>(return_values) = streetName;
+		std::get<1>(return_values) = crossingRoad;
+
+		return return_values;
+	}
+
+	static std::tuple<int, int, float, float> LUA_NATIVE_PATHFIND_GENERATE_DIRECTIONS_TO_COORD( float x, float y, float z, bool p3, int direction, float p5, float distToNxJunction )
+	{
+		std::tuple<int, int, float, float> return_values;
+		std::get<0>(return_values) = PATHFIND::GENERATE_DIRECTIONS_TO_COORD(x, y, z, p3, &direction, &p5, &distToNxJunction);
+		std::get<1>(return_values) = direction;
+		std::get<2>(return_values) = p5;
+		std::get<3>(return_values) = distToNxJunction;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG( bool toggle )
+	{
+		PATHFIND::SET_IGNORE_NO_GPS_FLAG(toggle);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE( bool toggle )
+	{
+		PATHFIND::SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE(toggle);
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE( float x1, float y1, float z1, float x2, float y2, float z3 )
+	{
+		PATHFIND::SET_GPS_DISABLED_ZONE(x1, y1, z1, x2, y2, z3);
+	}
+
+	static int LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_LENGTH(  )
+	{
+		auto retval = PATHFIND::GET_GPS_BLIP_ROUTE_LENGTH();
+		return retval;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_POS_ALONG_GPS_TYPE_ROUTE( Vector3 result, bool p1, float p2, int p3 )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_POS_ALONG_GPS_TYPE_ROUTE(&result, p1, p2, p3);
+		std::get<1>(return_values) = result;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_FOUND(  )
+	{
+		auto retval = (bool)PATHFIND::GET_GPS_BLIP_ROUTE_FOUND();
+		return retval;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_ROAD_BOUNDARY_USING_HEADING( float x, float y, float z, float heading, Vector3 outPosition )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_ROAD_BOUNDARY_USING_HEADING(x, y, z, heading, &outPosition);
+		std::get<1>(return_values) = outPosition;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_POSITION_BY_SIDE_OF_ROAD( float x, float y, float z, int p3, Vector3 outPosition )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)PATHFIND::GET_POSITION_BY_SIDE_OF_ROAD(x, y, z, p3, &outPosition);
+		std::get<1>(return_values) = outPosition;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_IS_POINT_ON_ROAD( float x, float y, float z, Vehicle vehicle )
+	{
+		auto retval = (bool)PATHFIND::IS_POINT_ON_ROAD(x, y, z, vehicle);
+		return retval;
+	}
+
+	static int LUA_NATIVE_PATHFIND_GET_NEXT_GPS_DISABLED_ZONE_INDEX(  )
+	{
+		auto retval = PATHFIND::GET_NEXT_GPS_DISABLED_ZONE_INDEX();
+		return retval;
+	}
+
+	static void LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE_AT_INDEX( float x1, float y1, float z1, float x2, float y2, float z2, int index )
+	{
+		PATHFIND::SET_GPS_DISABLED_ZONE_AT_INDEX(x1, y1, z1, x2, y2, z2, index);
+	}
+
+	static void LUA_NATIVE_PATHFIND_CLEAR_GPS_DISABLED_ZONE_AT_INDEX( int index )
+	{
+		PATHFIND::CLEAR_GPS_DISABLED_ZONE_AT_INDEX(index);
+	}
+
+	static void LUA_NATIVE_PATHFIND_ADD_NAVMESH_REQUIRED_REGION( float x, float y, float radius )
+	{
+		PATHFIND::ADD_NAVMESH_REQUIRED_REGION(x, y, radius);
+	}
+
+	static void LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_REQUIRED_REGIONS(  )
+	{
+		PATHFIND::REMOVE_NAVMESH_REQUIRED_REGIONS();
+	}
+
+	static bool LUA_NATIVE_PATHFIND_IS_NAVMESH_REQUIRED_REGION_IN_USE(  )
+	{
+		auto retval = (bool)PATHFIND::IS_NAVMESH_REQUIRED_REGION_IN_USE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_PATHFIND_DISABLE_NAVMESH_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2, bool toggle )
+	{
+		PATHFIND::DISABLE_NAVMESH_IN_AREA(x1, y1, z1, x2, y2, z2, toggle);
+	}
+
+	static bool LUA_NATIVE_PATHFIND_ARE_ALL_NAVMESH_REGIONS_LOADED(  )
+	{
+		auto retval = (bool)PATHFIND::ARE_ALL_NAVMESH_REGIONS_LOADED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_PATHFIND_IS_NAVMESH_LOADED_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = (bool)PATHFIND::IS_NAVMESH_LOADED_IN_AREA(x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	static int LUA_NATIVE_PATHFIND_GET_NUM_NAVMESHES_EXISTING_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = PATHFIND::GET_NUM_NAVMESHES_EXISTING_IN_AREA(x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	static int LUA_NATIVE_PATHFIND_ADD_NAVMESH_BLOCKING_OBJECT( float p0, float p1, float p2, float p3, float p4, float p5, float p6, bool p7, Any p8 )
+	{
+		auto retval = PATHFIND::ADD_NAVMESH_BLOCKING_OBJECT(p0, p1, p2, p3, p4, p5, p6, p7, p8);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PATHFIND_UPDATE_NAVMESH_BLOCKING_OBJECT( Any p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, Any p8 )
+	{
+		PATHFIND::UPDATE_NAVMESH_BLOCKING_OBJECT(p0, p1, p2, p3, p4, p5, p6, p7, p8);
+	}
+
+	static void LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_BLOCKING_OBJECT( Any p0 )
+	{
+		PATHFIND::REMOVE_NAVMESH_BLOCKING_OBJECT(p0);
+	}
+
+	static bool LUA_NATIVE_PATHFIND_DOES_NAVMESH_BLOCKING_OBJECT_EXIST( Any p0 )
+	{
+		auto retval = (bool)PATHFIND::DOES_NAVMESH_BLOCKING_OBJECT_EXIST(p0);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_POINT( float x, float y )
+	{
+		auto retval = PATHFIND::GET_APPROX_HEIGHT_FOR_POINT(x, y);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_AREA( float x1, float y1, float x2, float y2 )
+	{
+		auto retval = PATHFIND::GET_APPROX_HEIGHT_FOR_AREA(x1, y1, x2, y2);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_POINT( float x, float y )
+	{
+		auto retval = PATHFIND::GET_APPROX_FLOOR_FOR_POINT(x, y);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_AREA( float x1, float y1, float x2, float y2 )
+	{
+		auto retval = PATHFIND::GET_APPROX_FLOOR_FOR_AREA(x1, y1, x2, y2);
+		return retval;
+	}
+
+	static float LUA_NATIVE_PATHFIND_CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS( float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = PATHFIND::CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS(x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	void init_native_binding_PATHFIND(sol::state& L)
+	{
+		auto PATHFIND = L["PATHFIND"].get_or_create<sol::table>();
+		PATHFIND.set_function("SET_ROADS_IN_AREA", LUA_NATIVE_PATHFIND_SET_ROADS_IN_AREA);
+		PATHFIND.set_function("SET_ROADS_IN_ANGLED_AREA", LUA_NATIVE_PATHFIND_SET_ROADS_IN_ANGLED_AREA);
+		PATHFIND.set_function("SET_PED_PATHS_IN_AREA", LUA_NATIVE_PATHFIND_SET_PED_PATHS_IN_AREA);
+		PATHFIND.set_function("GET_SAFE_COORD_FOR_PED", LUA_NATIVE_PATHFIND_GET_SAFE_COORD_FOR_PED);
+		PATHFIND.set_function("GET_CLOSEST_VEHICLE_NODE", LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE);
+		PATHFIND.set_function("GET_CLOSEST_MAJOR_VEHICLE_NODE", LUA_NATIVE_PATHFIND_GET_CLOSEST_MAJOR_VEHICLE_NODE);
+		PATHFIND.set_function("GET_CLOSEST_VEHICLE_NODE_WITH_HEADING", LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE_WITH_HEADING);
+		PATHFIND.set_function("GET_NTH_CLOSEST_VEHICLE_NODE", LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE);
+		PATHFIND.set_function("GET_NTH_CLOSEST_VEHICLE_NODE_ID", LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID);
+		PATHFIND.set_function("GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING", LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING);
+		PATHFIND.set_function("GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING", LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING);
+		PATHFIND.set_function("GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION", LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION);
+		PATHFIND.set_function("GET_VEHICLE_NODE_PROPERTIES", LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_PROPERTIES);
+		PATHFIND.set_function("IS_VEHICLE_NODE_ID_VALID", LUA_NATIVE_PATHFIND_IS_VEHICLE_NODE_ID_VALID);
+		PATHFIND.set_function("GET_VEHICLE_NODE_POSITION", LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_POSITION);
+		PATHFIND.set_function("GET_VEHICLE_NODE_IS_GPS_ALLOWED", LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_GPS_ALLOWED);
+		PATHFIND.set_function("GET_VEHICLE_NODE_IS_SWITCHED_OFF", LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_SWITCHED_OFF);
+		PATHFIND.set_function("GET_CLOSEST_ROAD", LUA_NATIVE_PATHFIND_GET_CLOSEST_ROAD);
+		PATHFIND.set_function("LOAD_ALL_PATH_NODES", LUA_NATIVE_PATHFIND_LOAD_ALL_PATH_NODES);
+		PATHFIND.set_function("SET_ALLOW_STREAM_PROLOGUE_NODES", LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_PROLOGUE_NODES);
+		PATHFIND.set_function("SET_ALLOW_STREAM_HEIST_ISLAND_NODES", LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_HEIST_ISLAND_NODES);
+		PATHFIND.set_function("ARE_NODES_LOADED_FOR_AREA", LUA_NATIVE_PATHFIND_ARE_NODES_LOADED_FOR_AREA);
+		PATHFIND.set_function("REQUEST_PATH_NODES_IN_AREA_THIS_FRAME", LUA_NATIVE_PATHFIND_REQUEST_PATH_NODES_IN_AREA_THIS_FRAME);
+		PATHFIND.set_function("SET_ROADS_BACK_TO_ORIGINAL", LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL);
+		PATHFIND.set_function("SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA", LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA);
+		PATHFIND.set_function("SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME", LUA_NATIVE_PATHFIND_SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME);
+		PATHFIND.set_function("ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME", LUA_NATIVE_PATHFIND_ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME);
+		PATHFIND.set_function("SET_PED_PATHS_BACK_TO_ORIGINAL", LUA_NATIVE_PATHFIND_SET_PED_PATHS_BACK_TO_ORIGINAL);
+		PATHFIND.set_function("GET_RANDOM_VEHICLE_NODE", LUA_NATIVE_PATHFIND_GET_RANDOM_VEHICLE_NODE);
+		PATHFIND.set_function("GET_SPAWN_COORDS_FOR_VEHICLE_NODE", LUA_NATIVE_PATHFIND_GET_SPAWN_COORDS_FOR_VEHICLE_NODE);
+		PATHFIND.set_function("GET_STREET_NAME_AT_COORD", LUA_NATIVE_PATHFIND_GET_STREET_NAME_AT_COORD);
+		PATHFIND.set_function("GENERATE_DIRECTIONS_TO_COORD", LUA_NATIVE_PATHFIND_GENERATE_DIRECTIONS_TO_COORD);
+		PATHFIND.set_function("SET_IGNORE_NO_GPS_FLAG", LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG);
+		PATHFIND.set_function("SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE", LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE);
+		PATHFIND.set_function("SET_GPS_DISABLED_ZONE", LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE);
+		PATHFIND.set_function("GET_GPS_BLIP_ROUTE_LENGTH", LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_LENGTH);
+		PATHFIND.set_function("GET_POS_ALONG_GPS_TYPE_ROUTE", LUA_NATIVE_PATHFIND_GET_POS_ALONG_GPS_TYPE_ROUTE);
+		PATHFIND.set_function("GET_GPS_BLIP_ROUTE_FOUND", LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_FOUND);
+		PATHFIND.set_function("GET_ROAD_BOUNDARY_USING_HEADING", LUA_NATIVE_PATHFIND_GET_ROAD_BOUNDARY_USING_HEADING);
+		PATHFIND.set_function("GET_POSITION_BY_SIDE_OF_ROAD", LUA_NATIVE_PATHFIND_GET_POSITION_BY_SIDE_OF_ROAD);
+		PATHFIND.set_function("IS_POINT_ON_ROAD", LUA_NATIVE_PATHFIND_IS_POINT_ON_ROAD);
+		PATHFIND.set_function("GET_NEXT_GPS_DISABLED_ZONE_INDEX", LUA_NATIVE_PATHFIND_GET_NEXT_GPS_DISABLED_ZONE_INDEX);
+		PATHFIND.set_function("SET_GPS_DISABLED_ZONE_AT_INDEX", LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE_AT_INDEX);
+		PATHFIND.set_function("CLEAR_GPS_DISABLED_ZONE_AT_INDEX", LUA_NATIVE_PATHFIND_CLEAR_GPS_DISABLED_ZONE_AT_INDEX);
+		PATHFIND.set_function("ADD_NAVMESH_REQUIRED_REGION", LUA_NATIVE_PATHFIND_ADD_NAVMESH_REQUIRED_REGION);
+		PATHFIND.set_function("REMOVE_NAVMESH_REQUIRED_REGIONS", LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_REQUIRED_REGIONS);
+		PATHFIND.set_function("IS_NAVMESH_REQUIRED_REGION_IN_USE", LUA_NATIVE_PATHFIND_IS_NAVMESH_REQUIRED_REGION_IN_USE);
+		PATHFIND.set_function("DISABLE_NAVMESH_IN_AREA", LUA_NATIVE_PATHFIND_DISABLE_NAVMESH_IN_AREA);
+		PATHFIND.set_function("ARE_ALL_NAVMESH_REGIONS_LOADED", LUA_NATIVE_PATHFIND_ARE_ALL_NAVMESH_REGIONS_LOADED);
+		PATHFIND.set_function("IS_NAVMESH_LOADED_IN_AREA", LUA_NATIVE_PATHFIND_IS_NAVMESH_LOADED_IN_AREA);
+		PATHFIND.set_function("GET_NUM_NAVMESHES_EXISTING_IN_AREA", LUA_NATIVE_PATHFIND_GET_NUM_NAVMESHES_EXISTING_IN_AREA);
+		PATHFIND.set_function("ADD_NAVMESH_BLOCKING_OBJECT", LUA_NATIVE_PATHFIND_ADD_NAVMESH_BLOCKING_OBJECT);
+		PATHFIND.set_function("UPDATE_NAVMESH_BLOCKING_OBJECT", LUA_NATIVE_PATHFIND_UPDATE_NAVMESH_BLOCKING_OBJECT);
+		PATHFIND.set_function("REMOVE_NAVMESH_BLOCKING_OBJECT", LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_BLOCKING_OBJECT);
+		PATHFIND.set_function("DOES_NAVMESH_BLOCKING_OBJECT_EXIST", LUA_NATIVE_PATHFIND_DOES_NAVMESH_BLOCKING_OBJECT_EXIST);
+		PATHFIND.set_function("GET_APPROX_HEIGHT_FOR_POINT", LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_POINT);
+		PATHFIND.set_function("GET_APPROX_HEIGHT_FOR_AREA", LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_AREA);
+		PATHFIND.set_function("GET_APPROX_FLOOR_FOR_POINT", LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_POINT);
+		PATHFIND.set_function("GET_APPROX_FLOOR_FOR_AREA", LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_AREA);
+		PATHFIND.set_function("CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS", LUA_NATIVE_PATHFIND_CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS);
+	}
+}

src/lua/natives/lua_native_binding_PHYSICS.cpp

@@ -0,0 +1,326 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static std::tuple<int, Any> LUA_NATIVE_PHYSICS_ADD_ROPE( float x, float y, float z, float rotX, float rotY, float rotZ, float length, int ropeType, float maxLength, float minLength, float windingSpeed, bool p11, bool p12, bool rigid, float p14, bool breakWhenShot, Any unkPtr )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = PHYSICS::ADD_ROPE(x, y, z, rotX, rotY, rotZ, length, ropeType, maxLength, minLength, windingSpeed, p11, p12, rigid, p14, breakWhenShot, &unkPtr);
+		std::get<1>(return_values) = unkPtr;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_PHYSICS_DELETE_ROPE( int ropeId )
+	{
+		PHYSICS::DELETE_ROPE(&ropeId);
+		return ropeId;
+	}
+
+	static void LUA_NATIVE_PHYSICS_DELETE_CHILD_ROPE( int ropeId )
+	{
+		PHYSICS::DELETE_CHILD_ROPE(ropeId);
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_PHYSICS_DOES_ROPE_EXIST( int ropeId )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)PHYSICS::DOES_ROPE_EXIST(&ropeId);
+		std::get<1>(return_values) = ropeId;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_PHYSICS_ROPE_DRAW_ENABLED( int ropeId, bool p1 )
+	{
+		PHYSICS::ROPE_DRAW_ENABLED(&ropeId, p1);
+		return ropeId;
+	}
+
+	static int LUA_NATIVE_PHYSICS_ROPE_DRAW_SHADOW_ENABLED( int ropeId, bool toggle )
+	{
+		PHYSICS::ROPE_DRAW_SHADOW_ENABLED(&ropeId, toggle);
+		return ropeId;
+	}
+
+	static void LUA_NATIVE_PHYSICS_LOAD_ROPE_DATA( int ropeId, const char* rope_preset )
+	{
+		PHYSICS::LOAD_ROPE_DATA(ropeId, rope_preset);
+	}
+
+	static void LUA_NATIVE_PHYSICS_PIN_ROPE_VERTEX( int ropeId, int vertex, float x, float y, float z )
+	{
+		PHYSICS::PIN_ROPE_VERTEX(ropeId, vertex, x, y, z);
+	}
+
+	static void LUA_NATIVE_PHYSICS_UNPIN_ROPE_VERTEX( int ropeId, int vertex )
+	{
+		PHYSICS::UNPIN_ROPE_VERTEX(ropeId, vertex);
+	}
+
+	static int LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COUNT( int ropeId )
+	{
+		auto retval = PHYSICS::GET_ROPE_VERTEX_COUNT(ropeId);
+		return retval;
+	}
+
+	static std::tuple<Any, Any> LUA_NATIVE_PHYSICS_ATTACH_ENTITIES_TO_ROPE( int ropeId, Entity ent1, Entity ent2, float ent1_x, float ent1_y, float ent1_z, float ent2_x, float ent2_y, float ent2_z, float length, bool p10, bool p11, Any p12, Any p13 )
+	{
+		std::tuple<Any, Any> return_values;
+		PHYSICS::ATTACH_ENTITIES_TO_ROPE(ropeId, ent1, ent2, ent1_x, ent1_y, ent1_z, ent2_x, ent2_y, ent2_z, length, p10, p11, &p12, &p13);
+		std::get<0>(return_values) = p12;
+		std::get<1>(return_values) = p13;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_PHYSICS_ATTACH_ROPE_TO_ENTITY( int ropeId, Entity entity, float x, float y, float z, bool p5 )
+	{
+		PHYSICS::ATTACH_ROPE_TO_ENTITY(ropeId, entity, x, y, z, p5);
+	}
+
+	static void LUA_NATIVE_PHYSICS_DETACH_ROPE_FROM_ENTITY( int ropeId, Entity entity )
+	{
+		PHYSICS::DETACH_ROPE_FROM_ENTITY(ropeId, entity);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_PINVERTS( int ropeId )
+	{
+		PHYSICS::ROPE_SET_UPDATE_PINVERTS(ropeId);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_ORDER( int ropeId, Any p1 )
+	{
+		PHYSICS::ROPE_SET_UPDATE_ORDER(ropeId, p1);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_SMOOTH_REELIN( int ropeId, bool p1 )
+	{
+		PHYSICS::ROPE_SET_SMOOTH_REELIN(ropeId, p1);
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_PHYSICS_IS_ROPE_ATTACHED_AT_BOTH_ENDS( int ropeId )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)PHYSICS::IS_ROPE_ATTACHED_AT_BOTH_ENDS(&ropeId);
+		std::get<1>(return_values) = ropeId;
+
+		return return_values;
+	}
+
+	static Vector3 LUA_NATIVE_PHYSICS_GET_ROPE_LAST_VERTEX_COORD( int ropeId )
+	{
+		auto retval = PHYSICS::GET_ROPE_LAST_VERTEX_COORD(ropeId);
+		return retval;
+	}
+
+	static Vector3 LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COORD( int ropeId, int vertex )
+	{
+		auto retval = PHYSICS::GET_ROPE_VERTEX_COORD(ropeId, vertex);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PHYSICS_START_ROPE_WINDING( int ropeId )
+	{
+		PHYSICS::START_ROPE_WINDING(ropeId);
+	}
+
+	static void LUA_NATIVE_PHYSICS_STOP_ROPE_WINDING( int ropeId )
+	{
+		PHYSICS::STOP_ROPE_WINDING(ropeId);
+	}
+
+	static void LUA_NATIVE_PHYSICS_START_ROPE_UNWINDING_FRONT( int ropeId )
+	{
+		PHYSICS::START_ROPE_UNWINDING_FRONT(ropeId);
+	}
+
+	static void LUA_NATIVE_PHYSICS_STOP_ROPE_UNWINDING_FRONT( int ropeId )
+	{
+		PHYSICS::STOP_ROPE_UNWINDING_FRONT(ropeId);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_CONVERT_TO_SIMPLE( int ropeId )
+	{
+		PHYSICS::ROPE_CONVERT_TO_SIMPLE(ropeId);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_LOAD_TEXTURES(  )
+	{
+		PHYSICS::ROPE_LOAD_TEXTURES();
+	}
+
+	static bool LUA_NATIVE_PHYSICS_ROPE_ARE_TEXTURES_LOADED(  )
+	{
+		auto retval = (bool)PHYSICS::ROPE_ARE_TEXTURES_LOADED();
+		return retval;
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_UNLOAD_TEXTURES(  )
+	{
+		PHYSICS::ROPE_UNLOAD_TEXTURES();
+	}
+
+	static bool LUA_NATIVE_PHYSICS_DOES_SCRIPT_OWN_ROPE( int ropeId )
+	{
+		auto retval = (bool)PHYSICS::DOES_SCRIPT_OWN_ROPE(ropeId);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_ATTACH_VIRTUAL_BOUND_GEOM( int ropeId, int p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float p9, float p10, float p11, float p12, float p13 )
+	{
+		PHYSICS::ROPE_ATTACH_VIRTUAL_BOUND_GEOM(ropeId, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_CHANGE_SCRIPT_OWNER( Any p0, bool p1, bool p2 )
+	{
+		PHYSICS::ROPE_CHANGE_SCRIPT_OWNER(p0, p1, p2);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER( int ropeId, int p1 )
+	{
+		PHYSICS::ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER(ropeId, p1);
+	}
+
+	static float LUA_NATIVE_PHYSICS_ROPE_GET_DISTANCE_BETWEEN_ENDS( int ropeId )
+	{
+		auto retval = PHYSICS::ROPE_GET_DISTANCE_BETWEEN_ENDS(ropeId);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_FORCE_LENGTH( int ropeId, float length )
+	{
+		PHYSICS::ROPE_FORCE_LENGTH(ropeId, length);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ROPE_RESET_LENGTH( int ropeId, float length )
+	{
+		PHYSICS::ROPE_RESET_LENGTH(ropeId, length);
+	}
+
+	static void LUA_NATIVE_PHYSICS_APPLY_IMPULSE_TO_CLOTH( float posX, float posY, float posZ, float vecX, float vecY, float vecZ, float impulse )
+	{
+		PHYSICS::APPLY_IMPULSE_TO_CLOTH(posX, posY, posZ, vecX, vecY, vecZ, impulse);
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_DAMPING( Entity entity, int vertex, float value )
+	{
+		PHYSICS::SET_DAMPING(entity, vertex, value);
+	}
+
+	static void LUA_NATIVE_PHYSICS_ACTIVATE_PHYSICS( Entity entity )
+	{
+		PHYSICS::ACTIVATE_PHYSICS(entity);
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_CGOFFSET( Entity entity, float x, float y, float z )
+	{
+		PHYSICS::SET_CGOFFSET(entity, x, y, z);
+	}
+
+	static Vector3 LUA_NATIVE_PHYSICS_GET_CGOFFSET( Entity entity )
+	{
+		auto retval = PHYSICS::GET_CGOFFSET(entity);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_CG_AT_BOUNDCENTER( Entity entity )
+	{
+		PHYSICS::SET_CG_AT_BOUNDCENTER(entity);
+	}
+
+	static void LUA_NATIVE_PHYSICS_BREAK_ENTITY_GLASS( Entity entity, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, Any p9, bool p10 )
+	{
+		PHYSICS::BREAK_ENTITY_GLASS(entity, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
+	}
+
+	static bool LUA_NATIVE_PHYSICS_GET_IS_ENTITY_A_FRAG( Object object )
+	{
+		auto retval = (bool)PHYSICS::GET_IS_ENTITY_A_FRAG(object);
+		return retval;
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_DISABLE_BREAKING( Object object, bool toggle )
+	{
+		PHYSICS::SET_DISABLE_BREAKING(object, toggle);
+	}
+
+	static void LUA_NATIVE_PHYSICS_RESET_DISABLE_BREAKING( Object object )
+	{
+		PHYSICS::RESET_DISABLE_BREAKING(object);
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_DISABLE_FRAG_DAMAGE( Object object, bool toggle )
+	{
+		PHYSICS::SET_DISABLE_FRAG_DAMAGE(object, toggle);
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_USE_KINEMATIC_PHYSICS( Entity entity, bool toggle )
+	{
+		PHYSICS::SET_USE_KINEMATIC_PHYSICS(entity, toggle);
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_IN_STUNT_MODE( bool p0 )
+	{
+		PHYSICS::SET_IN_STUNT_MODE(p0);
+	}
+
+	static void LUA_NATIVE_PHYSICS_SET_IN_ARENA_MODE( bool toggle )
+	{
+		PHYSICS::SET_IN_ARENA_MODE(toggle);
+	}
+
+	void init_native_binding_PHYSICS(sol::state& L)
+	{
+		auto PHYSICS = L["PHYSICS"].get_or_create<sol::table>();
+		PHYSICS.set_function("ADD_ROPE", LUA_NATIVE_PHYSICS_ADD_ROPE);
+		PHYSICS.set_function("DELETE_ROPE", LUA_NATIVE_PHYSICS_DELETE_ROPE);
+		PHYSICS.set_function("DELETE_CHILD_ROPE", LUA_NATIVE_PHYSICS_DELETE_CHILD_ROPE);
+		PHYSICS.set_function("DOES_ROPE_EXIST", LUA_NATIVE_PHYSICS_DOES_ROPE_EXIST);
+		PHYSICS.set_function("ROPE_DRAW_ENABLED", LUA_NATIVE_PHYSICS_ROPE_DRAW_ENABLED);
+		PHYSICS.set_function("ROPE_DRAW_SHADOW_ENABLED", LUA_NATIVE_PHYSICS_ROPE_DRAW_SHADOW_ENABLED);
+		PHYSICS.set_function("LOAD_ROPE_DATA", LUA_NATIVE_PHYSICS_LOAD_ROPE_DATA);
+		PHYSICS.set_function("PIN_ROPE_VERTEX", LUA_NATIVE_PHYSICS_PIN_ROPE_VERTEX);
+		PHYSICS.set_function("UNPIN_ROPE_VERTEX", LUA_NATIVE_PHYSICS_UNPIN_ROPE_VERTEX);
+		PHYSICS.set_function("GET_ROPE_VERTEX_COUNT", LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COUNT);
+		PHYSICS.set_function("ATTACH_ENTITIES_TO_ROPE", LUA_NATIVE_PHYSICS_ATTACH_ENTITIES_TO_ROPE);
+		PHYSICS.set_function("ATTACH_ROPE_TO_ENTITY", LUA_NATIVE_PHYSICS_ATTACH_ROPE_TO_ENTITY);
+		PHYSICS.set_function("DETACH_ROPE_FROM_ENTITY", LUA_NATIVE_PHYSICS_DETACH_ROPE_FROM_ENTITY);
+		PHYSICS.set_function("ROPE_SET_UPDATE_PINVERTS", LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_PINVERTS);
+		PHYSICS.set_function("ROPE_SET_UPDATE_ORDER", LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_ORDER);
+		PHYSICS.set_function("ROPE_SET_SMOOTH_REELIN", LUA_NATIVE_PHYSICS_ROPE_SET_SMOOTH_REELIN);
+		PHYSICS.set_function("IS_ROPE_ATTACHED_AT_BOTH_ENDS", LUA_NATIVE_PHYSICS_IS_ROPE_ATTACHED_AT_BOTH_ENDS);
+		PHYSICS.set_function("GET_ROPE_LAST_VERTEX_COORD", LUA_NATIVE_PHYSICS_GET_ROPE_LAST_VERTEX_COORD);
+		PHYSICS.set_function("GET_ROPE_VERTEX_COORD", LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COORD);
+		PHYSICS.set_function("START_ROPE_WINDING", LUA_NATIVE_PHYSICS_START_ROPE_WINDING);
+		PHYSICS.set_function("STOP_ROPE_WINDING", LUA_NATIVE_PHYSICS_STOP_ROPE_WINDING);
+		PHYSICS.set_function("START_ROPE_UNWINDING_FRONT", LUA_NATIVE_PHYSICS_START_ROPE_UNWINDING_FRONT);
+		PHYSICS.set_function("STOP_ROPE_UNWINDING_FRONT", LUA_NATIVE_PHYSICS_STOP_ROPE_UNWINDING_FRONT);
+		PHYSICS.set_function("ROPE_CONVERT_TO_SIMPLE", LUA_NATIVE_PHYSICS_ROPE_CONVERT_TO_SIMPLE);
+		PHYSICS.set_function("ROPE_LOAD_TEXTURES", LUA_NATIVE_PHYSICS_ROPE_LOAD_TEXTURES);
+		PHYSICS.set_function("ROPE_ARE_TEXTURES_LOADED", LUA_NATIVE_PHYSICS_ROPE_ARE_TEXTURES_LOADED);
+		PHYSICS.set_function("ROPE_UNLOAD_TEXTURES", LUA_NATIVE_PHYSICS_ROPE_UNLOAD_TEXTURES);
+		PHYSICS.set_function("DOES_SCRIPT_OWN_ROPE", LUA_NATIVE_PHYSICS_DOES_SCRIPT_OWN_ROPE);
+		PHYSICS.set_function("ROPE_ATTACH_VIRTUAL_BOUND_GEOM", LUA_NATIVE_PHYSICS_ROPE_ATTACH_VIRTUAL_BOUND_GEOM);
+		PHYSICS.set_function("ROPE_CHANGE_SCRIPT_OWNER", LUA_NATIVE_PHYSICS_ROPE_CHANGE_SCRIPT_OWNER);
+		PHYSICS.set_function("ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER", LUA_NATIVE_PHYSICS_ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER);
+		PHYSICS.set_function("ROPE_GET_DISTANCE_BETWEEN_ENDS", LUA_NATIVE_PHYSICS_ROPE_GET_DISTANCE_BETWEEN_ENDS);
+		PHYSICS.set_function("ROPE_FORCE_LENGTH", LUA_NATIVE_PHYSICS_ROPE_FORCE_LENGTH);
+		PHYSICS.set_function("ROPE_RESET_LENGTH", LUA_NATIVE_PHYSICS_ROPE_RESET_LENGTH);
+		PHYSICS.set_function("APPLY_IMPULSE_TO_CLOTH", LUA_NATIVE_PHYSICS_APPLY_IMPULSE_TO_CLOTH);
+		PHYSICS.set_function("SET_DAMPING", LUA_NATIVE_PHYSICS_SET_DAMPING);
+		PHYSICS.set_function("ACTIVATE_PHYSICS", LUA_NATIVE_PHYSICS_ACTIVATE_PHYSICS);
+		PHYSICS.set_function("SET_CGOFFSET", LUA_NATIVE_PHYSICS_SET_CGOFFSET);
+		PHYSICS.set_function("GET_CGOFFSET", LUA_NATIVE_PHYSICS_GET_CGOFFSET);
+		PHYSICS.set_function("SET_CG_AT_BOUNDCENTER", LUA_NATIVE_PHYSICS_SET_CG_AT_BOUNDCENTER);
+		PHYSICS.set_function("BREAK_ENTITY_GLASS", LUA_NATIVE_PHYSICS_BREAK_ENTITY_GLASS);
+		PHYSICS.set_function("GET_IS_ENTITY_A_FRAG", LUA_NATIVE_PHYSICS_GET_IS_ENTITY_A_FRAG);
+		PHYSICS.set_function("SET_DISABLE_BREAKING", LUA_NATIVE_PHYSICS_SET_DISABLE_BREAKING);
+		PHYSICS.set_function("RESET_DISABLE_BREAKING", LUA_NATIVE_PHYSICS_RESET_DISABLE_BREAKING);
+		PHYSICS.set_function("SET_DISABLE_FRAG_DAMAGE", LUA_NATIVE_PHYSICS_SET_DISABLE_FRAG_DAMAGE);
+		PHYSICS.set_function("SET_USE_KINEMATIC_PHYSICS", LUA_NATIVE_PHYSICS_SET_USE_KINEMATIC_PHYSICS);
+		PHYSICS.set_function("SET_IN_STUNT_MODE", LUA_NATIVE_PHYSICS_SET_IN_STUNT_MODE);
+		PHYSICS.set_function("SET_IN_ARENA_MODE", LUA_NATIVE_PHYSICS_SET_IN_ARENA_MODE);
+	}
+}

src/lua/natives/lua_native_binding_RECORDING.cpp

@@ -0,0 +1,117 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_RECORDING_REPLAY_START_EVENT( int p0 )
+	{
+		RECORDING::REPLAY_START_EVENT(p0);
+	}
+
+	static void LUA_NATIVE_RECORDING_REPLAY_STOP_EVENT(  )
+	{
+		RECORDING::REPLAY_STOP_EVENT();
+	}
+
+	static void LUA_NATIVE_RECORDING_REPLAY_CANCEL_EVENT(  )
+	{
+		RECORDING::REPLAY_CANCEL_EVENT();
+	}
+
+	static void LUA_NATIVE_RECORDING_REPLAY_RECORD_BACK_FOR_TIME( float p0, float p1, int p2 )
+	{
+		RECORDING::REPLAY_RECORD_BACK_FOR_TIME(p0, p1, p2);
+	}
+
+	static void LUA_NATIVE_RECORDING_REPLAY_CHECK_FOR_EVENT_THIS_FRAME( const char* missionNameLabel, Any p1 )
+	{
+		RECORDING::REPLAY_CHECK_FOR_EVENT_THIS_FRAME(missionNameLabel, p1);
+	}
+
+	static void LUA_NATIVE_RECORDING_REPLAY_PREVENT_RECORDING_THIS_FRAME(  )
+	{
+		RECORDING::REPLAY_PREVENT_RECORDING_THIS_FRAME();
+	}
+
+	static void LUA_NATIVE_RECORDING_REPLAY_RESET_EVENT_INFO(  )
+	{
+		RECORDING::REPLAY_RESET_EVENT_INFO();
+	}
+
+	static void LUA_NATIVE_RECORDING_REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME(  )
+	{
+		RECORDING::REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME();
+	}
+
+	static void LUA_NATIVE_RECORDING_RECORD_GREATEST_MOMENT( int p0, int p1, int p2 )
+	{
+		RECORDING::RECORD_GREATEST_MOMENT(p0, p1, p2);
+	}
+
+	static void LUA_NATIVE_RECORDING_START_REPLAY_RECORDING( int mode )
+	{
+		RECORDING::START_REPLAY_RECORDING(mode);
+	}
+
+	static void LUA_NATIVE_RECORDING_STOP_REPLAY_RECORDING(  )
+	{
+		RECORDING::STOP_REPLAY_RECORDING();
+	}
+
+	static void LUA_NATIVE_RECORDING_CANCEL_REPLAY_RECORDING(  )
+	{
+		RECORDING::CANCEL_REPLAY_RECORDING();
+	}
+
+	static bool LUA_NATIVE_RECORDING_SAVE_REPLAY_RECORDING(  )
+	{
+		auto retval = (bool)RECORDING::SAVE_REPLAY_RECORDING();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_RECORDING(  )
+	{
+		auto retval = (bool)RECORDING::IS_REPLAY_RECORDING();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_INITIALIZED(  )
+	{
+		auto retval = (bool)RECORDING::IS_REPLAY_INITIALIZED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_AVAILABLE(  )
+	{
+		auto retval = (bool)RECORDING::IS_REPLAY_AVAILABLE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_RECORD_SPACE_AVAILABLE( bool p0 )
+	{
+		auto retval = (bool)RECORDING::IS_REPLAY_RECORD_SPACE_AVAILABLE(p0);
+		return retval;
+	}
+
+	void init_native_binding_RECORDING(sol::state& L)
+	{
+		auto RECORDING = L["RECORDING"].get_or_create<sol::table>();
+		RECORDING.set_function("REPLAY_START_EVENT", LUA_NATIVE_RECORDING_REPLAY_START_EVENT);
+		RECORDING.set_function("REPLAY_STOP_EVENT", LUA_NATIVE_RECORDING_REPLAY_STOP_EVENT);
+		RECORDING.set_function("REPLAY_CANCEL_EVENT", LUA_NATIVE_RECORDING_REPLAY_CANCEL_EVENT);
+		RECORDING.set_function("REPLAY_RECORD_BACK_FOR_TIME", LUA_NATIVE_RECORDING_REPLAY_RECORD_BACK_FOR_TIME);
+		RECORDING.set_function("REPLAY_CHECK_FOR_EVENT_THIS_FRAME", LUA_NATIVE_RECORDING_REPLAY_CHECK_FOR_EVENT_THIS_FRAME);
+		RECORDING.set_function("REPLAY_PREVENT_RECORDING_THIS_FRAME", LUA_NATIVE_RECORDING_REPLAY_PREVENT_RECORDING_THIS_FRAME);
+		RECORDING.set_function("REPLAY_RESET_EVENT_INFO", LUA_NATIVE_RECORDING_REPLAY_RESET_EVENT_INFO);
+		RECORDING.set_function("REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME", LUA_NATIVE_RECORDING_REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME);
+		RECORDING.set_function("RECORD_GREATEST_MOMENT", LUA_NATIVE_RECORDING_RECORD_GREATEST_MOMENT);
+		RECORDING.set_function("START_REPLAY_RECORDING", LUA_NATIVE_RECORDING_START_REPLAY_RECORDING);
+		RECORDING.set_function("STOP_REPLAY_RECORDING", LUA_NATIVE_RECORDING_STOP_REPLAY_RECORDING);
+		RECORDING.set_function("CANCEL_REPLAY_RECORDING", LUA_NATIVE_RECORDING_CANCEL_REPLAY_RECORDING);
+		RECORDING.set_function("SAVE_REPLAY_RECORDING", LUA_NATIVE_RECORDING_SAVE_REPLAY_RECORDING);
+		RECORDING.set_function("IS_REPLAY_RECORDING", LUA_NATIVE_RECORDING_IS_REPLAY_RECORDING);
+		RECORDING.set_function("IS_REPLAY_INITIALIZED", LUA_NATIVE_RECORDING_IS_REPLAY_INITIALIZED);
+		RECORDING.set_function("IS_REPLAY_AVAILABLE", LUA_NATIVE_RECORDING_IS_REPLAY_AVAILABLE);
+		RECORDING.set_function("IS_REPLAY_RECORD_SPACE_AVAILABLE", LUA_NATIVE_RECORDING_IS_REPLAY_RECORD_SPACE_AVAILABLE);
+	}
+}

src/lua/natives/lua_native_binding_REPLAY.cpp

@@ -0,0 +1,47 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_REPLAY_REGISTER_EFFECT_FOR_REPLAY_EDITOR( const char* p0, bool p1 )
+	{
+		REPLAY::REGISTER_EFFECT_FOR_REPLAY_EDITOR(p0, p1);
+	}
+
+	static bool LUA_NATIVE_REPLAY_REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP(  )
+	{
+		auto retval = (bool)REPLAY::REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP();
+		return retval;
+	}
+
+	static void LUA_NATIVE_REPLAY_SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM(  )
+	{
+		REPLAY::SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM();
+	}
+
+	static void LUA_NATIVE_REPLAY_SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE( bool p0 )
+	{
+		REPLAY::SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE(p0);
+	}
+
+	static void LUA_NATIVE_REPLAY_REPLAY_CONTROL_SHUTDOWN(  )
+	{
+		REPLAY::REPLAY_CONTROL_SHUTDOWN();
+	}
+
+	static void LUA_NATIVE_REPLAY_ACTIVATE_ROCKSTAR_EDITOR( int p0 )
+	{
+		REPLAY::ACTIVATE_ROCKSTAR_EDITOR(p0);
+	}
+
+	void init_native_binding_REPLAY(sol::state& L)
+	{
+		auto REPLAY = L["REPLAY"].get_or_create<sol::table>();
+		REPLAY.set_function("REGISTER_EFFECT_FOR_REPLAY_EDITOR", LUA_NATIVE_REPLAY_REGISTER_EFFECT_FOR_REPLAY_EDITOR);
+		REPLAY.set_function("REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP", LUA_NATIVE_REPLAY_REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP);
+		REPLAY.set_function("SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM", LUA_NATIVE_REPLAY_SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM);
+		REPLAY.set_function("SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE", LUA_NATIVE_REPLAY_SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE);
+		REPLAY.set_function("REPLAY_CONTROL_SHUTDOWN", LUA_NATIVE_REPLAY_REPLAY_CONTROL_SHUTDOWN);
+		REPLAY.set_function("ACTIVATE_ROCKSTAR_EDITOR", LUA_NATIVE_REPLAY_ACTIVATE_ROCKSTAR_EDITOR);
+	}
+}

src/lua/natives/lua_native_binding_SAVEMIGRATION.cpp

@@ -0,0 +1,62 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_IS_MP_ENABLED(  )
+	{
+		auto retval = (bool)SAVEMIGRATION::SAVEMIGRATION_IS_MP_ENABLED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_ACCOUNTS(  )
+	{
+		auto retval = (bool)SAVEMIGRATION::SAVEMIGRATION_MP_REQUEST_ACCOUNTS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS(  )
+	{
+		auto retval = SAVEMIGRATION::SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_NUM_ACCOUNTS(  )
+	{
+		auto retval = SAVEMIGRATION::SAVEMIGRATION_MP_NUM_ACCOUNTS();
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNT( int p0, Any p1 )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)SAVEMIGRATION::SAVEMIGRATION_MP_GET_ACCOUNT(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_STATUS(  )
+	{
+		auto retval = (bool)SAVEMIGRATION::SAVEMIGRATION_MP_REQUEST_STATUS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_STATUS(  )
+	{
+		auto retval = SAVEMIGRATION::SAVEMIGRATION_MP_GET_STATUS();
+		return retval;
+	}
+
+	void init_native_binding_SAVEMIGRATION(sol::state& L)
+	{
+		auto SAVEMIGRATION = L["SAVEMIGRATION"].get_or_create<sol::table>();
+		SAVEMIGRATION.set_function("SAVEMIGRATION_IS_MP_ENABLED", LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_IS_MP_ENABLED);
+		SAVEMIGRATION.set_function("SAVEMIGRATION_MP_REQUEST_ACCOUNTS", LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_ACCOUNTS);
+		SAVEMIGRATION.set_function("SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS", LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS);
+		SAVEMIGRATION.set_function("SAVEMIGRATION_MP_NUM_ACCOUNTS", LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_NUM_ACCOUNTS);
+		SAVEMIGRATION.set_function("SAVEMIGRATION_MP_GET_ACCOUNT", LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNT);
+		SAVEMIGRATION.set_function("SAVEMIGRATION_MP_REQUEST_STATUS", LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_STATUS);
+		SAVEMIGRATION.set_function("SAVEMIGRATION_MP_GET_STATUS", LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_STATUS);
+	}
+}

src/lua/natives/lua_native_binding_SCRIPT.cpp

@@ -0,0 +1,257 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_SCRIPT_REQUEST_SCRIPT( const char* scriptName )
+	{
+		SCRIPT::REQUEST_SCRIPT(scriptName);
+	}
+
+	static void LUA_NATIVE_SCRIPT_SET_SCRIPT_AS_NO_LONGER_NEEDED( const char* scriptName )
+	{
+		SCRIPT::SET_SCRIPT_AS_NO_LONGER_NEEDED(scriptName);
+	}
+
+	static bool LUA_NATIVE_SCRIPT_HAS_SCRIPT_LOADED( const char* scriptName )
+	{
+		auto retval = (bool)SCRIPT::HAS_SCRIPT_LOADED(scriptName);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SCRIPT_DOES_SCRIPT_EXIST( const char* scriptName )
+	{
+		auto retval = (bool)SCRIPT::DOES_SCRIPT_EXIST(scriptName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_SCRIPT_REQUEST_SCRIPT_WITH_NAME_HASH( Hash scriptHash )
+	{
+		SCRIPT::REQUEST_SCRIPT_WITH_NAME_HASH(scriptHash);
+	}
+
+	static void LUA_NATIVE_SCRIPT_SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED( Hash scriptHash )
+	{
+		SCRIPT::SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED(scriptHash);
+	}
+
+	static bool LUA_NATIVE_SCRIPT_HAS_SCRIPT_WITH_NAME_HASH_LOADED( Hash scriptHash )
+	{
+		auto retval = (bool)SCRIPT::HAS_SCRIPT_WITH_NAME_HASH_LOADED(scriptHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SCRIPT_DOES_SCRIPT_WITH_NAME_HASH_EXIST( Hash scriptHash )
+	{
+		auto retval = (bool)SCRIPT::DOES_SCRIPT_WITH_NAME_HASH_EXIST(scriptHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_SCRIPT_TERMINATE_THREAD( int threadId )
+	{
+		SCRIPT::TERMINATE_THREAD(threadId);
+	}
+
+	static bool LUA_NATIVE_SCRIPT_IS_THREAD_ACTIVE( int threadId )
+	{
+		auto retval = (bool)SCRIPT::IS_THREAD_ACTIVE(threadId);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_SCRIPT_GET_NAME_OF_SCRIPT_WITH_THIS_ID( int threadId )
+	{
+		auto retval = SCRIPT::GET_NAME_OF_SCRIPT_WITH_THIS_ID(threadId);
+		return retval;
+	}
+
+	static void LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_RESET(  )
+	{
+		SCRIPT::SCRIPT_THREAD_ITERATOR_RESET();
+	}
+
+	static int LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID(  )
+	{
+		auto retval = SCRIPT::SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SCRIPT_GET_ID_OF_THIS_THREAD(  )
+	{
+		auto retval = SCRIPT::GET_ID_OF_THIS_THREAD();
+		return retval;
+	}
+
+	static void LUA_NATIVE_SCRIPT_TERMINATE_THIS_THREAD(  )
+	{
+		SCRIPT::TERMINATE_THIS_THREAD();
+	}
+
+	static int LUA_NATIVE_SCRIPT_GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH( Hash scriptHash )
+	{
+		auto retval = SCRIPT::GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH(scriptHash);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_SCRIPT_GET_THIS_SCRIPT_NAME(  )
+	{
+		auto retval = SCRIPT::GET_THIS_SCRIPT_NAME();
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_SCRIPT_GET_HASH_OF_THIS_SCRIPT_NAME(  )
+	{
+		auto retval = SCRIPT::GET_HASH_OF_THIS_SCRIPT_NAME();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SCRIPT_GET_NUMBER_OF_EVENTS( int eventGroup )
+	{
+		auto retval = SCRIPT::GET_NUMBER_OF_EVENTS(eventGroup);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SCRIPT_GET_EVENT_EXISTS( int eventGroup, int eventIndex )
+	{
+		auto retval = (bool)SCRIPT::GET_EVENT_EXISTS(eventGroup, eventIndex);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SCRIPT_GET_EVENT_AT_INDEX( int eventGroup, int eventIndex )
+	{
+		auto retval = SCRIPT::GET_EVENT_AT_INDEX(eventGroup, eventIndex);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_SCRIPT_GET_EVENT_DATA( int eventGroup, int eventIndex, Any eventData, int eventDataSize )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)SCRIPT::GET_EVENT_DATA(eventGroup, eventIndex, &eventData, eventDataSize);
+		std::get<1>(return_values) = eventData;
+
+		return return_values;
+	}
+
+	static Any LUA_NATIVE_SCRIPT_TRIGGER_SCRIPT_EVENT( int eventGroup, Any eventData, int eventDataSize, int playerBits )
+	{
+		SCRIPT::TRIGGER_SCRIPT_EVENT(eventGroup, &eventData, eventDataSize, playerBits);
+		return eventData;
+	}
+
+	static void LUA_NATIVE_SCRIPT_SHUTDOWN_LOADING_SCREEN(  )
+	{
+		SCRIPT::SHUTDOWN_LOADING_SCREEN();
+	}
+
+	static void LUA_NATIVE_SCRIPT_SET_NO_LOADING_SCREEN( bool toggle )
+	{
+		SCRIPT::SET_NO_LOADING_SCREEN(toggle);
+	}
+
+	static bool LUA_NATIVE_SCRIPT_GET_NO_LOADING_SCREEN(  )
+	{
+		auto retval = (bool)SCRIPT::GET_NO_LOADING_SCREEN();
+		return retval;
+	}
+
+	static void LUA_NATIVE_SCRIPT_COMMIT_TO_LOADINGSCREEN_SELCTION(  )
+	{
+		SCRIPT::COMMIT_TO_LOADINGSCREEN_SELCTION();
+	}
+
+	static bool LUA_NATIVE_SCRIPT_BG_IS_EXITFLAG_SET(  )
+	{
+		auto retval = (bool)SCRIPT::BG_IS_EXITFLAG_SET();
+		return retval;
+	}
+
+	static void LUA_NATIVE_SCRIPT_BG_SET_EXITFLAG_RESPONSE(  )
+	{
+		SCRIPT::BG_SET_EXITFLAG_RESPONSE();
+	}
+
+	static void LUA_NATIVE_SCRIPT_BG_START_CONTEXT_HASH( Hash contextHash )
+	{
+		SCRIPT::BG_START_CONTEXT_HASH(contextHash);
+	}
+
+	static void LUA_NATIVE_SCRIPT_BG_END_CONTEXT_HASH( Hash contextHash )
+	{
+		SCRIPT::BG_END_CONTEXT_HASH(contextHash);
+	}
+
+	static void LUA_NATIVE_SCRIPT_BG_START_CONTEXT( const char* contextName )
+	{
+		SCRIPT::BG_START_CONTEXT(contextName);
+	}
+
+	static void LUA_NATIVE_SCRIPT_BG_END_CONTEXT( const char* contextName )
+	{
+		SCRIPT::BG_END_CONTEXT(contextName);
+	}
+
+	static bool LUA_NATIVE_SCRIPT_BG_DOES_LAUNCH_PARAM_EXIST( int scriptIndex, const char* p1 )
+	{
+		auto retval = (bool)SCRIPT::BG_DOES_LAUNCH_PARAM_EXIST(scriptIndex, p1);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SCRIPT_BG_GET_LAUNCH_PARAM_VALUE( int scriptIndex, const char* p1 )
+	{
+		auto retval = SCRIPT::BG_GET_LAUNCH_PARAM_VALUE(scriptIndex, p1);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SCRIPT_BG_GET_SCRIPT_ID_FROM_NAME_HASH( Hash p0 )
+	{
+		auto retval = SCRIPT::BG_GET_SCRIPT_ID_FROM_NAME_HASH(p0);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_SCRIPT_SEND_TU_SCRIPT_EVENT( int eventGroup, Any eventData, int eventDataSize, int playerBits )
+	{
+		SCRIPT::SEND_TU_SCRIPT_EVENT(eventGroup, &eventData, eventDataSize, playerBits);
+		return eventData;
+	}
+
+	void init_native_binding_SCRIPT(sol::state& L)
+	{
+		auto SCRIPT = L["SCRIPT"].get_or_create<sol::table>();
+		SCRIPT.set_function("REQUEST_SCRIPT", LUA_NATIVE_SCRIPT_REQUEST_SCRIPT);
+		SCRIPT.set_function("SET_SCRIPT_AS_NO_LONGER_NEEDED", LUA_NATIVE_SCRIPT_SET_SCRIPT_AS_NO_LONGER_NEEDED);
+		SCRIPT.set_function("HAS_SCRIPT_LOADED", LUA_NATIVE_SCRIPT_HAS_SCRIPT_LOADED);
+		SCRIPT.set_function("DOES_SCRIPT_EXIST", LUA_NATIVE_SCRIPT_DOES_SCRIPT_EXIST);
+		SCRIPT.set_function("REQUEST_SCRIPT_WITH_NAME_HASH", LUA_NATIVE_SCRIPT_REQUEST_SCRIPT_WITH_NAME_HASH);
+		SCRIPT.set_function("SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED", LUA_NATIVE_SCRIPT_SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED);
+		SCRIPT.set_function("HAS_SCRIPT_WITH_NAME_HASH_LOADED", LUA_NATIVE_SCRIPT_HAS_SCRIPT_WITH_NAME_HASH_LOADED);
+		SCRIPT.set_function("DOES_SCRIPT_WITH_NAME_HASH_EXIST", LUA_NATIVE_SCRIPT_DOES_SCRIPT_WITH_NAME_HASH_EXIST);
+		SCRIPT.set_function("TERMINATE_THREAD", LUA_NATIVE_SCRIPT_TERMINATE_THREAD);
+		SCRIPT.set_function("IS_THREAD_ACTIVE", LUA_NATIVE_SCRIPT_IS_THREAD_ACTIVE);
+		SCRIPT.set_function("GET_NAME_OF_SCRIPT_WITH_THIS_ID", LUA_NATIVE_SCRIPT_GET_NAME_OF_SCRIPT_WITH_THIS_ID);
+		SCRIPT.set_function("SCRIPT_THREAD_ITERATOR_RESET", LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_RESET);
+		SCRIPT.set_function("SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID", LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID);
+		SCRIPT.set_function("GET_ID_OF_THIS_THREAD", LUA_NATIVE_SCRIPT_GET_ID_OF_THIS_THREAD);
+		SCRIPT.set_function("TERMINATE_THIS_THREAD", LUA_NATIVE_SCRIPT_TERMINATE_THIS_THREAD);
+		SCRIPT.set_function("GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH", LUA_NATIVE_SCRIPT_GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH);
+		SCRIPT.set_function("GET_THIS_SCRIPT_NAME", LUA_NATIVE_SCRIPT_GET_THIS_SCRIPT_NAME);
+		SCRIPT.set_function("GET_HASH_OF_THIS_SCRIPT_NAME", LUA_NATIVE_SCRIPT_GET_HASH_OF_THIS_SCRIPT_NAME);
+		SCRIPT.set_function("GET_NUMBER_OF_EVENTS", LUA_NATIVE_SCRIPT_GET_NUMBER_OF_EVENTS);
+		SCRIPT.set_function("GET_EVENT_EXISTS", LUA_NATIVE_SCRIPT_GET_EVENT_EXISTS);
+		SCRIPT.set_function("GET_EVENT_AT_INDEX", LUA_NATIVE_SCRIPT_GET_EVENT_AT_INDEX);
+		SCRIPT.set_function("GET_EVENT_DATA", LUA_NATIVE_SCRIPT_GET_EVENT_DATA);
+		SCRIPT.set_function("TRIGGER_SCRIPT_EVENT", LUA_NATIVE_SCRIPT_TRIGGER_SCRIPT_EVENT);
+		SCRIPT.set_function("SHUTDOWN_LOADING_SCREEN", LUA_NATIVE_SCRIPT_SHUTDOWN_LOADING_SCREEN);
+		SCRIPT.set_function("SET_NO_LOADING_SCREEN", LUA_NATIVE_SCRIPT_SET_NO_LOADING_SCREEN);
+		SCRIPT.set_function("GET_NO_LOADING_SCREEN", LUA_NATIVE_SCRIPT_GET_NO_LOADING_SCREEN);
+		SCRIPT.set_function("COMMIT_TO_LOADINGSCREEN_SELCTION", LUA_NATIVE_SCRIPT_COMMIT_TO_LOADINGSCREEN_SELCTION);
+		SCRIPT.set_function("BG_IS_EXITFLAG_SET", LUA_NATIVE_SCRIPT_BG_IS_EXITFLAG_SET);
+		SCRIPT.set_function("BG_SET_EXITFLAG_RESPONSE", LUA_NATIVE_SCRIPT_BG_SET_EXITFLAG_RESPONSE);
+		SCRIPT.set_function("BG_START_CONTEXT_HASH", LUA_NATIVE_SCRIPT_BG_START_CONTEXT_HASH);
+		SCRIPT.set_function("BG_END_CONTEXT_HASH", LUA_NATIVE_SCRIPT_BG_END_CONTEXT_HASH);
+		SCRIPT.set_function("BG_START_CONTEXT", LUA_NATIVE_SCRIPT_BG_START_CONTEXT);
+		SCRIPT.set_function("BG_END_CONTEXT", LUA_NATIVE_SCRIPT_BG_END_CONTEXT);
+		SCRIPT.set_function("BG_DOES_LAUNCH_PARAM_EXIST", LUA_NATIVE_SCRIPT_BG_DOES_LAUNCH_PARAM_EXIST);
+		SCRIPT.set_function("BG_GET_LAUNCH_PARAM_VALUE", LUA_NATIVE_SCRIPT_BG_GET_LAUNCH_PARAM_VALUE);
+		SCRIPT.set_function("BG_GET_SCRIPT_ID_FROM_NAME_HASH", LUA_NATIVE_SCRIPT_BG_GET_SCRIPT_ID_FROM_NAME_HASH);
+		SCRIPT.set_function("SEND_TU_SCRIPT_EVENT", LUA_NATIVE_SCRIPT_SEND_TU_SCRIPT_EVENT);
+	}
+}

src/lua/natives/lua_native_binding_SECURITY.cpp

@@ -0,0 +1,30 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static Any LUA_NATIVE_SECURITY_REGISTER_SCRIPT_VARIABLE( Any variable )
+	{
+		SECURITY::REGISTER_SCRIPT_VARIABLE(&variable);
+		return variable;
+	}
+
+	static Any LUA_NATIVE_SECURITY_UNREGISTER_SCRIPT_VARIABLE( Any variable )
+	{
+		SECURITY::UNREGISTER_SCRIPT_VARIABLE(&variable);
+		return variable;
+	}
+
+	static void LUA_NATIVE_SECURITY_FORCE_CHECK_SCRIPT_VARIABLES(  )
+	{
+		SECURITY::FORCE_CHECK_SCRIPT_VARIABLES();
+	}
+
+	void init_native_binding_SECURITY(sol::state& L)
+	{
+		auto SECURITY = L["SECURITY"].get_or_create<sol::table>();
+		SECURITY.set_function("REGISTER_SCRIPT_VARIABLE", LUA_NATIVE_SECURITY_REGISTER_SCRIPT_VARIABLE);
+		SECURITY.set_function("UNREGISTER_SCRIPT_VARIABLE", LUA_NATIVE_SECURITY_UNREGISTER_SCRIPT_VARIABLE);
+		SECURITY.set_function("FORCE_CHECK_SCRIPT_VARIABLES", LUA_NATIVE_SECURITY_FORCE_CHECK_SCRIPT_VARIABLES);
+	}
+}

src/lua/natives/lua_native_binding_SHAPETEST.cpp

@@ -0,0 +1,103 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_LOS_PROBE( float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8 )
+	{
+		auto retval = SHAPETEST::START_SHAPE_TEST_LOS_PROBE(x1, y1, z1, x2, y2, z2, flags, entity, p8);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SHAPETEST_START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE( float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8 )
+	{
+		auto retval = SHAPETEST::START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE(x1, y1, z1, x2, y2, z2, flags, entity, p8);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUNDING_BOX( Entity entity, int flags1, int flags2 )
+	{
+		auto retval = SHAPETEST::START_SHAPE_TEST_BOUNDING_BOX(entity, flags1, flags2);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOX( float x, float y, float z, float dimX, float dimY, float dimZ, float rotX, float rotY, float rotZ, Any p9, int flags, Entity entity, Any p12 )
+	{
+		auto retval = SHAPETEST::START_SHAPE_TEST_BOX(x, y, z, dimX, dimY, dimZ, rotX, rotY, rotZ, p9, flags, entity, p12);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUND( Entity entity, int flags1, int flags2 )
+	{
+		auto retval = SHAPETEST::START_SHAPE_TEST_BOUND(entity, flags1, flags2);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_CAPSULE( float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, int p9 )
+	{
+		auto retval = SHAPETEST::START_SHAPE_TEST_CAPSULE(x1, y1, z1, x2, y2, z2, radius, flags, entity, p9);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_SWEPT_SPHERE( float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, Any p9 )
+	{
+		auto retval = SHAPETEST::START_SHAPE_TEST_SWEPT_SPHERE(x1, y1, z1, x2, y2, z2, radius, flags, entity, p9);
+		return retval;
+	}
+
+	static std::tuple<int, Vector3, Vector3> LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE( Vector3 pVec1, Vector3 pVec2, int flag, Entity entity, int flag2 )
+	{
+		std::tuple<int, Vector3, Vector3> return_values;
+		std::get<0>(return_values) = SHAPETEST::START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE(&pVec1, &pVec2, flag, entity, flag2);
+		std::get<1>(return_values) = pVec1;
+		std::get<2>(return_values) = pVec2;
+
+		return return_values;
+	}
+
+	static std::tuple<int, bool, Vector3, Vector3, Entity> LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT( int shapeTestHandle, bool hit, Vector3 endCoords, Vector3 surfaceNormal, Entity entityHit )
+	{
+		std::tuple<int, bool, Vector3, Vector3, Entity> return_values;
+		std::get<0>(return_values) = SHAPETEST::GET_SHAPE_TEST_RESULT(shapeTestHandle, (BOOL*)&hit, &endCoords, &surfaceNormal, &entityHit);
+		std::get<1>(return_values) = hit;
+		std::get<2>(return_values) = endCoords;
+		std::get<3>(return_values) = surfaceNormal;
+		std::get<4>(return_values) = entityHit;
+
+		return return_values;
+	}
+
+	static std::tuple<int, bool, Vector3, Vector3, Hash, Entity> LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL( int shapeTestHandle, bool hit, Vector3 endCoords, Vector3 surfaceNormal, Hash materialHash, Entity entityHit )
+	{
+		std::tuple<int, bool, Vector3, Vector3, Hash, Entity> return_values;
+		std::get<0>(return_values) = SHAPETEST::GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL(shapeTestHandle, (BOOL*)&hit, &endCoords, &surfaceNormal, &materialHash, &entityHit);
+		std::get<1>(return_values) = hit;
+		std::get<2>(return_values) = endCoords;
+		std::get<3>(return_values) = surfaceNormal;
+		std::get<4>(return_values) = materialHash;
+		std::get<5>(return_values) = entityHit;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_SHAPETEST_RELEASE_SCRIPT_GUID_FROM_ENTITY( Entity entityHit )
+	{
+		SHAPETEST::RELEASE_SCRIPT_GUID_FROM_ENTITY(entityHit);
+	}
+
+	void init_native_binding_SHAPETEST(sol::state& L)
+	{
+		auto SHAPETEST = L["SHAPETEST"].get_or_create<sol::table>();
+		SHAPETEST.set_function("START_SHAPE_TEST_LOS_PROBE", LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_LOS_PROBE);
+		SHAPETEST.set_function("START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE", LUA_NATIVE_SHAPETEST_START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE);
+		SHAPETEST.set_function("START_SHAPE_TEST_BOUNDING_BOX", LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUNDING_BOX);
+		SHAPETEST.set_function("START_SHAPE_TEST_BOX", LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOX);
+		SHAPETEST.set_function("START_SHAPE_TEST_BOUND", LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUND);
+		SHAPETEST.set_function("START_SHAPE_TEST_CAPSULE", LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_CAPSULE);
+		SHAPETEST.set_function("START_SHAPE_TEST_SWEPT_SPHERE", LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_SWEPT_SPHERE);
+		SHAPETEST.set_function("START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE", LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE);
+		SHAPETEST.set_function("GET_SHAPE_TEST_RESULT", LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT);
+		SHAPETEST.set_function("GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL", LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL);
+		SHAPETEST.set_function("RELEASE_SCRIPT_GUID_FROM_ENTITY", LUA_NATIVE_SHAPETEST_RELEASE_SCRIPT_GUID_FROM_ENTITY);
+	}
+}

src/lua/natives/lua_native_binding_SOCIALCLUB.cpp

@@ -0,0 +1,676 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static int LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_TOTAL_NUM_MESSAGES(  )
+	{
+		auto retval = SOCIALCLUB::SC_INBOX_GET_TOTAL_NUM_MESSAGES();
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX( int msgIndex )
+	{
+		auto retval = SOCIALCLUB::SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX(msgIndex);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX( int msgIndex )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX(msgIndex);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX( int msgIndex )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX(msgIndex);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_INT( int p0, const char* context, int out )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_DATA_INT(p0, context, &out);
+		std::get<1>(return_values) = out;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_BOOL( int p0, const char* p1 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_DATA_BOOL(p0, p1);
+		return retval;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_STRING( int p0, const char* context, char out )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_DATA_STRING(p0, context, &out);
+		std::get<1>(return_values) = out;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_DO_APPLY( int p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_DO_APPLY(p0);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX( int p0 )
+	{
+		auto retval = SOCIALCLUB::SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX(p0);
+		return retval;
+	}
+
+	static Any LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST( Any gamerHandle )
+	{
+		SOCIALCLUB::SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST(&gamerHandle);
+		return gamerHandle;
+	}
+
+	static Any LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST( Any data )
+	{
+		SOCIALCLUB::SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST(&data);
+		return data;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_UGCDATA( int p0, Any p1 )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_UGCDATA(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST( Any data )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST(&data);
+		std::get<1>(return_values) = data;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_BOUNTY_DATA_AT_INDEX( int index, Any outData )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_GET_BOUNTY_DATA_AT_INDEX(index, &outData);
+		std::get<1>(return_values) = outData;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_RETRIEVE_EMAILS( int offset, int limit )
+	{
+		SOCIALCLUB::SC_EMAIL_RETRIEVE_EMAILS(offset, limit);
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_RETRIEVAL_STATUS(  )
+	{
+		auto retval = SOCIALCLUB::SC_EMAIL_GET_RETRIEVAL_STATUS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_NUM_RETRIEVED_EMAILS(  )
+	{
+		auto retval = SOCIALCLUB::SC_EMAIL_GET_NUM_RETRIEVED_EMAILS();
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_EMAIL_AT_INDEX( int p0, Any p1 )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_EMAIL_GET_EMAIL_AT_INDEX(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static Any LUA_NATIVE_SOCIALCLUB_SC_EMAIL_DELETE_EMAILS( Any p0, Any p1 )
+	{
+		SOCIALCLUB::SC_EMAIL_DELETE_EMAILS(&p0, p1);
+		return p0;
+	}
+
+	static Any LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST( Any gamerHandle )
+	{
+		SOCIALCLUB::SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST(&gamerHandle);
+		return gamerHandle;
+	}
+
+	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST(  )
+	{
+		SOCIALCLUB::SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST();
+	}
+
+	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SEND_EMAIL( const char* p0 )
+	{
+		SOCIALCLUB::SC_EMAIL_SEND_EMAIL(p0);
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SET_CURRENT_EMAIL_TAG( Any p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_EMAIL_SET_CURRENT_EMAIL_TAG(p0);
+		return retval;
+	}
+
+	static void LUA_NATIVE_SOCIALCLUB_SC_CACHE_NEW_ROCKSTAR_MSGS( bool toggle )
+	{
+		SOCIALCLUB::SC_CACHE_NEW_ROCKSTAR_MSGS(toggle);
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_HAS_NEW_ROCKSTAR_MSG(  )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_HAS_NEW_ROCKSTAR_MSG();
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_GET_NEW_ROCKSTAR_MSG(  )
+	{
+		auto retval = SOCIALCLUB::SC_GET_NEW_ROCKSTAR_MSG();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_INT( Hash attrHash, int value )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_ATTR_SET_INT(attrHash, value);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_FLOAT( Hash attrHash, float value )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_ATTR_SET_FLOAT(attrHash, value);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_STRING( Hash attrHash, const char* value )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_ATTR_SET_STRING(attrHash, value);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_SET_ACTIVITY_RATING( Any p0, float p1 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_SET_ACTIVITY_RATING(p0, p1);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_INT( const char* name, int value )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_INT(name, &value);
+		std::get<1>(return_values) = value;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_FLOAT( const char* name, float value )
+	{
+		std::tuple<bool, float> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_FLOAT(name, &value);
+		std::get<1>(return_values) = value;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_BOOL( const char* name )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_GAMERDATA_GET_BOOL(name);
+		return retval;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_STRING( const char* name, char value )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_STRING(name, &value);
+		std::get<1>(return_values) = value;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_ACTIVE_XP_BONUS( float value )
+	{
+		std::tuple<bool, float> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_ACTIVE_XP_BONUS(&value);
+		std::get<1>(return_values) = value;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING( const char* string, int token )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_PROFANITY_CHECK_STRING(string, &token);
+		std::get<1>(return_values) = token;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING_UGC( const char* string, int token )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_PROFANITY_CHECK_STRING_UGC(string, &token);
+		std::get<1>(return_values) = token;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_VALID( int token )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PROFANITY_GET_CHECK_IS_VALID(token);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_PENDING( int token )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PROFANITY_GET_CHECK_IS_PENDING(token);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_PASSED( int token )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PROFANITY_GET_STRING_PASSED(token);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_STATUS( int token )
+	{
+		auto retval = SOCIALCLUB::SC_PROFANITY_GET_STRING_STATUS(token);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_CHECK_STRING( const char* p0, int p1 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_CHECK_STRING(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_VALID( Any p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_CHECK_IS_VALID(p0);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_PENDING( Any p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_CHECK_IS_PENDING(p0);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_COUNT( int token )
+	{
+		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_COUNT(token);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE( int token, int plateIndex )
+	{
+		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_PLATE(token, plateIndex);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE_DATA( int token, int plateIndex )
+	{
+		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_PLATE_DATA(token, plateIndex);
+		return retval;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_SET_PLATE_DATA( const char* oldPlateText, const char* newPlateText, Any plateData )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_SET_PLATE_DATA(oldPlateText, newPlateText, &plateData);
+		std::get<1>(return_values) = plateData;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ADD( const char* plateText, Any plateData, int token )
+	{
+		std::tuple<bool, Any, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_ADD(plateText, &plateData, &token);
+		std::get<1>(return_values) = plateData;
+		std::get<2>(return_values) = token;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_IS_PENDING( int token )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_ADD_IS_PENDING(token);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_STATUS( int token )
+	{
+		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_ADD_STATUS(token);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ISVALID( const char* plateText, int token )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_ISVALID(plateText, &token);
+		std::get<1>(return_values) = token;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_IS_PENDING( int token )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_ISVALID_IS_PENDING(token);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_STATUS( int token )
+	{
+		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_ISVALID_STATUS(token);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE(  )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_IS_ACTIVE();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID(  )
+	{
+		auto retval = SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EVENT_ID();
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT( const char* p0, int p1 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT( const char* p0, float p1 )
+	{
+		std::tuple<bool, float> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING( const char* p0, char p1 )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME( char p0 )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_DISPLAY_NAME(&p0);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE( const char* p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE(p0);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE( const char* p0 )
+	{
+		auto retval = SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE(p0);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE( const char* p0, int p1, const char* p2 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE(p0, &p1, p2);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE( const char* p0, float p1, const char* p2 )
+	{
+		std::tuple<bool, float> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE(p0, &p1, p2);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE( const char* p0, char p1, const char* p2 )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE(p0, &p1, p2);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE( char p0, const char* p1 )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE(&p0, p1);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID( int p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID(p0);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID( int p0, const char* p1, int p2 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID(p0, p1, &p2);
+		std::get<1>(return_values) = p2;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID( int p0, const char* p1, float p2 )
+	{
+		std::tuple<bool, float> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID(p0, p1, &p2);
+		std::get<1>(return_values) = p2;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID( int p0, const char* p1, char p2 )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID(p0, p1, &p2);
+		std::get<1>(return_values) = p2;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID( int p0, char p1 )
+	{
+		std::tuple<bool, char> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW( Any p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_SHOW(p0);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_TIMED( Any p0, Any p1 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_SHOW_TIMED(p0, p1);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_NEXT_ITEM(  )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_SHOW_NEXT_ITEM();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU(  )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU();
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU( const char* p0, int p1 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU(p0, &p1);
+		std::get<1>(return_values) = p1;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_END(  )
+	{
+		SOCIALCLUB::SC_TRANSITION_NEWS_END();
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_INIT_STARTER_PACK( Any p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PAUSE_NEWS_INIT_STARTER_PACK(p0);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_GET_PENDING_STORY( Any p0 )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_PAUSE_NEWS_GET_PENDING_STORY(p0);
+		return retval;
+	}
+
+	static void LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_SHUTDOWN(  )
+	{
+		SOCIALCLUB::SC_PAUSE_NEWS_SHUTDOWN();
+	}
+
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_ACCOUNT_INFO_GET_NICKNAME(  )
+	{
+		auto retval = SOCIALCLUB::SC_ACCOUNT_INFO_GET_NICKNAME();
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_ACHIEVEMENT_INFO_STATUS( int p0 )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_ACHIEVEMENT_INFO_STATUS(&p0);
+		std::get<1>(return_values) = p0;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_SOCIALCLUB_SC_HAS_ACHIEVEMENT_BEEN_PASSED( int achievementId )
+	{
+		auto retval = (bool)SOCIALCLUB::SC_HAS_ACHIEVEMENT_BEEN_PASSED(achievementId);
+		return retval;
+	}
+
+	void init_native_binding_SOCIALCLUB(sol::state& L)
+	{
+		auto SOCIALCLUB = L["SOCIALCLUB"].get_or_create<sol::table>();
+		SOCIALCLUB.set_function("SC_INBOX_GET_TOTAL_NUM_MESSAGES", LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_TOTAL_NUM_MESSAGES);
+		SOCIALCLUB.set_function("SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX", LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX);
+		SOCIALCLUB.set_function("SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX", LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX);
+		SOCIALCLUB.set_function("SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX", LUA_NATIVE_SOCIALCLUB_SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX);
+		SOCIALCLUB.set_function("SC_INBOX_MESSAGE_GET_DATA_INT", LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_INT);
+		SOCIALCLUB.set_function("SC_INBOX_MESSAGE_GET_DATA_BOOL", LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_BOOL);
+		SOCIALCLUB.set_function("SC_INBOX_MESSAGE_GET_DATA_STRING", LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_STRING);
+		SOCIALCLUB.set_function("SC_INBOX_MESSAGE_DO_APPLY", LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_DO_APPLY);
+		SOCIALCLUB.set_function("SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX", LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX);
+		SOCIALCLUB.set_function("SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST", LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST);
+		SOCIALCLUB.set_function("SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST", LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST);
+		SOCIALCLUB.set_function("SC_INBOX_MESSAGE_GET_UGCDATA", LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_UGCDATA);
+		SOCIALCLUB.set_function("SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST", LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST);
+		SOCIALCLUB.set_function("SC_INBOX_GET_BOUNTY_DATA_AT_INDEX", LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_BOUNTY_DATA_AT_INDEX);
+		SOCIALCLUB.set_function("SC_EMAIL_RETRIEVE_EMAILS", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_RETRIEVE_EMAILS);
+		SOCIALCLUB.set_function("SC_EMAIL_GET_RETRIEVAL_STATUS", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_RETRIEVAL_STATUS);
+		SOCIALCLUB.set_function("SC_EMAIL_GET_NUM_RETRIEVED_EMAILS", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_NUM_RETRIEVED_EMAILS);
+		SOCIALCLUB.set_function("SC_EMAIL_GET_EMAIL_AT_INDEX", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_EMAIL_AT_INDEX);
+		SOCIALCLUB.set_function("SC_EMAIL_DELETE_EMAILS", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_DELETE_EMAILS);
+		SOCIALCLUB.set_function("SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST);
+		SOCIALCLUB.set_function("SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST);
+		SOCIALCLUB.set_function("SC_EMAIL_SEND_EMAIL", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SEND_EMAIL);
+		SOCIALCLUB.set_function("SC_EMAIL_SET_CURRENT_EMAIL_TAG", LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SET_CURRENT_EMAIL_TAG);
+		SOCIALCLUB.set_function("SC_CACHE_NEW_ROCKSTAR_MSGS", LUA_NATIVE_SOCIALCLUB_SC_CACHE_NEW_ROCKSTAR_MSGS);
+		SOCIALCLUB.set_function("SC_HAS_NEW_ROCKSTAR_MSG", LUA_NATIVE_SOCIALCLUB_SC_HAS_NEW_ROCKSTAR_MSG);
+		SOCIALCLUB.set_function("SC_GET_NEW_ROCKSTAR_MSG", LUA_NATIVE_SOCIALCLUB_SC_GET_NEW_ROCKSTAR_MSG);
+		SOCIALCLUB.set_function("SC_PRESENCE_ATTR_SET_INT", LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_INT);
+		SOCIALCLUB.set_function("SC_PRESENCE_ATTR_SET_FLOAT", LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_FLOAT);
+		SOCIALCLUB.set_function("SC_PRESENCE_ATTR_SET_STRING", LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_STRING);
+		SOCIALCLUB.set_function("SC_PRESENCE_SET_ACTIVITY_RATING", LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_SET_ACTIVITY_RATING);
+		SOCIALCLUB.set_function("SC_GAMERDATA_GET_INT", LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_INT);
+		SOCIALCLUB.set_function("SC_GAMERDATA_GET_FLOAT", LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_FLOAT);
+		SOCIALCLUB.set_function("SC_GAMERDATA_GET_BOOL", LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_BOOL);
+		SOCIALCLUB.set_function("SC_GAMERDATA_GET_STRING", LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_STRING);
+		SOCIALCLUB.set_function("SC_GAMERDATA_GET_ACTIVE_XP_BONUS", LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_ACTIVE_XP_BONUS);
+		SOCIALCLUB.set_function("SC_PROFANITY_CHECK_STRING", LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING);
+		SOCIALCLUB.set_function("SC_PROFANITY_CHECK_STRING_UGC", LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING_UGC);
+		SOCIALCLUB.set_function("SC_PROFANITY_GET_CHECK_IS_VALID", LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_VALID);
+		SOCIALCLUB.set_function("SC_PROFANITY_GET_CHECK_IS_PENDING", LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_PENDING);
+		SOCIALCLUB.set_function("SC_PROFANITY_GET_STRING_PASSED", LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_PASSED);
+		SOCIALCLUB.set_function("SC_PROFANITY_GET_STRING_STATUS", LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_STATUS);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_CHECK_STRING", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_CHECK_STRING);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_CHECK_IS_VALID", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_VALID);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_CHECK_IS_PENDING", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_PENDING);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_COUNT", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_COUNT);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_PLATE", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_PLATE_DATA", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE_DATA);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_SET_PLATE_DATA", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_SET_PLATE_DATA);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_ADD", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ADD);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_ADD_IS_PENDING", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_IS_PENDING);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_ADD_STATUS", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_STATUS);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_ISVALID", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ISVALID);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_ISVALID_IS_PENDING", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_IS_PENDING);
+		SOCIALCLUB.set_function("SC_LICENSEPLATE_GET_ISVALID_STATUS", LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_STATUS);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_IS_ACTIVE", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EVENT_ID", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_DISPLAY_NAME", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID);
+		SOCIALCLUB.set_function("SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID", LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID);
+		SOCIALCLUB.set_function("SC_TRANSITION_NEWS_SHOW", LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW);
+		SOCIALCLUB.set_function("SC_TRANSITION_NEWS_SHOW_TIMED", LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_TIMED);
+		SOCIALCLUB.set_function("SC_TRANSITION_NEWS_SHOW_NEXT_ITEM", LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_NEXT_ITEM);
+		SOCIALCLUB.set_function("SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU", LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU);
+		SOCIALCLUB.set_function("SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU", LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU);
+		SOCIALCLUB.set_function("SC_TRANSITION_NEWS_END", LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_END);
+		SOCIALCLUB.set_function("SC_PAUSE_NEWS_INIT_STARTER_PACK", LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_INIT_STARTER_PACK);
+		SOCIALCLUB.set_function("SC_PAUSE_NEWS_GET_PENDING_STORY", LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_GET_PENDING_STORY);
+		SOCIALCLUB.set_function("SC_PAUSE_NEWS_SHUTDOWN", LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_SHUTDOWN);
+		SOCIALCLUB.set_function("SC_ACCOUNT_INFO_GET_NICKNAME", LUA_NATIVE_SOCIALCLUB_SC_ACCOUNT_INFO_GET_NICKNAME);
+		SOCIALCLUB.set_function("SC_ACHIEVEMENT_INFO_STATUS", LUA_NATIVE_SOCIALCLUB_SC_ACHIEVEMENT_INFO_STATUS);
+		SOCIALCLUB.set_function("SC_HAS_ACHIEVEMENT_BEEN_PASSED", LUA_NATIVE_SOCIALCLUB_SC_HAS_ACHIEVEMENT_BEEN_PASSED);
+	}
+}

src/lua/natives/lua_native_binding_STREAMING.cpp

@@ -0,0 +1,776 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_STREAMING_LOAD_ALL_OBJECTS_NOW(  )
+	{
+		STREAMING::LOAD_ALL_OBJECTS_NOW();
+	}
+
+	static void LUA_NATIVE_STREAMING_LOAD_SCENE( float x, float y, float z )
+	{
+		STREAMING::LOAD_SCENE(x, y, z);
+	}
+
+	static bool LUA_NATIVE_STREAMING_NETWORK_UPDATE_LOAD_SCENE(  )
+	{
+		auto retval = (bool)STREAMING::NETWORK_UPDATE_LOAD_SCENE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_NETWORK_LOADING_SCENE(  )
+	{
+		auto retval = (bool)STREAMING::IS_NETWORK_LOADING_SCENE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_INTERIOR_ACTIVE( int interiorID, bool toggle )
+	{
+		STREAMING::SET_INTERIOR_ACTIVE(interiorID, toggle);
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_MODEL( Hash model )
+	{
+		STREAMING::REQUEST_MODEL(model);
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_MENU_PED_MODEL( Hash model )
+	{
+		STREAMING::REQUEST_MENU_PED_MODEL(model);
+	}
+
+	static bool LUA_NATIVE_STREAMING_HAS_MODEL_LOADED( Hash model )
+	{
+		auto retval = (bool)STREAMING::HAS_MODEL_LOADED(model);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_MODELS_IN_ROOM( Interior interior, const char* roomName )
+	{
+		STREAMING::REQUEST_MODELS_IN_ROOM(interior, roomName);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_MODEL_AS_NO_LONGER_NEEDED( Hash model )
+	{
+		STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(model);
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_IN_CDIMAGE( Hash model )
+	{
+		auto retval = (bool)STREAMING::IS_MODEL_IN_CDIMAGE(model);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_VALID( Hash model )
+	{
+		auto retval = (bool)STREAMING::IS_MODEL_VALID(model);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_A_PED( Hash model )
+	{
+		auto retval = (bool)STREAMING::IS_MODEL_A_PED(model);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_A_VEHICLE( Hash model )
+	{
+		auto retval = (bool)STREAMING::IS_MODEL_A_VEHICLE(model);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_COLLISION_AT_COORD( float x, float y, float z )
+	{
+		STREAMING::REQUEST_COLLISION_AT_COORD(x, y, z);
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_COLLISION_FOR_MODEL( Hash model )
+	{
+		STREAMING::REQUEST_COLLISION_FOR_MODEL(model);
+	}
+
+	static bool LUA_NATIVE_STREAMING_HAS_COLLISION_FOR_MODEL_LOADED( Hash model )
+	{
+		auto retval = (bool)STREAMING::HAS_COLLISION_FOR_MODEL_LOADED(model);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_ADDITIONAL_COLLISION_AT_COORD( float x, float y, float z )
+	{
+		STREAMING::REQUEST_ADDITIONAL_COLLISION_AT_COORD(x, y, z);
+	}
+
+	static bool LUA_NATIVE_STREAMING_DOES_ANIM_DICT_EXIST( const char* animDict )
+	{
+		auto retval = (bool)STREAMING::DOES_ANIM_DICT_EXIST(animDict);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_ANIM_DICT( const char* animDict )
+	{
+		STREAMING::REQUEST_ANIM_DICT(animDict);
+	}
+
+	static bool LUA_NATIVE_STREAMING_HAS_ANIM_DICT_LOADED( const char* animDict )
+	{
+		auto retval = (bool)STREAMING::HAS_ANIM_DICT_LOADED(animDict);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REMOVE_ANIM_DICT( const char* animDict )
+	{
+		STREAMING::REMOVE_ANIM_DICT(animDict);
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_ANIM_SET( const char* animSet )
+	{
+		STREAMING::REQUEST_ANIM_SET(animSet);
+	}
+
+	static bool LUA_NATIVE_STREAMING_HAS_ANIM_SET_LOADED( const char* animSet )
+	{
+		auto retval = (bool)STREAMING::HAS_ANIM_SET_LOADED(animSet);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REMOVE_ANIM_SET( const char* animSet )
+	{
+		STREAMING::REMOVE_ANIM_SET(animSet);
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_CLIP_SET( const char* clipSet )
+	{
+		STREAMING::REQUEST_CLIP_SET(clipSet);
+	}
+
+	static bool LUA_NATIVE_STREAMING_HAS_CLIP_SET_LOADED( const char* clipSet )
+	{
+		auto retval = (bool)STREAMING::HAS_CLIP_SET_LOADED(clipSet);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REMOVE_CLIP_SET( const char* clipSet )
+	{
+		STREAMING::REMOVE_CLIP_SET(clipSet);
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_IPL( const char* iplName )
+	{
+		STREAMING::REQUEST_IPL(iplName);
+	}
+
+	static void LUA_NATIVE_STREAMING_REMOVE_IPL( const char* iplName )
+	{
+		STREAMING::REMOVE_IPL(iplName);
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_IPL_ACTIVE( const char* iplName )
+	{
+		auto retval = (bool)STREAMING::IS_IPL_ACTIVE(iplName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_STREAMING( bool toggle )
+	{
+		STREAMING::SET_STREAMING(toggle);
+	}
+
+	static void LUA_NATIVE_STREAMING_LOAD_GLOBAL_WATER_FILE( int waterType )
+	{
+		STREAMING::LOAD_GLOBAL_WATER_FILE(waterType);
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_GLOBAL_WATER_FILE(  )
+	{
+		auto retval = STREAMING::GET_GLOBAL_WATER_FILE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_GAME_PAUSES_FOR_STREAMING( bool toggle )
+	{
+		STREAMING::SET_GAME_PAUSES_FOR_STREAMING(toggle);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_REDUCE_PED_MODEL_BUDGET( bool toggle )
+	{
+		STREAMING::SET_REDUCE_PED_MODEL_BUDGET(toggle);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_REDUCE_VEHICLE_MODEL_BUDGET( bool toggle )
+	{
+		STREAMING::SET_REDUCE_VEHICLE_MODEL_BUDGET(toggle);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_DITCH_POLICE_MODELS( bool toggle )
+	{
+		STREAMING::SET_DITCH_POLICE_MODELS(toggle);
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_NUMBER_OF_STREAMING_REQUESTS(  )
+	{
+		auto retval = STREAMING::GET_NUMBER_OF_STREAMING_REQUESTS();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_PTFX_ASSET(  )
+	{
+		STREAMING::REQUEST_PTFX_ASSET();
+	}
+
+	static bool LUA_NATIVE_STREAMING_HAS_PTFX_ASSET_LOADED(  )
+	{
+		auto retval = (bool)STREAMING::HAS_PTFX_ASSET_LOADED();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REMOVE_PTFX_ASSET(  )
+	{
+		STREAMING::REMOVE_PTFX_ASSET();
+	}
+
+	static void LUA_NATIVE_STREAMING_REQUEST_NAMED_PTFX_ASSET( const char* fxName )
+	{
+		STREAMING::REQUEST_NAMED_PTFX_ASSET(fxName);
+	}
+
+	static bool LUA_NATIVE_STREAMING_HAS_NAMED_PTFX_ASSET_LOADED( const char* fxName )
+	{
+		auto retval = (bool)STREAMING::HAS_NAMED_PTFX_ASSET_LOADED(fxName);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REMOVE_NAMED_PTFX_ASSET( const char* fxName )
+	{
+		STREAMING::REMOVE_NAMED_PTFX_ASSET(fxName);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_VEHICLE_POPULATION_BUDGET( int p0 )
+	{
+		STREAMING::SET_VEHICLE_POPULATION_BUDGET(p0);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_PED_POPULATION_BUDGET( int p0 )
+	{
+		STREAMING::SET_PED_POPULATION_BUDGET(p0);
+	}
+
+	static void LUA_NATIVE_STREAMING_CLEAR_FOCUS(  )
+	{
+		STREAMING::CLEAR_FOCUS();
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_FOCUS_POS_AND_VEL( float x, float y, float z, float offsetX, float offsetY, float offsetZ )
+	{
+		STREAMING::SET_FOCUS_POS_AND_VEL(x, y, z, offsetX, offsetY, offsetZ);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_FOCUS_ENTITY( Entity entity )
+	{
+		STREAMING::SET_FOCUS_ENTITY(entity);
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_ENTITY_FOCUS( Entity entity )
+	{
+		auto retval = (bool)STREAMING::IS_ENTITY_FOCUS(entity);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_RESTORE_FOCUS_ENTITY( Entity p0 )
+	{
+		STREAMING::SET_RESTORE_FOCUS_ENTITY(p0);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_MAPDATACULLBOX_ENABLED( const char* name, bool toggle )
+	{
+		STREAMING::SET_MAPDATACULLBOX_ENABLED(name, toggle);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_ALL_MAPDATA_CULLED( Any p0 )
+	{
+		STREAMING::SET_ALL_MAPDATA_CULLED(p0);
+	}
+
+	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_SPHERE( float x, float y, float z, float rad, Any p4, Any p5 )
+	{
+		auto retval = STREAMING::STREAMVOL_CREATE_SPHERE(x, y, z, rad, p4, p5);
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_FRUSTUM( float p0, float p1, float p2, float p3, float p4, float p5, float p6, Any p7, Any p8 )
+	{
+		auto retval = STREAMING::STREAMVOL_CREATE_FRUSTUM(p0, p1, p2, p3, p4, p5, p6, p7, p8);
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_LINE( float p0, float p1, float p2, float p3, float p4, float p5, Any p6 )
+	{
+		auto retval = STREAMING::STREAMVOL_CREATE_LINE(p0, p1, p2, p3, p4, p5, p6);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_STREAMVOL_DELETE( Any unused )
+	{
+		STREAMING::STREAMVOL_DELETE(unused);
+	}
+
+	static bool LUA_NATIVE_STREAMING_STREAMVOL_HAS_LOADED( Any unused )
+	{
+		auto retval = (bool)STREAMING::STREAMVOL_HAS_LOADED(unused);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_STREAMVOL_IS_VALID( Any unused )
+	{
+		auto retval = (bool)STREAMING::STREAMVOL_IS_VALID(unused);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_STREAMVOL_ACTIVE(  )
+	{
+		auto retval = (bool)STREAMING::IS_STREAMVOL_ACTIVE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START( float posX, float posY, float posZ, float offsetX, float offsetY, float offsetZ, float radius, int p7 )
+	{
+		auto retval = (bool)STREAMING::NEW_LOAD_SCENE_START(posX, posY, posZ, offsetX, offsetY, offsetZ, radius, p7);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START_SPHERE( float x, float y, float z, float radius, Any p4 )
+	{
+		auto retval = (bool)STREAMING::NEW_LOAD_SCENE_START_SPHERE(x, y, z, radius, p4);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_STOP(  )
+	{
+		STREAMING::NEW_LOAD_SCENE_STOP();
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_ACTIVE(  )
+	{
+		auto retval = (bool)STREAMING::IS_NEW_LOAD_SCENE_ACTIVE();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_LOADED(  )
+	{
+		auto retval = (bool)STREAMING::IS_NEW_LOAD_SCENE_LOADED();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_SAFE_TO_START_PLAYER_SWITCH(  )
+	{
+		auto retval = (bool)STREAMING::IS_SAFE_TO_START_PLAYER_SWITCH();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_START_PLAYER_SWITCH( Ped from, Ped to, int flags, int switchType )
+	{
+		STREAMING::START_PLAYER_SWITCH(from, to, flags, switchType);
+	}
+
+	static void LUA_NATIVE_STREAMING_STOP_PLAYER_SWITCH(  )
+	{
+		STREAMING::STOP_PLAYER_SWITCH();
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_PLAYER_SWITCH_IN_PROGRESS(  )
+	{
+		auto retval = (bool)STREAMING::IS_PLAYER_SWITCH_IN_PROGRESS();
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_TYPE(  )
+	{
+		auto retval = STREAMING::GET_PLAYER_SWITCH_TYPE();
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_IDEAL_PLAYER_SWITCH_TYPE( float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = STREAMING::GET_IDEAL_PLAYER_SWITCH_TYPE(x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_STATE(  )
+	{
+		auto retval = STREAMING::GET_PLAYER_SWITCH_STATE();
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SHORT_SWITCH_STATE(  )
+	{
+		auto retval = STREAMING::GET_PLAYER_SHORT_SWITCH_STATE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_PLAYER_SHORT_SWITCH_STYLE( int p0 )
+	{
+		STREAMING::SET_PLAYER_SHORT_SWITCH_STYLE(p0);
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_JUMP_CUT_INDEX(  )
+	{
+		auto retval = STREAMING::GET_PLAYER_SWITCH_JUMP_CUT_INDEX();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_OUTRO( float cameraCoordX, float cameraCoordY, float cameraCoordZ, float camRotationX, float camRotationY, float camRotationZ, float camFov, float camFarClip, int rotationOrder )
+	{
+		STREAMING::SET_PLAYER_SWITCH_OUTRO(cameraCoordX, cameraCoordY, cameraCoordZ, camRotationX, camRotationY, camRotationZ, camFov, camFarClip, rotationOrder);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_ESTABLISHING_SHOT( const char* name )
+	{
+		STREAMING::SET_PLAYER_SWITCH_ESTABLISHING_SHOT(name);
+	}
+
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_PAN(  )
+	{
+		STREAMING::ALLOW_PLAYER_SWITCH_PAN();
+	}
+
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_OUTRO(  )
+	{
+		STREAMING::ALLOW_PLAYER_SWITCH_OUTRO();
+	}
+
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_ASCENT(  )
+	{
+		STREAMING::ALLOW_PLAYER_SWITCH_ASCENT();
+	}
+
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_DESCENT(  )
+	{
+		STREAMING::ALLOW_PLAYER_SWITCH_DESCENT();
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_SWITCH_READY_FOR_DESCENT(  )
+	{
+		auto retval = (bool)STREAMING::IS_SWITCH_READY_FOR_DESCENT();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_ENABLE_SWITCH_PAUSE_BEFORE_DESCENT(  )
+	{
+		STREAMING::ENABLE_SWITCH_PAUSE_BEFORE_DESCENT();
+	}
+
+	static void LUA_NATIVE_STREAMING_DISABLE_SWITCH_OUTRO_FX(  )
+	{
+		STREAMING::DISABLE_SWITCH_OUTRO_FX();
+	}
+
+	static void LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_FIRSTPART( Ped ped, int flags, int switchType )
+	{
+		STREAMING::SWITCH_TO_MULTI_FIRSTPART(ped, flags, switchType);
+	}
+
+	static void LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_SECONDPART( Ped ped )
+	{
+		STREAMING::SWITCH_TO_MULTI_SECONDPART(ped);
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED(  )
+	{
+		auto retval = (bool)STREAMING::IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED();
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_DURATION(  )
+	{
+		auto retval = STREAMING::GET_PLAYER_SWITCH_INTERP_OUT_DURATION();
+		return retval;
+	}
+
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME(  )
+	{
+		auto retval = STREAMING::GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME();
+		return retval;
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_SWITCH_SKIPPING_DESCENT(  )
+	{
+		auto retval = (bool)STREAMING::IS_SWITCH_SKIPPING_DESCENT();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME(  )
+	{
+		STREAMING::SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME();
+	}
+
+	static float LUA_NATIVE_STREAMING_GET_LODSCALE(  )
+	{
+		auto retval = STREAMING::GET_LODSCALE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_OVERRIDE_LODSCALE_THIS_FRAME( float scaling )
+	{
+		STREAMING::OVERRIDE_LODSCALE_THIS_FRAME(scaling);
+	}
+
+	static void LUA_NATIVE_STREAMING_REMAP_LODSCALE_RANGE_THIS_FRAME( float p0, float p1, float p2, float p3 )
+	{
+		STREAMING::REMAP_LODSCALE_RANGE_THIS_FRAME(p0, p1, p2, p3);
+	}
+
+	static void LUA_NATIVE_STREAMING_SUPPRESS_HD_MAP_STREAMING_THIS_FRAME(  )
+	{
+		STREAMING::SUPPRESS_HD_MAP_STREAMING_THIS_FRAME();
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_RENDER_HD_ONLY( bool toggle )
+	{
+		STREAMING::SET_RENDER_HD_ONLY(toggle);
+	}
+
+	static void LUA_NATIVE_STREAMING_FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME(  )
+	{
+		STREAMING::FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME();
+	}
+
+	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_START( const char* iplName1, const char* iplName2 )
+	{
+		STREAMING::IPL_GROUP_SWAP_START(iplName1, iplName2);
+	}
+
+	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_CANCEL(  )
+	{
+		STREAMING::IPL_GROUP_SWAP_CANCEL();
+	}
+
+	static bool LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_READY(  )
+	{
+		auto retval = (bool)STREAMING::IPL_GROUP_SWAP_IS_READY();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_FINISH(  )
+	{
+		STREAMING::IPL_GROUP_SWAP_FINISH();
+	}
+
+	static bool LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_ACTIVE(  )
+	{
+		auto retval = (bool)STREAMING::IPL_GROUP_SWAP_IS_ACTIVE();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_PREFETCH_SRL( const char* srl )
+	{
+		STREAMING::PREFETCH_SRL(srl);
+	}
+
+	static bool LUA_NATIVE_STREAMING_IS_SRL_LOADED(  )
+	{
+		auto retval = (bool)STREAMING::IS_SRL_LOADED();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_BEGIN_SRL(  )
+	{
+		STREAMING::BEGIN_SRL();
+	}
+
+	static void LUA_NATIVE_STREAMING_END_SRL(  )
+	{
+		STREAMING::END_SRL();
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_SRL_TIME( float p0 )
+	{
+		STREAMING::SET_SRL_TIME(p0);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_SRL_POST_CUTSCENE_CAMERA( Any p0, Any p1, Any p2, Any p3, Any p4, Any p5 )
+	{
+		STREAMING::SET_SRL_POST_CUTSCENE_CAMERA(p0, p1, p2, p3, p4, p5);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_SRL_READAHEAD_TIMES( Any p0, Any p1, Any p2, Any p3 )
+	{
+		STREAMING::SET_SRL_READAHEAD_TIMES(p0, p1, p2, p3);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_SRL_LONG_JUMP_MODE( bool p0 )
+	{
+		STREAMING::SET_SRL_LONG_JUMP_MODE(p0);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_SRL_FORCE_PRESTREAM( Any p0 )
+	{
+		STREAMING::SET_SRL_FORCE_PRESTREAM(p0);
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_HD_AREA( float x, float y, float z, float radius )
+	{
+		STREAMING::SET_HD_AREA(x, y, z, radius);
+	}
+
+	static void LUA_NATIVE_STREAMING_CLEAR_HD_AREA(  )
+	{
+		STREAMING::CLEAR_HD_AREA();
+	}
+
+	static void LUA_NATIVE_STREAMING_INIT_CREATOR_BUDGET(  )
+	{
+		STREAMING::INIT_CREATOR_BUDGET();
+	}
+
+	static void LUA_NATIVE_STREAMING_SHUTDOWN_CREATOR_BUDGET(  )
+	{
+		STREAMING::SHUTDOWN_CREATOR_BUDGET();
+	}
+
+	static bool LUA_NATIVE_STREAMING_ADD_MODEL_TO_CREATOR_BUDGET( Hash modelHash )
+	{
+		auto retval = (bool)STREAMING::ADD_MODEL_TO_CREATOR_BUDGET(modelHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_REMOVE_MODEL_FROM_CREATOR_BUDGET( Hash modelHash )
+	{
+		STREAMING::REMOVE_MODEL_FROM_CREATOR_BUDGET(modelHash);
+	}
+
+	static float LUA_NATIVE_STREAMING_GET_USED_CREATOR_BUDGET(  )
+	{
+		auto retval = STREAMING::GET_USED_CREATOR_BUDGET();
+		return retval;
+	}
+
+	static void LUA_NATIVE_STREAMING_SET_ISLAND_ENABLED( const char* name, bool toggle )
+	{
+		STREAMING::SET_ISLAND_ENABLED(name, toggle);
+	}
+
+	void init_native_binding_STREAMING(sol::state& L)
+	{
+		auto STREAMING = L["STREAMING"].get_or_create<sol::table>();
+		STREAMING.set_function("LOAD_ALL_OBJECTS_NOW", LUA_NATIVE_STREAMING_LOAD_ALL_OBJECTS_NOW);
+		STREAMING.set_function("LOAD_SCENE", LUA_NATIVE_STREAMING_LOAD_SCENE);
+		STREAMING.set_function("NETWORK_UPDATE_LOAD_SCENE", LUA_NATIVE_STREAMING_NETWORK_UPDATE_LOAD_SCENE);
+		STREAMING.set_function("IS_NETWORK_LOADING_SCENE", LUA_NATIVE_STREAMING_IS_NETWORK_LOADING_SCENE);
+		STREAMING.set_function("SET_INTERIOR_ACTIVE", LUA_NATIVE_STREAMING_SET_INTERIOR_ACTIVE);
+		STREAMING.set_function("REQUEST_MODEL", LUA_NATIVE_STREAMING_REQUEST_MODEL);
+		STREAMING.set_function("REQUEST_MENU_PED_MODEL", LUA_NATIVE_STREAMING_REQUEST_MENU_PED_MODEL);
+		STREAMING.set_function("HAS_MODEL_LOADED", LUA_NATIVE_STREAMING_HAS_MODEL_LOADED);
+		STREAMING.set_function("REQUEST_MODELS_IN_ROOM", LUA_NATIVE_STREAMING_REQUEST_MODELS_IN_ROOM);
+		STREAMING.set_function("SET_MODEL_AS_NO_LONGER_NEEDED", LUA_NATIVE_STREAMING_SET_MODEL_AS_NO_LONGER_NEEDED);
+		STREAMING.set_function("IS_MODEL_IN_CDIMAGE", LUA_NATIVE_STREAMING_IS_MODEL_IN_CDIMAGE);
+		STREAMING.set_function("IS_MODEL_VALID", LUA_NATIVE_STREAMING_IS_MODEL_VALID);
+		STREAMING.set_function("IS_MODEL_A_PED", LUA_NATIVE_STREAMING_IS_MODEL_A_PED);
+		STREAMING.set_function("IS_MODEL_A_VEHICLE", LUA_NATIVE_STREAMING_IS_MODEL_A_VEHICLE);
+		STREAMING.set_function("REQUEST_COLLISION_AT_COORD", LUA_NATIVE_STREAMING_REQUEST_COLLISION_AT_COORD);
+		STREAMING.set_function("REQUEST_COLLISION_FOR_MODEL", LUA_NATIVE_STREAMING_REQUEST_COLLISION_FOR_MODEL);
+		STREAMING.set_function("HAS_COLLISION_FOR_MODEL_LOADED", LUA_NATIVE_STREAMING_HAS_COLLISION_FOR_MODEL_LOADED);
+		STREAMING.set_function("REQUEST_ADDITIONAL_COLLISION_AT_COORD", LUA_NATIVE_STREAMING_REQUEST_ADDITIONAL_COLLISION_AT_COORD);
+		STREAMING.set_function("DOES_ANIM_DICT_EXIST", LUA_NATIVE_STREAMING_DOES_ANIM_DICT_EXIST);
+		STREAMING.set_function("REQUEST_ANIM_DICT", LUA_NATIVE_STREAMING_REQUEST_ANIM_DICT);
+		STREAMING.set_function("HAS_ANIM_DICT_LOADED", LUA_NATIVE_STREAMING_HAS_ANIM_DICT_LOADED);
+		STREAMING.set_function("REMOVE_ANIM_DICT", LUA_NATIVE_STREAMING_REMOVE_ANIM_DICT);
+		STREAMING.set_function("REQUEST_ANIM_SET", LUA_NATIVE_STREAMING_REQUEST_ANIM_SET);
+		STREAMING.set_function("HAS_ANIM_SET_LOADED", LUA_NATIVE_STREAMING_HAS_ANIM_SET_LOADED);
+		STREAMING.set_function("REMOVE_ANIM_SET", LUA_NATIVE_STREAMING_REMOVE_ANIM_SET);
+		STREAMING.set_function("REQUEST_CLIP_SET", LUA_NATIVE_STREAMING_REQUEST_CLIP_SET);
+		STREAMING.set_function("HAS_CLIP_SET_LOADED", LUA_NATIVE_STREAMING_HAS_CLIP_SET_LOADED);
+		STREAMING.set_function("REMOVE_CLIP_SET", LUA_NATIVE_STREAMING_REMOVE_CLIP_SET);
+		STREAMING.set_function("REQUEST_IPL", LUA_NATIVE_STREAMING_REQUEST_IPL);
+		STREAMING.set_function("REMOVE_IPL", LUA_NATIVE_STREAMING_REMOVE_IPL);
+		STREAMING.set_function("IS_IPL_ACTIVE", LUA_NATIVE_STREAMING_IS_IPL_ACTIVE);
+		STREAMING.set_function("SET_STREAMING", LUA_NATIVE_STREAMING_SET_STREAMING);
+		STREAMING.set_function("LOAD_GLOBAL_WATER_FILE", LUA_NATIVE_STREAMING_LOAD_GLOBAL_WATER_FILE);
+		STREAMING.set_function("GET_GLOBAL_WATER_FILE", LUA_NATIVE_STREAMING_GET_GLOBAL_WATER_FILE);
+		STREAMING.set_function("SET_GAME_PAUSES_FOR_STREAMING", LUA_NATIVE_STREAMING_SET_GAME_PAUSES_FOR_STREAMING);
+		STREAMING.set_function("SET_REDUCE_PED_MODEL_BUDGET", LUA_NATIVE_STREAMING_SET_REDUCE_PED_MODEL_BUDGET);
+		STREAMING.set_function("SET_REDUCE_VEHICLE_MODEL_BUDGET", LUA_NATIVE_STREAMING_SET_REDUCE_VEHICLE_MODEL_BUDGET);
+		STREAMING.set_function("SET_DITCH_POLICE_MODELS", LUA_NATIVE_STREAMING_SET_DITCH_POLICE_MODELS);
+		STREAMING.set_function("GET_NUMBER_OF_STREAMING_REQUESTS", LUA_NATIVE_STREAMING_GET_NUMBER_OF_STREAMING_REQUESTS);
+		STREAMING.set_function("REQUEST_PTFX_ASSET", LUA_NATIVE_STREAMING_REQUEST_PTFX_ASSET);
+		STREAMING.set_function("HAS_PTFX_ASSET_LOADED", LUA_NATIVE_STREAMING_HAS_PTFX_ASSET_LOADED);
+		STREAMING.set_function("REMOVE_PTFX_ASSET", LUA_NATIVE_STREAMING_REMOVE_PTFX_ASSET);
+		STREAMING.set_function("REQUEST_NAMED_PTFX_ASSET", LUA_NATIVE_STREAMING_REQUEST_NAMED_PTFX_ASSET);
+		STREAMING.set_function("HAS_NAMED_PTFX_ASSET_LOADED", LUA_NATIVE_STREAMING_HAS_NAMED_PTFX_ASSET_LOADED);
+		STREAMING.set_function("REMOVE_NAMED_PTFX_ASSET", LUA_NATIVE_STREAMING_REMOVE_NAMED_PTFX_ASSET);
+		STREAMING.set_function("SET_VEHICLE_POPULATION_BUDGET", LUA_NATIVE_STREAMING_SET_VEHICLE_POPULATION_BUDGET);
+		STREAMING.set_function("SET_PED_POPULATION_BUDGET", LUA_NATIVE_STREAMING_SET_PED_POPULATION_BUDGET);
+		STREAMING.set_function("CLEAR_FOCUS", LUA_NATIVE_STREAMING_CLEAR_FOCUS);
+		STREAMING.set_function("SET_FOCUS_POS_AND_VEL", LUA_NATIVE_STREAMING_SET_FOCUS_POS_AND_VEL);
+		STREAMING.set_function("SET_FOCUS_ENTITY", LUA_NATIVE_STREAMING_SET_FOCUS_ENTITY);
+		STREAMING.set_function("IS_ENTITY_FOCUS", LUA_NATIVE_STREAMING_IS_ENTITY_FOCUS);
+		STREAMING.set_function("SET_RESTORE_FOCUS_ENTITY", LUA_NATIVE_STREAMING_SET_RESTORE_FOCUS_ENTITY);
+		STREAMING.set_function("SET_MAPDATACULLBOX_ENABLED", LUA_NATIVE_STREAMING_SET_MAPDATACULLBOX_ENABLED);
+		STREAMING.set_function("SET_ALL_MAPDATA_CULLED", LUA_NATIVE_STREAMING_SET_ALL_MAPDATA_CULLED);
+		STREAMING.set_function("STREAMVOL_CREATE_SPHERE", LUA_NATIVE_STREAMING_STREAMVOL_CREATE_SPHERE);
+		STREAMING.set_function("STREAMVOL_CREATE_FRUSTUM", LUA_NATIVE_STREAMING_STREAMVOL_CREATE_FRUSTUM);
+		STREAMING.set_function("STREAMVOL_CREATE_LINE", LUA_NATIVE_STREAMING_STREAMVOL_CREATE_LINE);
+		STREAMING.set_function("STREAMVOL_DELETE", LUA_NATIVE_STREAMING_STREAMVOL_DELETE);
+		STREAMING.set_function("STREAMVOL_HAS_LOADED", LUA_NATIVE_STREAMING_STREAMVOL_HAS_LOADED);
+		STREAMING.set_function("STREAMVOL_IS_VALID", LUA_NATIVE_STREAMING_STREAMVOL_IS_VALID);
+		STREAMING.set_function("IS_STREAMVOL_ACTIVE", LUA_NATIVE_STREAMING_IS_STREAMVOL_ACTIVE);
+		STREAMING.set_function("NEW_LOAD_SCENE_START", LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START);
+		STREAMING.set_function("NEW_LOAD_SCENE_START_SPHERE", LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START_SPHERE);
+		STREAMING.set_function("NEW_LOAD_SCENE_STOP", LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_STOP);
+		STREAMING.set_function("IS_NEW_LOAD_SCENE_ACTIVE", LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_ACTIVE);
+		STREAMING.set_function("IS_NEW_LOAD_SCENE_LOADED", LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_LOADED);
+		STREAMING.set_function("IS_SAFE_TO_START_PLAYER_SWITCH", LUA_NATIVE_STREAMING_IS_SAFE_TO_START_PLAYER_SWITCH);
+		STREAMING.set_function("START_PLAYER_SWITCH", LUA_NATIVE_STREAMING_START_PLAYER_SWITCH);
+		STREAMING.set_function("STOP_PLAYER_SWITCH", LUA_NATIVE_STREAMING_STOP_PLAYER_SWITCH);
+		STREAMING.set_function("IS_PLAYER_SWITCH_IN_PROGRESS", LUA_NATIVE_STREAMING_IS_PLAYER_SWITCH_IN_PROGRESS);
+		STREAMING.set_function("GET_PLAYER_SWITCH_TYPE", LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_TYPE);
+		STREAMING.set_function("GET_IDEAL_PLAYER_SWITCH_TYPE", LUA_NATIVE_STREAMING_GET_IDEAL_PLAYER_SWITCH_TYPE);
+		STREAMING.set_function("GET_PLAYER_SWITCH_STATE", LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_STATE);
+		STREAMING.set_function("GET_PLAYER_SHORT_SWITCH_STATE", LUA_NATIVE_STREAMING_GET_PLAYER_SHORT_SWITCH_STATE);
+		STREAMING.set_function("SET_PLAYER_SHORT_SWITCH_STYLE", LUA_NATIVE_STREAMING_SET_PLAYER_SHORT_SWITCH_STYLE);
+		STREAMING.set_function("GET_PLAYER_SWITCH_JUMP_CUT_INDEX", LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_JUMP_CUT_INDEX);
+		STREAMING.set_function("SET_PLAYER_SWITCH_OUTRO", LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_OUTRO);
+		STREAMING.set_function("SET_PLAYER_SWITCH_ESTABLISHING_SHOT", LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_ESTABLISHING_SHOT);
+		STREAMING.set_function("ALLOW_PLAYER_SWITCH_PAN", LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_PAN);
+		STREAMING.set_function("ALLOW_PLAYER_SWITCH_OUTRO", LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_OUTRO);
+		STREAMING.set_function("ALLOW_PLAYER_SWITCH_ASCENT", LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_ASCENT);
+		STREAMING.set_function("ALLOW_PLAYER_SWITCH_DESCENT", LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_DESCENT);
+		STREAMING.set_function("IS_SWITCH_READY_FOR_DESCENT", LUA_NATIVE_STREAMING_IS_SWITCH_READY_FOR_DESCENT);
+		STREAMING.set_function("ENABLE_SWITCH_PAUSE_BEFORE_DESCENT", LUA_NATIVE_STREAMING_ENABLE_SWITCH_PAUSE_BEFORE_DESCENT);
+		STREAMING.set_function("DISABLE_SWITCH_OUTRO_FX", LUA_NATIVE_STREAMING_DISABLE_SWITCH_OUTRO_FX);
+		STREAMING.set_function("SWITCH_TO_MULTI_FIRSTPART", LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_FIRSTPART);
+		STREAMING.set_function("SWITCH_TO_MULTI_SECONDPART", LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_SECONDPART);
+		STREAMING.set_function("IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED", LUA_NATIVE_STREAMING_IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED);
+		STREAMING.set_function("GET_PLAYER_SWITCH_INTERP_OUT_DURATION", LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_DURATION);
+		STREAMING.set_function("GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME", LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME);
+		STREAMING.set_function("IS_SWITCH_SKIPPING_DESCENT", LUA_NATIVE_STREAMING_IS_SWITCH_SKIPPING_DESCENT);
+		STREAMING.set_function("SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME", LUA_NATIVE_STREAMING_SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME);
+		STREAMING.set_function("GET_LODSCALE", LUA_NATIVE_STREAMING_GET_LODSCALE);
+		STREAMING.set_function("OVERRIDE_LODSCALE_THIS_FRAME", LUA_NATIVE_STREAMING_OVERRIDE_LODSCALE_THIS_FRAME);
+		STREAMING.set_function("REMAP_LODSCALE_RANGE_THIS_FRAME", LUA_NATIVE_STREAMING_REMAP_LODSCALE_RANGE_THIS_FRAME);
+		STREAMING.set_function("SUPPRESS_HD_MAP_STREAMING_THIS_FRAME", LUA_NATIVE_STREAMING_SUPPRESS_HD_MAP_STREAMING_THIS_FRAME);
+		STREAMING.set_function("SET_RENDER_HD_ONLY", LUA_NATIVE_STREAMING_SET_RENDER_HD_ONLY);
+		STREAMING.set_function("FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME", LUA_NATIVE_STREAMING_FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME);
+		STREAMING.set_function("IPL_GROUP_SWAP_START", LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_START);
+		STREAMING.set_function("IPL_GROUP_SWAP_CANCEL", LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_CANCEL);
+		STREAMING.set_function("IPL_GROUP_SWAP_IS_READY", LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_READY);
+		STREAMING.set_function("IPL_GROUP_SWAP_FINISH", LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_FINISH);
+		STREAMING.set_function("IPL_GROUP_SWAP_IS_ACTIVE", LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_ACTIVE);
+		STREAMING.set_function("PREFETCH_SRL", LUA_NATIVE_STREAMING_PREFETCH_SRL);
+		STREAMING.set_function("IS_SRL_LOADED", LUA_NATIVE_STREAMING_IS_SRL_LOADED);
+		STREAMING.set_function("BEGIN_SRL", LUA_NATIVE_STREAMING_BEGIN_SRL);
+		STREAMING.set_function("END_SRL", LUA_NATIVE_STREAMING_END_SRL);
+		STREAMING.set_function("SET_SRL_TIME", LUA_NATIVE_STREAMING_SET_SRL_TIME);
+		STREAMING.set_function("SET_SRL_POST_CUTSCENE_CAMERA", LUA_NATIVE_STREAMING_SET_SRL_POST_CUTSCENE_CAMERA);
+		STREAMING.set_function("SET_SRL_READAHEAD_TIMES", LUA_NATIVE_STREAMING_SET_SRL_READAHEAD_TIMES);
+		STREAMING.set_function("SET_SRL_LONG_JUMP_MODE", LUA_NATIVE_STREAMING_SET_SRL_LONG_JUMP_MODE);
+		STREAMING.set_function("SET_SRL_FORCE_PRESTREAM", LUA_NATIVE_STREAMING_SET_SRL_FORCE_PRESTREAM);
+		STREAMING.set_function("SET_HD_AREA", LUA_NATIVE_STREAMING_SET_HD_AREA);
+		STREAMING.set_function("CLEAR_HD_AREA", LUA_NATIVE_STREAMING_CLEAR_HD_AREA);
+		STREAMING.set_function("INIT_CREATOR_BUDGET", LUA_NATIVE_STREAMING_INIT_CREATOR_BUDGET);
+		STREAMING.set_function("SHUTDOWN_CREATOR_BUDGET", LUA_NATIVE_STREAMING_SHUTDOWN_CREATOR_BUDGET);
+		STREAMING.set_function("ADD_MODEL_TO_CREATOR_BUDGET", LUA_NATIVE_STREAMING_ADD_MODEL_TO_CREATOR_BUDGET);
+		STREAMING.set_function("REMOVE_MODEL_FROM_CREATOR_BUDGET", LUA_NATIVE_STREAMING_REMOVE_MODEL_FROM_CREATOR_BUDGET);
+		STREAMING.set_function("GET_USED_CREATOR_BUDGET", LUA_NATIVE_STREAMING_GET_USED_CREATOR_BUDGET);
+		STREAMING.set_function("SET_ISLAND_ENABLED", LUA_NATIVE_STREAMING_SET_ISLAND_ENABLED);
+	}
+}

src/lua/natives/lua_native_binding_SYSTEM.cpp

@@ -0,0 +1,194 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_SYSTEM_WAIT( int ms )
+	{
+		SYSTEM::WAIT(ms);
+	}
+
+	static int LUA_NATIVE_SYSTEM_START_NEW_SCRIPT( const char* scriptName, int stackSize )
+	{
+		auto retval = SYSTEM::START_NEW_SCRIPT(scriptName, stackSize);
+		return retval;
+	}
+
+	static std::tuple<int, Any> LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_ARGS( const char* scriptName, Any args, int argCount, int stackSize )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = SYSTEM::START_NEW_SCRIPT_WITH_ARGS(scriptName, &args, argCount, stackSize);
+		std::get<1>(return_values) = args;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH( Hash scriptHash, int stackSize )
+	{
+		auto retval = SYSTEM::START_NEW_SCRIPT_WITH_NAME_HASH(scriptHash, stackSize);
+		return retval;
+	}
+
+	static std::tuple<int, Any> LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS( Hash scriptHash, Any args, int argCount, int stackSize )
+	{
+		std::tuple<int, Any> return_values;
+		std::get<0>(return_values) = SYSTEM::START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS(scriptHash, &args, argCount, stackSize);
+		std::get<1>(return_values) = args;
+
+		return return_values;
+	}
+
+	static int LUA_NATIVE_SYSTEM_TIMERA(  )
+	{
+		auto retval = SYSTEM::TIMERA();
+		return retval;
+	}
+
+	static int LUA_NATIVE_SYSTEM_TIMERB(  )
+	{
+		auto retval = SYSTEM::TIMERB();
+		return retval;
+	}
+
+	static void LUA_NATIVE_SYSTEM_SETTIMERA( int value )
+	{
+		SYSTEM::SETTIMERA(value);
+	}
+
+	static void LUA_NATIVE_SYSTEM_SETTIMERB( int value )
+	{
+		SYSTEM::SETTIMERB(value);
+	}
+
+	static float LUA_NATIVE_SYSTEM_TIMESTEP(  )
+	{
+		auto retval = SYSTEM::TIMESTEP();
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_SIN( float value )
+	{
+		auto retval = SYSTEM::SIN(value);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_COS( float value )
+	{
+		auto retval = SYSTEM::COS(value);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_SQRT( float value )
+	{
+		auto retval = SYSTEM::SQRT(value);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_POW( float base, float exponent )
+	{
+		auto retval = SYSTEM::POW(base, exponent);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_LOG10( float value )
+	{
+		auto retval = SYSTEM::LOG10(value);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_VMAG( float x, float y, float z )
+	{
+		auto retval = SYSTEM::VMAG(x, y, z);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_VMAG2( float x, float y, float z )
+	{
+		auto retval = SYSTEM::VMAG2(x, y, z);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_VDIST( float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = SYSTEM::VDIST(x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_VDIST2( float x1, float y1, float z1, float x2, float y2, float z2 )
+	{
+		auto retval = SYSTEM::VDIST2(x1, y1, z1, x2, y2, z2);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SYSTEM_SHIFT_LEFT( int value, int bitShift )
+	{
+		auto retval = SYSTEM::SHIFT_LEFT(value, bitShift);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SYSTEM_SHIFT_RIGHT( int value, int bitShift )
+	{
+		auto retval = SYSTEM::SHIFT_RIGHT(value, bitShift);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SYSTEM_FLOOR( float value )
+	{
+		auto retval = SYSTEM::FLOOR(value);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SYSTEM_CEIL( float value )
+	{
+		auto retval = SYSTEM::CEIL(value);
+		return retval;
+	}
+
+	static int LUA_NATIVE_SYSTEM_ROUND( float value )
+	{
+		auto retval = SYSTEM::ROUND(value);
+		return retval;
+	}
+
+	static float LUA_NATIVE_SYSTEM_TO_FLOAT( int value )
+	{
+		auto retval = SYSTEM::TO_FLOAT(value);
+		return retval;
+	}
+
+	static void LUA_NATIVE_SYSTEM_SET_THIS_THREAD_PRIORITY( int priority )
+	{
+		SYSTEM::SET_THIS_THREAD_PRIORITY(priority);
+	}
+
+	void init_native_binding_SYSTEM(sol::state& L)
+	{
+		auto SYSTEM = L["SYSTEM"].get_or_create<sol::table>();
+		SYSTEM.set_function("WAIT", LUA_NATIVE_SYSTEM_WAIT);
+		SYSTEM.set_function("START_NEW_SCRIPT", LUA_NATIVE_SYSTEM_START_NEW_SCRIPT);
+		SYSTEM.set_function("START_NEW_SCRIPT_WITH_ARGS", LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_ARGS);
+		SYSTEM.set_function("START_NEW_SCRIPT_WITH_NAME_HASH", LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH);
+		SYSTEM.set_function("START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS", LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS);
+		SYSTEM.set_function("TIMERA", LUA_NATIVE_SYSTEM_TIMERA);
+		SYSTEM.set_function("TIMERB", LUA_NATIVE_SYSTEM_TIMERB);
+		SYSTEM.set_function("SETTIMERA", LUA_NATIVE_SYSTEM_SETTIMERA);
+		SYSTEM.set_function("SETTIMERB", LUA_NATIVE_SYSTEM_SETTIMERB);
+		SYSTEM.set_function("TIMESTEP", LUA_NATIVE_SYSTEM_TIMESTEP);
+		SYSTEM.set_function("SIN", LUA_NATIVE_SYSTEM_SIN);
+		SYSTEM.set_function("COS", LUA_NATIVE_SYSTEM_COS);
+		SYSTEM.set_function("SQRT", LUA_NATIVE_SYSTEM_SQRT);
+		SYSTEM.set_function("POW", LUA_NATIVE_SYSTEM_POW);
+		SYSTEM.set_function("LOG10", LUA_NATIVE_SYSTEM_LOG10);
+		SYSTEM.set_function("VMAG", LUA_NATIVE_SYSTEM_VMAG);
+		SYSTEM.set_function("VMAG2", LUA_NATIVE_SYSTEM_VMAG2);
+		SYSTEM.set_function("VDIST", LUA_NATIVE_SYSTEM_VDIST);
+		SYSTEM.set_function("VDIST2", LUA_NATIVE_SYSTEM_VDIST2);
+		SYSTEM.set_function("SHIFT_LEFT", LUA_NATIVE_SYSTEM_SHIFT_LEFT);
+		SYSTEM.set_function("SHIFT_RIGHT", LUA_NATIVE_SYSTEM_SHIFT_RIGHT);
+		SYSTEM.set_function("FLOOR", LUA_NATIVE_SYSTEM_FLOOR);
+		SYSTEM.set_function("CEIL", LUA_NATIVE_SYSTEM_CEIL);
+		SYSTEM.set_function("ROUND", LUA_NATIVE_SYSTEM_ROUND);
+		SYSTEM.set_function("TO_FLOAT", LUA_NATIVE_SYSTEM_TO_FLOAT);
+		SYSTEM.set_function("SET_THIS_THREAD_PRIORITY", LUA_NATIVE_SYSTEM_SET_THIS_THREAD_PRIORITY);
+	}
+}

src/lua/natives/lua_native_binding_WATER.cpp

@@ -0,0 +1,104 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static std::tuple<bool, float> LUA_NATIVE_WATER_GET_WATER_HEIGHT( float x, float y, float z, float height )
+	{
+		std::tuple<bool, float> return_values;
+		std::get<0>(return_values) = (bool)WATER::GET_WATER_HEIGHT(x, y, z, &height);
+		std::get<1>(return_values) = height;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, float> LUA_NATIVE_WATER_GET_WATER_HEIGHT_NO_WAVES( float x, float y, float z, float height )
+	{
+		std::tuple<bool, float> return_values;
+		std::get<0>(return_values) = (bool)WATER::GET_WATER_HEIGHT_NO_WAVES(x, y, z, &height);
+		std::get<1>(return_values) = height;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_WATER_TEST_PROBE_AGAINST_WATER( float x1, float y1, float z1, float x2, float y2, float z2, Vector3 result )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)WATER::TEST_PROBE_AGAINST_WATER(x1, y1, z1, x2, y2, z2, &result);
+		std::get<1>(return_values) = result;
+
+		return return_values;
+	}
+
+	static std::tuple<int, float> LUA_NATIVE_WATER_TEST_PROBE_AGAINST_ALL_WATER( float x1, float y1, float z1, float x2, float y2, float z2, int flags, float waterHeight )
+	{
+		std::tuple<int, float> return_values;
+		std::get<0>(return_values) = WATER::TEST_PROBE_AGAINST_ALL_WATER(x1, y1, z1, x2, y2, z2, flags, &waterHeight);
+		std::get<1>(return_values) = waterHeight;
+
+		return return_values;
+	}
+
+	static std::tuple<int, float> LUA_NATIVE_WATER_TEST_VERTICAL_PROBE_AGAINST_ALL_WATER( float x, float y, float z, int flags, float waterHeight )
+	{
+		std::tuple<int, float> return_values;
+		std::get<0>(return_values) = WATER::TEST_VERTICAL_PROBE_AGAINST_ALL_WATER(x, y, z, flags, &waterHeight);
+		std::get<1>(return_values) = waterHeight;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_WATER_MODIFY_WATER( float x, float y, float radius, float height )
+	{
+		WATER::MODIFY_WATER(x, y, radius, height);
+	}
+
+	static int LUA_NATIVE_WATER_ADD_EXTRA_CALMING_QUAD( float xLow, float yLow, float xHigh, float yHigh, float height )
+	{
+		auto retval = WATER::ADD_EXTRA_CALMING_QUAD(xLow, yLow, xHigh, yHigh, height);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WATER_REMOVE_EXTRA_CALMING_QUAD( int calmingQuad )
+	{
+		WATER::REMOVE_EXTRA_CALMING_QUAD(calmingQuad);
+	}
+
+	static void LUA_NATIVE_WATER_SET_DEEP_OCEAN_SCALER( float intensity )
+	{
+		WATER::SET_DEEP_OCEAN_SCALER(intensity);
+	}
+
+	static float LUA_NATIVE_WATER_GET_DEEP_OCEAN_SCALER(  )
+	{
+		auto retval = WATER::GET_DEEP_OCEAN_SCALER();
+		return retval;
+	}
+
+	static void LUA_NATIVE_WATER_SET_CALMED_WAVE_HEIGHT_SCALER( float height )
+	{
+		WATER::SET_CALMED_WAVE_HEIGHT_SCALER(height);
+	}
+
+	static void LUA_NATIVE_WATER_RESET_DEEP_OCEAN_SCALER(  )
+	{
+		WATER::RESET_DEEP_OCEAN_SCALER();
+	}
+
+	void init_native_binding_WATER(sol::state& L)
+	{
+		auto WATER = L["WATER"].get_or_create<sol::table>();
+		WATER.set_function("GET_WATER_HEIGHT", LUA_NATIVE_WATER_GET_WATER_HEIGHT);
+		WATER.set_function("GET_WATER_HEIGHT_NO_WAVES", LUA_NATIVE_WATER_GET_WATER_HEIGHT_NO_WAVES);
+		WATER.set_function("TEST_PROBE_AGAINST_WATER", LUA_NATIVE_WATER_TEST_PROBE_AGAINST_WATER);
+		WATER.set_function("TEST_PROBE_AGAINST_ALL_WATER", LUA_NATIVE_WATER_TEST_PROBE_AGAINST_ALL_WATER);
+		WATER.set_function("TEST_VERTICAL_PROBE_AGAINST_ALL_WATER", LUA_NATIVE_WATER_TEST_VERTICAL_PROBE_AGAINST_ALL_WATER);
+		WATER.set_function("MODIFY_WATER", LUA_NATIVE_WATER_MODIFY_WATER);
+		WATER.set_function("ADD_EXTRA_CALMING_QUAD", LUA_NATIVE_WATER_ADD_EXTRA_CALMING_QUAD);
+		WATER.set_function("REMOVE_EXTRA_CALMING_QUAD", LUA_NATIVE_WATER_REMOVE_EXTRA_CALMING_QUAD);
+		WATER.set_function("SET_DEEP_OCEAN_SCALER", LUA_NATIVE_WATER_SET_DEEP_OCEAN_SCALER);
+		WATER.set_function("GET_DEEP_OCEAN_SCALER", LUA_NATIVE_WATER_GET_DEEP_OCEAN_SCALER);
+		WATER.set_function("SET_CALMED_WAVE_HEIGHT_SCALER", LUA_NATIVE_WATER_SET_CALMED_WAVE_HEIGHT_SCALER);
+		WATER.set_function("RESET_DEEP_OCEAN_SCALER", LUA_NATIVE_WATER_RESET_DEEP_OCEAN_SCALER);
+	}
+}

src/lua/natives/lua_native_binding_WEAPON.cpp

@@ -0,0 +1,797 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static void LUA_NATIVE_WEAPON_ENABLE_LASER_SIGHT_RENDERING( bool toggle )
+	{
+		WEAPON::ENABLE_LASER_SIGHT_RENDERING(toggle);
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_TYPE_MODEL( Hash componentHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_COMPONENT_TYPE_MODEL(componentHash);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_MODEL( Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_WEAPONTYPE_MODEL(weaponHash);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_SLOT( Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_WEAPONTYPE_SLOT(weaponHash);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_GROUP( Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_WEAPONTYPE_GROUP(weaponHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT( Hash componentHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT(componentHash);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL( Hash componentHash, int extraComponentIndex )
+	{
+		auto retval = WEAPON::GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL(componentHash, extraComponentIndex);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_CURRENT_PED_WEAPON( Ped ped, Hash weaponHash, bool bForceInHand )
+	{
+		WEAPON::SET_CURRENT_PED_WEAPON(ped, weaponHash, bForceInHand);
+	}
+
+	static std::tuple<bool, Hash> LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON( Ped ped, Hash weaponHash, bool p2 )
+	{
+		std::tuple<bool, Hash> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_CURRENT_PED_WEAPON(ped, &weaponHash, p2);
+		std::get<1>(return_values) = weaponHash;
+
+		return return_values;
+	}
+
+	static Entity LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON_ENTITY_INDEX( Ped ped, Any p1 )
+	{
+		auto retval = WEAPON::GET_CURRENT_PED_WEAPON_ENTITY_INDEX(ped, p1);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_BEST_PED_WEAPON( Ped ped, bool p1 )
+	{
+		auto retval = WEAPON::GET_BEST_PED_WEAPON(ped, p1);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_SET_CURRENT_PED_VEHICLE_WEAPON( Ped ped, Hash weaponHash )
+	{
+		auto retval = (bool)WEAPON::SET_CURRENT_PED_VEHICLE_WEAPON(ped, weaponHash);
+		return retval;
+	}
+
+	static std::tuple<bool, Hash> LUA_NATIVE_WEAPON_GET_CURRENT_PED_VEHICLE_WEAPON( Ped ped, Hash weaponHash )
+	{
+		std::tuple<bool, Hash> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_CURRENT_PED_VEHICLE_WEAPON(ped, &weaponHash);
+		std::get<1>(return_values) = weaponHash;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY( Ped ped )
+	{
+		WEAPON::SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY(ped);
+	}
+
+	static bool LUA_NATIVE_WEAPON_IS_PED_ARMED( Ped ped, int typeFlags )
+	{
+		auto retval = (bool)WEAPON::IS_PED_ARMED(ped, typeFlags);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_IS_WEAPON_VALID( Hash weaponHash )
+	{
+		auto retval = (bool)WEAPON::IS_WEAPON_VALID(weaponHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON( Ped ped, Hash weaponHash, bool p2 )
+	{
+		auto retval = (bool)WEAPON::HAS_PED_GOT_WEAPON(ped, weaponHash, p2);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_IS_PED_WEAPON_READY_TO_SHOOT( Ped ped )
+	{
+		auto retval = (bool)WEAPON::IS_PED_WEAPON_READY_TO_SHOOT(ped);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_PED_WEAPONTYPE_IN_SLOT( Ped ped, Hash weaponSlot )
+	{
+		auto retval = WEAPON::GET_PED_WEAPONTYPE_IN_SLOT(ped, weaponSlot);
+		return retval;
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_AMMO_IN_PED_WEAPON( Ped ped, Hash weaponhash )
+	{
+		auto retval = WEAPON::GET_AMMO_IN_PED_WEAPON(ped, weaponhash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_ADD_AMMO_TO_PED( Ped ped, Hash weaponHash, int ammo )
+	{
+		WEAPON::ADD_AMMO_TO_PED(ped, weaponHash, ammo);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_AMMO( Ped ped, Hash weaponHash, int ammo, bool p3 )
+	{
+		WEAPON::SET_PED_AMMO(ped, weaponHash, ammo, p3);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO( Ped ped, bool toggle, Hash weaponHash )
+	{
+		WEAPON::SET_PED_INFINITE_AMMO(ped, toggle, weaponHash);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO_CLIP( Ped ped, bool toggle )
+	{
+		WEAPON::SET_PED_INFINITE_AMMO_CLIP(ped, toggle);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_STUN_GUN_FINITE_AMMO( Any p0, Any p1 )
+	{
+		WEAPON::SET_PED_STUN_GUN_FINITE_AMMO(p0, p1);
+	}
+
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_TO_PED( Ped ped, Hash weaponHash, int ammoCount, bool isHidden, bool bForceInHand )
+	{
+		WEAPON::GIVE_WEAPON_TO_PED(ped, weaponHash, ammoCount, isHidden, bForceInHand);
+	}
+
+	static void LUA_NATIVE_WEAPON_GIVE_DELAYED_WEAPON_TO_PED( Ped ped, Hash weaponHash, int ammoCount, bool bForceInHand )
+	{
+		WEAPON::GIVE_DELAYED_WEAPON_TO_PED(ped, weaponHash, ammoCount, bForceInHand);
+	}
+
+	static void LUA_NATIVE_WEAPON_REMOVE_ALL_PED_WEAPONS( Ped ped, bool p1 )
+	{
+		WEAPON::REMOVE_ALL_PED_WEAPONS(ped, p1);
+	}
+
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_FROM_PED( Ped ped, Hash weaponHash )
+	{
+		WEAPON::REMOVE_WEAPON_FROM_PED(ped, weaponHash);
+	}
+
+	static void LUA_NATIVE_WEAPON_HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE( Ped ped, bool toggle )
+	{
+		WEAPON::HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE(ped, toggle);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_CURRENT_WEAPON_VISIBLE( Ped ped, bool visible, bool deselectWeapon, bool p3, bool p4 )
+	{
+		WEAPON::SET_PED_CURRENT_WEAPON_VISIBLE(ped, visible, deselectWeapon, p3, p4);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPONS_WHEN_DEAD( Ped ped, bool toggle )
+	{
+		WEAPON::SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped, toggle);
+	}
+
+	static bool LUA_NATIVE_WEAPON_HAS_PED_BEEN_DAMAGED_BY_WEAPON( Ped ped, Hash weaponHash, int weaponType )
+	{
+		auto retval = (bool)WEAPON::HAS_PED_BEEN_DAMAGED_BY_WEAPON(ped, weaponHash, weaponType);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_CLEAR_PED_LAST_WEAPON_DAMAGE( Ped ped )
+	{
+		WEAPON::CLEAR_PED_LAST_WEAPON_DAMAGE(ped);
+	}
+
+	static bool LUA_NATIVE_WEAPON_HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON( Entity entity, Hash weaponHash, int weaponType )
+	{
+		auto retval = (bool)WEAPON::HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(entity, weaponHash, weaponType);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_CLEAR_ENTITY_LAST_WEAPON_DAMAGE( Entity entity )
+	{
+		WEAPON::CLEAR_ENTITY_LAST_WEAPON_DAMAGE(entity);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPON( Ped ped )
+	{
+		WEAPON::SET_PED_DROPS_WEAPON(ped);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_INVENTORY_WEAPON( Ped ped, Hash weaponHash, float xOffset, float yOffset, float zOffset, int ammoCount )
+	{
+		WEAPON::SET_PED_DROPS_INVENTORY_WEAPON(ped, weaponHash, xOffset, yOffset, zOffset, ammoCount);
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_MAX_AMMO_IN_CLIP( Ped ped, Hash weaponHash, bool p2 )
+	{
+		auto retval = WEAPON::GET_MAX_AMMO_IN_CLIP(ped, weaponHash, p2);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_AMMO_IN_CLIP( Ped ped, Hash weaponHash, int ammo )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_AMMO_IN_CLIP(ped, weaponHash, &ammo);
+		std::get<1>(return_values) = ammo;
+
+		return return_values;
+	}
+
+	static bool LUA_NATIVE_WEAPON_SET_AMMO_IN_CLIP( Ped ped, Hash weaponHash, int ammo )
+	{
+		auto retval = (bool)WEAPON::SET_AMMO_IN_CLIP(ped, weaponHash, ammo);
+		return retval;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_MAX_AMMO( Ped ped, Hash weaponHash, int ammo )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_MAX_AMMO(ped, weaponHash, &ammo);
+		std::get<1>(return_values) = ammo;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_MAX_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash, int ammo )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_MAX_AMMO_BY_TYPE(ped, ammoTypeHash, &ammo);
+		std::get<1>(return_values) = ammo;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_WEAPON_ADD_PED_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash, int ammo )
+	{
+		WEAPON::ADD_PED_AMMO_BY_TYPE(ped, ammoTypeHash, ammo);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash, int ammo )
+	{
+		WEAPON::SET_PED_AMMO_BY_TYPE(ped, ammoTypeHash, ammo);
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_PED_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash )
+	{
+		auto retval = WEAPON::GET_PED_AMMO_BY_TYPE(ped, ammoTypeHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_AMMO_TO_DROP( Ped ped, int p1 )
+	{
+		WEAPON::SET_PED_AMMO_TO_DROP(ped, p1);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PICKUP_AMMO_AMOUNT_SCALER( float p0 )
+	{
+		WEAPON::SET_PICKUP_AMMO_AMOUNT_SCALER(p0);
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_PED_AMMO_TYPE_FROM_WEAPON( Ped ped, Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_PED_AMMO_TYPE_FROM_WEAPON(ped, weaponHash);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON( Ped ped, Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON(ped, weaponHash);
+		return retval;
+	}
+
+	static std::tuple<bool, Vector3> LUA_NATIVE_WEAPON_GET_PED_LAST_WEAPON_IMPACT_COORD( Ped ped, Vector3 coords )
+	{
+		std::tuple<bool, Vector3> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_PED_LAST_WEAPON_IMPACT_COORD(ped, &coords);
+		std::get<1>(return_values) = coords;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_GADGET( Ped ped, Hash gadgetHash, bool p2 )
+	{
+		WEAPON::SET_PED_GADGET(ped, gadgetHash, p2);
+	}
+
+	static bool LUA_NATIVE_WEAPON_GET_IS_PED_GADGET_EQUIPPED( Ped ped, Hash gadgetHash )
+	{
+		auto retval = (bool)WEAPON::GET_IS_PED_GADGET_EQUIPPED(ped, gadgetHash);
+		return retval;
+	}
+
+	static Hash LUA_NATIVE_WEAPON_GET_SELECTED_PED_WEAPON( Ped ped )
+	{
+		auto retval = WEAPON::GET_SELECTED_PED_WEAPON(ped);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_EXPLODE_PROJECTILES( Ped ped, Hash weaponHash, bool p2 )
+	{
+		WEAPON::EXPLODE_PROJECTILES(ped, weaponHash, p2);
+	}
+
+	static void LUA_NATIVE_WEAPON_REMOVE_ALL_PROJECTILES_OF_TYPE( Hash weaponHash, bool explode )
+	{
+		WEAPON::REMOVE_ALL_PROJECTILES_OF_TYPE(weaponHash, explode);
+	}
+
+	static float LUA_NATIVE_WEAPON_GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON( Ped ped )
+	{
+		auto retval = WEAPON::GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON(ped);
+		return retval;
+	}
+
+	static float LUA_NATIVE_WEAPON_GET_MAX_RANGE_OF_CURRENT_PED_WEAPON( Ped ped )
+	{
+		auto retval = WEAPON::GET_MAX_RANGE_OF_CURRENT_PED_WEAPON(ped);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_HAS_VEHICLE_GOT_PROJECTILE_ATTACHED( Ped driver, Vehicle vehicle, Hash weaponHash, Any p3 )
+	{
+		auto retval = (bool)WEAPON::HAS_VEHICLE_GOT_PROJECTILE_ATTACHED(driver, vehicle, weaponHash, p3);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_PED( Ped ped, Hash weaponHash, Hash componentHash )
+	{
+		WEAPON::GIVE_WEAPON_COMPONENT_TO_PED(ped, weaponHash, componentHash);
+	}
+
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_PED( Ped ped, Hash weaponHash, Hash componentHash )
+	{
+		WEAPON::REMOVE_WEAPON_COMPONENT_FROM_PED(ped, weaponHash, componentHash);
+	}
+
+	static bool LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON_COMPONENT( Ped ped, Hash weaponHash, Hash componentHash )
+	{
+		auto retval = (bool)WEAPON::HAS_PED_GOT_WEAPON_COMPONENT(ped, weaponHash, componentHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_IS_PED_WEAPON_COMPONENT_ACTIVE( Ped ped, Hash weaponHash, Hash componentHash )
+	{
+		auto retval = (bool)WEAPON::IS_PED_WEAPON_COMPONENT_ACTIVE(ped, weaponHash, componentHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_REFILL_AMMO_INSTANTLY( Ped ped )
+	{
+		auto retval = (bool)WEAPON::REFILL_AMMO_INSTANTLY(ped);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_MAKE_PED_RELOAD( Ped ped )
+	{
+		auto retval = (bool)WEAPON::MAKE_PED_RELOAD(ped);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_REQUEST_WEAPON_ASSET( Hash weaponHash, int p1, int p2 )
+	{
+		WEAPON::REQUEST_WEAPON_ASSET(weaponHash, p1, p2);
+	}
+
+	static bool LUA_NATIVE_WEAPON_HAS_WEAPON_ASSET_LOADED( Hash weaponHash )
+	{
+		auto retval = (bool)WEAPON::HAS_WEAPON_ASSET_LOADED(weaponHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_ASSET( Hash weaponHash )
+	{
+		WEAPON::REMOVE_WEAPON_ASSET(weaponHash);
+	}
+
+	static Object LUA_NATIVE_WEAPON_CREATE_WEAPON_OBJECT( Hash weaponHash, int ammoCount, float x, float y, float z, bool showWorldModel, float scale, Any p7, Any p8, Any p9 )
+	{
+		auto retval = WEAPON::CREATE_WEAPON_OBJECT(weaponHash, ammoCount, x, y, z, showWorldModel, scale, p7, p8, p9);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT( Object weaponObject, Hash componentHash )
+	{
+		WEAPON::GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT(weaponObject, componentHash);
+	}
+
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT( Object object, Hash componentHash )
+	{
+		WEAPON::REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT(object, componentHash);
+	}
+
+	static bool LUA_NATIVE_WEAPON_HAS_WEAPON_GOT_WEAPON_COMPONENT( Object weapon, Hash componentHash )
+	{
+		auto retval = (bool)WEAPON::HAS_WEAPON_GOT_WEAPON_COMPONENT(weapon, componentHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_OBJECT_TO_PED( Object weaponObject, Ped ped )
+	{
+		WEAPON::GIVE_WEAPON_OBJECT_TO_PED(weaponObject, ped);
+	}
+
+	static bool LUA_NATIVE_WEAPON_DOES_WEAPON_TAKE_WEAPON_COMPONENT( Hash weaponHash, Hash componentHash )
+	{
+		auto retval = (bool)WEAPON::DOES_WEAPON_TAKE_WEAPON_COMPONENT(weaponHash, componentHash);
+		return retval;
+	}
+
+	static Object LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_FROM_PED( Ped ped, bool p1 )
+	{
+		auto retval = WEAPON::GET_WEAPON_OBJECT_FROM_PED(ped, p1);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_GIVE_LOADOUT_TO_PED( Ped ped, Hash loadoutHash )
+	{
+		WEAPON::GIVE_LOADOUT_TO_PED(ped, loadoutHash);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_WEAPON_TINT_INDEX( Ped ped, Hash weaponHash, int tintIndex )
+	{
+		WEAPON::SET_PED_WEAPON_TINT_INDEX(ped, weaponHash, tintIndex);
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_TINT_INDEX( Ped ped, Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_PED_WEAPON_TINT_INDEX(ped, weaponHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_TINT_INDEX( Object weapon, int tintIndex )
+	{
+		WEAPON::SET_WEAPON_OBJECT_TINT_INDEX(weapon, tintIndex);
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_TINT_INDEX( Object weapon )
+	{
+		auto retval = WEAPON::GET_WEAPON_OBJECT_TINT_INDEX(weapon);
+		return retval;
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_TINT_COUNT( Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_TINT_COUNT(weaponHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_WEAPON_COMPONENT_TINT_INDEX( Ped ped, Hash weaponHash, Hash camoComponentHash, int colorIndex )
+	{
+		WEAPON::SET_PED_WEAPON_COMPONENT_TINT_INDEX(ped, weaponHash, camoComponentHash, colorIndex);
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_COMPONENT_TINT_INDEX( Ped ped, Hash weaponHash, Hash camoComponentHash )
+	{
+		auto retval = WEAPON::GET_PED_WEAPON_COMPONENT_TINT_INDEX(ped, weaponHash, camoComponentHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX( Object weaponObject, Hash camoComponentHash, int colorIndex )
+	{
+		WEAPON::SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(weaponObject, camoComponentHash, colorIndex);
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX( Object weaponObject, Hash camoComponentHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(weaponObject, camoComponentHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_CAMO_INDEX( Ped ped, Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_PED_WEAPON_CAMO_INDEX(ped, weaponHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_CAMO_INDEX( Object weaponObject, int p1 )
+	{
+		WEAPON::SET_WEAPON_OBJECT_CAMO_INDEX(weaponObject, p1);
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_WEAPON_GET_WEAPON_HUD_STATS( Hash weaponHash, Any outData )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_WEAPON_HUD_STATS(weaponHash, &outData);
+		std::get<1>(return_values) = outData;
+
+		return return_values;
+	}
+
+	static std::tuple<bool, Any> LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_HUD_STATS( Hash componentHash, Any outData )
+	{
+		std::tuple<bool, Any> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::GET_WEAPON_COMPONENT_HUD_STATS(componentHash, &outData);
+		std::get<1>(return_values) = outData;
+
+		return return_values;
+	}
+
+	static float LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE( Hash weaponHash, Hash componentHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_DAMAGE(weaponHash, componentHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_CLIP_SIZE( Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_CLIP_SIZE(weaponHash);
+		return retval;
+	}
+
+	static float LUA_NATIVE_WEAPON_GET_WEAPON_TIME_BETWEEN_SHOTS( Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_TIME_BETWEEN_SHOTS(weaponHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PED_CHANCE_OF_FIRING_BLANKS( Ped ped, float xBias, float yBias )
+	{
+		WEAPON::SET_PED_CHANCE_OF_FIRING_BLANKS(ped, xBias, yBias);
+	}
+
+	static Object LUA_NATIVE_WEAPON_SET_PED_SHOOT_ORDNANCE_WEAPON( Ped ped, float p1 )
+	{
+		auto retval = WEAPON::SET_PED_SHOOT_ORDNANCE_WEAPON(ped, p1);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_REQUEST_WEAPON_HIGH_DETAIL_MODEL( Entity weaponObject )
+	{
+		WEAPON::REQUEST_WEAPON_HIGH_DETAIL_MODEL(weaponObject);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_DAMAGE_MODIFIER( Hash weaponHash, float damageMultiplier )
+	{
+		WEAPON::SET_WEAPON_DAMAGE_MODIFIER(weaponHash, damageMultiplier);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_AOE_MODIFIER( Hash weaponHash, float multiplier )
+	{
+		WEAPON::SET_WEAPON_AOE_MODIFIER(weaponHash, multiplier);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_EFFECT_DURATION_MODIFIER( Hash p0, float p1 )
+	{
+		WEAPON::SET_WEAPON_EFFECT_DURATION_MODIFIER(p0, p1);
+	}
+
+	static bool LUA_NATIVE_WEAPON_IS_PED_CURRENT_WEAPON_SILENCED( Ped ped )
+	{
+		auto retval = (bool)WEAPON::IS_PED_CURRENT_WEAPON_SILENCED(ped);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_IS_FLASH_LIGHT_ON( Ped ped )
+	{
+		auto retval = (bool)WEAPON::IS_FLASH_LIGHT_ON(ped);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_FADE_DISTANCE( float distance )
+	{
+		auto retval = (bool)WEAPON::SET_FLASH_LIGHT_FADE_DISTANCE(distance);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_ACTIVE_HISTORY( Ped ped, bool toggle )
+	{
+		WEAPON::SET_FLASH_LIGHT_ACTIVE_HISTORY(ped, toggle);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_ANIMATION_OVERRIDE( Ped ped, Hash animStyle )
+	{
+		WEAPON::SET_WEAPON_ANIMATION_OVERRIDE(ped, animStyle);
+	}
+
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE_TYPE( Hash weaponHash )
+	{
+		auto retval = WEAPON::GET_WEAPON_DAMAGE_TYPE(weaponHash);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED( Ped ped )
+	{
+		WEAPON::SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED(ped);
+	}
+
+	static bool LUA_NATIVE_WEAPON_CAN_USE_WEAPON_ON_PARACHUTE( Hash weaponHash )
+	{
+		auto retval = (bool)WEAPON::CAN_USE_WEAPON_ON_PARACHUTE(weaponHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_SPHERE( float x, float y, float z, float radius, float p4, float p5, float p6, Hash weaponHash )
+	{
+		auto retval = WEAPON::CREATE_AIR_DEFENCE_SPHERE(x, y, z, radius, p4, p5, p6, weaponHash);
+		return retval;
+	}
+
+	static int LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_ANGLED_AREA( float p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float radius, Hash weaponHash )
+	{
+		auto retval = WEAPON::CREATE_AIR_DEFENCE_ANGLED_AREA(p0, p1, p2, p3, p4, p5, p6, p7, p8, radius, weaponHash);
+		return retval;
+	}
+
+	static bool LUA_NATIVE_WEAPON_REMOVE_AIR_DEFENCE_SPHERE( int zoneId )
+	{
+		auto retval = (bool)WEAPON::REMOVE_AIR_DEFENCE_SPHERE(zoneId);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_REMOVE_ALL_AIR_DEFENCE_SPHERES(  )
+	{
+		WEAPON::REMOVE_ALL_AIR_DEFENCE_SPHERES();
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE( Player player, int zoneId, bool enable )
+	{
+		WEAPON::SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE(player, zoneId, enable);
+	}
+
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_IS_AIR_DEFENCE_SPHERE_IN_AREA( float x, float y, float z, float radius, int outZoneId )
+	{
+		std::tuple<bool, int> return_values;
+		std::get<0>(return_values) = (bool)WEAPON::IS_AIR_DEFENCE_SPHERE_IN_AREA(x, y, z, radius, &outZoneId);
+		std::get<1>(return_values) = outZoneId;
+
+		return return_values;
+	}
+
+	static void LUA_NATIVE_WEAPON_FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION( int zoneId, float x, float y, float z )
+	{
+		WEAPON::FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION(zoneId, x, y, z);
+	}
+
+	static bool LUA_NATIVE_WEAPON_DOES_AIR_DEFENCE_SPHERE_EXIST( int zoneId )
+	{
+		auto retval = (bool)WEAPON::DOES_AIR_DEFENCE_SPHERE_EXIST(zoneId);
+		return retval;
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_INVENTORY_WEAPON( Ped ped, Hash weaponHash, bool toggle )
+	{
+		WEAPON::SET_CAN_PED_SELECT_INVENTORY_WEAPON(ped, weaponHash, toggle);
+	}
+
+	static void LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_ALL_WEAPONS( Ped ped, bool toggle )
+	{
+		WEAPON::SET_CAN_PED_SELECT_ALL_WEAPONS(ped, toggle);
+	}
+
+	void init_native_binding_WEAPON(sol::state& L)
+	{
+		auto WEAPON = L["WEAPON"].get_or_create<sol::table>();
+		WEAPON.set_function("ENABLE_LASER_SIGHT_RENDERING", LUA_NATIVE_WEAPON_ENABLE_LASER_SIGHT_RENDERING);
+		WEAPON.set_function("GET_WEAPON_COMPONENT_TYPE_MODEL", LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_TYPE_MODEL);
+		WEAPON.set_function("GET_WEAPONTYPE_MODEL", LUA_NATIVE_WEAPON_GET_WEAPONTYPE_MODEL);
+		WEAPON.set_function("GET_WEAPONTYPE_SLOT", LUA_NATIVE_WEAPON_GET_WEAPONTYPE_SLOT);
+		WEAPON.set_function("GET_WEAPONTYPE_GROUP", LUA_NATIVE_WEAPON_GET_WEAPONTYPE_GROUP);
+		WEAPON.set_function("GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT", LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT);
+		WEAPON.set_function("GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL", LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL);
+		WEAPON.set_function("SET_CURRENT_PED_WEAPON", LUA_NATIVE_WEAPON_SET_CURRENT_PED_WEAPON);
+		WEAPON.set_function("GET_CURRENT_PED_WEAPON", LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON);
+		WEAPON.set_function("GET_CURRENT_PED_WEAPON_ENTITY_INDEX", LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON_ENTITY_INDEX);
+		WEAPON.set_function("GET_BEST_PED_WEAPON", LUA_NATIVE_WEAPON_GET_BEST_PED_WEAPON);
+		WEAPON.set_function("SET_CURRENT_PED_VEHICLE_WEAPON", LUA_NATIVE_WEAPON_SET_CURRENT_PED_VEHICLE_WEAPON);
+		WEAPON.set_function("GET_CURRENT_PED_VEHICLE_WEAPON", LUA_NATIVE_WEAPON_GET_CURRENT_PED_VEHICLE_WEAPON);
+		WEAPON.set_function("SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY", LUA_NATIVE_WEAPON_SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY);
+		WEAPON.set_function("IS_PED_ARMED", LUA_NATIVE_WEAPON_IS_PED_ARMED);
+		WEAPON.set_function("IS_WEAPON_VALID", LUA_NATIVE_WEAPON_IS_WEAPON_VALID);
+		WEAPON.set_function("HAS_PED_GOT_WEAPON", LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON);
+		WEAPON.set_function("IS_PED_WEAPON_READY_TO_SHOOT", LUA_NATIVE_WEAPON_IS_PED_WEAPON_READY_TO_SHOOT);
+		WEAPON.set_function("GET_PED_WEAPONTYPE_IN_SLOT", LUA_NATIVE_WEAPON_GET_PED_WEAPONTYPE_IN_SLOT);
+		WEAPON.set_function("GET_AMMO_IN_PED_WEAPON", LUA_NATIVE_WEAPON_GET_AMMO_IN_PED_WEAPON);
+		WEAPON.set_function("ADD_AMMO_TO_PED", LUA_NATIVE_WEAPON_ADD_AMMO_TO_PED);
+		WEAPON.set_function("SET_PED_AMMO", LUA_NATIVE_WEAPON_SET_PED_AMMO);
+		WEAPON.set_function("SET_PED_INFINITE_AMMO", LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO);
+		WEAPON.set_function("SET_PED_INFINITE_AMMO_CLIP", LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO_CLIP);
+		WEAPON.set_function("SET_PED_STUN_GUN_FINITE_AMMO", LUA_NATIVE_WEAPON_SET_PED_STUN_GUN_FINITE_AMMO);
+		WEAPON.set_function("GIVE_WEAPON_TO_PED", LUA_NATIVE_WEAPON_GIVE_WEAPON_TO_PED);
+		WEAPON.set_function("GIVE_DELAYED_WEAPON_TO_PED", LUA_NATIVE_WEAPON_GIVE_DELAYED_WEAPON_TO_PED);
+		WEAPON.set_function("REMOVE_ALL_PED_WEAPONS", LUA_NATIVE_WEAPON_REMOVE_ALL_PED_WEAPONS);
+		WEAPON.set_function("REMOVE_WEAPON_FROM_PED", LUA_NATIVE_WEAPON_REMOVE_WEAPON_FROM_PED);
+		WEAPON.set_function("HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE", LUA_NATIVE_WEAPON_HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE);
+		WEAPON.set_function("SET_PED_CURRENT_WEAPON_VISIBLE", LUA_NATIVE_WEAPON_SET_PED_CURRENT_WEAPON_VISIBLE);
+		WEAPON.set_function("SET_PED_DROPS_WEAPONS_WHEN_DEAD", LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPONS_WHEN_DEAD);
+		WEAPON.set_function("HAS_PED_BEEN_DAMAGED_BY_WEAPON", LUA_NATIVE_WEAPON_HAS_PED_BEEN_DAMAGED_BY_WEAPON);
+		WEAPON.set_function("CLEAR_PED_LAST_WEAPON_DAMAGE", LUA_NATIVE_WEAPON_CLEAR_PED_LAST_WEAPON_DAMAGE);
+		WEAPON.set_function("HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON", LUA_NATIVE_WEAPON_HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON);
+		WEAPON.set_function("CLEAR_ENTITY_LAST_WEAPON_DAMAGE", LUA_NATIVE_WEAPON_CLEAR_ENTITY_LAST_WEAPON_DAMAGE);
+		WEAPON.set_function("SET_PED_DROPS_WEAPON", LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPON);
+		WEAPON.set_function("SET_PED_DROPS_INVENTORY_WEAPON", LUA_NATIVE_WEAPON_SET_PED_DROPS_INVENTORY_WEAPON);
+		WEAPON.set_function("GET_MAX_AMMO_IN_CLIP", LUA_NATIVE_WEAPON_GET_MAX_AMMO_IN_CLIP);
+		WEAPON.set_function("GET_AMMO_IN_CLIP", LUA_NATIVE_WEAPON_GET_AMMO_IN_CLIP);
+		WEAPON.set_function("SET_AMMO_IN_CLIP", LUA_NATIVE_WEAPON_SET_AMMO_IN_CLIP);
+		WEAPON.set_function("GET_MAX_AMMO", LUA_NATIVE_WEAPON_GET_MAX_AMMO);
+		WEAPON.set_function("GET_MAX_AMMO_BY_TYPE", LUA_NATIVE_WEAPON_GET_MAX_AMMO_BY_TYPE);
+		WEAPON.set_function("ADD_PED_AMMO_BY_TYPE", LUA_NATIVE_WEAPON_ADD_PED_AMMO_BY_TYPE);
+		WEAPON.set_function("SET_PED_AMMO_BY_TYPE", LUA_NATIVE_WEAPON_SET_PED_AMMO_BY_TYPE);
+		WEAPON.set_function("GET_PED_AMMO_BY_TYPE", LUA_NATIVE_WEAPON_GET_PED_AMMO_BY_TYPE);
+		WEAPON.set_function("SET_PED_AMMO_TO_DROP", LUA_NATIVE_WEAPON_SET_PED_AMMO_TO_DROP);
+		WEAPON.set_function("SET_PICKUP_AMMO_AMOUNT_SCALER", LUA_NATIVE_WEAPON_SET_PICKUP_AMMO_AMOUNT_SCALER);
+		WEAPON.set_function("GET_PED_AMMO_TYPE_FROM_WEAPON", LUA_NATIVE_WEAPON_GET_PED_AMMO_TYPE_FROM_WEAPON);
+		WEAPON.set_function("GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON", LUA_NATIVE_WEAPON_GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON);
+		WEAPON.set_function("GET_PED_LAST_WEAPON_IMPACT_COORD", LUA_NATIVE_WEAPON_GET_PED_LAST_WEAPON_IMPACT_COORD);
+		WEAPON.set_function("SET_PED_GADGET", LUA_NATIVE_WEAPON_SET_PED_GADGET);
+		WEAPON.set_function("GET_IS_PED_GADGET_EQUIPPED", LUA_NATIVE_WEAPON_GET_IS_PED_GADGET_EQUIPPED);
+		WEAPON.set_function("GET_SELECTED_PED_WEAPON", LUA_NATIVE_WEAPON_GET_SELECTED_PED_WEAPON);
+		WEAPON.set_function("EXPLODE_PROJECTILES", LUA_NATIVE_WEAPON_EXPLODE_PROJECTILES);
+		WEAPON.set_function("REMOVE_ALL_PROJECTILES_OF_TYPE", LUA_NATIVE_WEAPON_REMOVE_ALL_PROJECTILES_OF_TYPE);
+		WEAPON.set_function("GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON", LUA_NATIVE_WEAPON_GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON);
+		WEAPON.set_function("GET_MAX_RANGE_OF_CURRENT_PED_WEAPON", LUA_NATIVE_WEAPON_GET_MAX_RANGE_OF_CURRENT_PED_WEAPON);
+		WEAPON.set_function("HAS_VEHICLE_GOT_PROJECTILE_ATTACHED", LUA_NATIVE_WEAPON_HAS_VEHICLE_GOT_PROJECTILE_ATTACHED);
+		WEAPON.set_function("GIVE_WEAPON_COMPONENT_TO_PED", LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_PED);
+		WEAPON.set_function("REMOVE_WEAPON_COMPONENT_FROM_PED", LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_PED);
+		WEAPON.set_function("HAS_PED_GOT_WEAPON_COMPONENT", LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON_COMPONENT);
+		WEAPON.set_function("IS_PED_WEAPON_COMPONENT_ACTIVE", LUA_NATIVE_WEAPON_IS_PED_WEAPON_COMPONENT_ACTIVE);
+		WEAPON.set_function("REFILL_AMMO_INSTANTLY", LUA_NATIVE_WEAPON_REFILL_AMMO_INSTANTLY);
+		WEAPON.set_function("MAKE_PED_RELOAD", LUA_NATIVE_WEAPON_MAKE_PED_RELOAD);
+		WEAPON.set_function("REQUEST_WEAPON_ASSET", LUA_NATIVE_WEAPON_REQUEST_WEAPON_ASSET);
+		WEAPON.set_function("HAS_WEAPON_ASSET_LOADED", LUA_NATIVE_WEAPON_HAS_WEAPON_ASSET_LOADED);
+		WEAPON.set_function("REMOVE_WEAPON_ASSET", LUA_NATIVE_WEAPON_REMOVE_WEAPON_ASSET);
+		WEAPON.set_function("CREATE_WEAPON_OBJECT", LUA_NATIVE_WEAPON_CREATE_WEAPON_OBJECT);
+		WEAPON.set_function("GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT", LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT);
+		WEAPON.set_function("REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT", LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT);
+		WEAPON.set_function("HAS_WEAPON_GOT_WEAPON_COMPONENT", LUA_NATIVE_WEAPON_HAS_WEAPON_GOT_WEAPON_COMPONENT);
+		WEAPON.set_function("GIVE_WEAPON_OBJECT_TO_PED", LUA_NATIVE_WEAPON_GIVE_WEAPON_OBJECT_TO_PED);
+		WEAPON.set_function("DOES_WEAPON_TAKE_WEAPON_COMPONENT", LUA_NATIVE_WEAPON_DOES_WEAPON_TAKE_WEAPON_COMPONENT);
+		WEAPON.set_function("GET_WEAPON_OBJECT_FROM_PED", LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_FROM_PED);
+		WEAPON.set_function("GIVE_LOADOUT_TO_PED", LUA_NATIVE_WEAPON_GIVE_LOADOUT_TO_PED);
+		WEAPON.set_function("SET_PED_WEAPON_TINT_INDEX", LUA_NATIVE_WEAPON_SET_PED_WEAPON_TINT_INDEX);
+		WEAPON.set_function("GET_PED_WEAPON_TINT_INDEX", LUA_NATIVE_WEAPON_GET_PED_WEAPON_TINT_INDEX);
+		WEAPON.set_function("SET_WEAPON_OBJECT_TINT_INDEX", LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_TINT_INDEX);
+		WEAPON.set_function("GET_WEAPON_OBJECT_TINT_INDEX", LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_TINT_INDEX);
+		WEAPON.set_function("GET_WEAPON_TINT_COUNT", LUA_NATIVE_WEAPON_GET_WEAPON_TINT_COUNT);
+		WEAPON.set_function("SET_PED_WEAPON_COMPONENT_TINT_INDEX", LUA_NATIVE_WEAPON_SET_PED_WEAPON_COMPONENT_TINT_INDEX);
+		WEAPON.set_function("GET_PED_WEAPON_COMPONENT_TINT_INDEX", LUA_NATIVE_WEAPON_GET_PED_WEAPON_COMPONENT_TINT_INDEX);
+		WEAPON.set_function("SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX", LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX);
+		WEAPON.set_function("GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX", LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX);
+		WEAPON.set_function("GET_PED_WEAPON_CAMO_INDEX", LUA_NATIVE_WEAPON_GET_PED_WEAPON_CAMO_INDEX);
+		WEAPON.set_function("SET_WEAPON_OBJECT_CAMO_INDEX", LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_CAMO_INDEX);
+		WEAPON.set_function("GET_WEAPON_HUD_STATS", LUA_NATIVE_WEAPON_GET_WEAPON_HUD_STATS);
+		WEAPON.set_function("GET_WEAPON_COMPONENT_HUD_STATS", LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_HUD_STATS);
+		WEAPON.set_function("GET_WEAPON_DAMAGE", LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE);
+		WEAPON.set_function("GET_WEAPON_CLIP_SIZE", LUA_NATIVE_WEAPON_GET_WEAPON_CLIP_SIZE);
+		WEAPON.set_function("GET_WEAPON_TIME_BETWEEN_SHOTS", LUA_NATIVE_WEAPON_GET_WEAPON_TIME_BETWEEN_SHOTS);
+		WEAPON.set_function("SET_PED_CHANCE_OF_FIRING_BLANKS", LUA_NATIVE_WEAPON_SET_PED_CHANCE_OF_FIRING_BLANKS);
+		WEAPON.set_function("SET_PED_SHOOT_ORDNANCE_WEAPON", LUA_NATIVE_WEAPON_SET_PED_SHOOT_ORDNANCE_WEAPON);
+		WEAPON.set_function("REQUEST_WEAPON_HIGH_DETAIL_MODEL", LUA_NATIVE_WEAPON_REQUEST_WEAPON_HIGH_DETAIL_MODEL);
+		WEAPON.set_function("SET_WEAPON_DAMAGE_MODIFIER", LUA_NATIVE_WEAPON_SET_WEAPON_DAMAGE_MODIFIER);
+		WEAPON.set_function("SET_WEAPON_AOE_MODIFIER", LUA_NATIVE_WEAPON_SET_WEAPON_AOE_MODIFIER);
+		WEAPON.set_function("SET_WEAPON_EFFECT_DURATION_MODIFIER", LUA_NATIVE_WEAPON_SET_WEAPON_EFFECT_DURATION_MODIFIER);
+		WEAPON.set_function("IS_PED_CURRENT_WEAPON_SILENCED", LUA_NATIVE_WEAPON_IS_PED_CURRENT_WEAPON_SILENCED);
+		WEAPON.set_function("IS_FLASH_LIGHT_ON", LUA_NATIVE_WEAPON_IS_FLASH_LIGHT_ON);
+		WEAPON.set_function("SET_FLASH_LIGHT_FADE_DISTANCE", LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_FADE_DISTANCE);
+		WEAPON.set_function("SET_FLASH_LIGHT_ACTIVE_HISTORY", LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_ACTIVE_HISTORY);
+		WEAPON.set_function("SET_WEAPON_ANIMATION_OVERRIDE", LUA_NATIVE_WEAPON_SET_WEAPON_ANIMATION_OVERRIDE);
+		WEAPON.set_function("GET_WEAPON_DAMAGE_TYPE", LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE_TYPE);
+		WEAPON.set_function("SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED", LUA_NATIVE_WEAPON_SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED);
+		WEAPON.set_function("CAN_USE_WEAPON_ON_PARACHUTE", LUA_NATIVE_WEAPON_CAN_USE_WEAPON_ON_PARACHUTE);
+		WEAPON.set_function("CREATE_AIR_DEFENCE_SPHERE", LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_SPHERE);
+		WEAPON.set_function("CREATE_AIR_DEFENCE_ANGLED_AREA", LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_ANGLED_AREA);
+		WEAPON.set_function("REMOVE_AIR_DEFENCE_SPHERE", LUA_NATIVE_WEAPON_REMOVE_AIR_DEFENCE_SPHERE);
+		WEAPON.set_function("REMOVE_ALL_AIR_DEFENCE_SPHERES", LUA_NATIVE_WEAPON_REMOVE_ALL_AIR_DEFENCE_SPHERES);
+		WEAPON.set_function("SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE", LUA_NATIVE_WEAPON_SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE);
+		WEAPON.set_function("IS_AIR_DEFENCE_SPHERE_IN_AREA", LUA_NATIVE_WEAPON_IS_AIR_DEFENCE_SPHERE_IN_AREA);
+		WEAPON.set_function("FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION", LUA_NATIVE_WEAPON_FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION);
+		WEAPON.set_function("DOES_AIR_DEFENCE_SPHERE_EXIST", LUA_NATIVE_WEAPON_DOES_AIR_DEFENCE_SPHERE_EXIST);
+		WEAPON.set_function("SET_CAN_PED_SELECT_INVENTORY_WEAPON", LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_INVENTORY_WEAPON);
+		WEAPON.set_function("SET_CAN_PED_SELECT_ALL_WEAPONS", LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_ALL_WEAPONS);
+	}
+}

src/lua/natives/lua_native_binding_ZONE.cpp

@@ -0,0 +1,70 @@
+#include "lua_native_binding.hpp"
+#include "natives.hpp"
+
+namespace lua::native
+{
+	static int LUA_NATIVE_ZONE_GET_ZONE_AT_COORDS( float x, float y, float z )
+	{
+		auto retval = ZONE::GET_ZONE_AT_COORDS(x, y, z);
+		return retval;
+	}
+
+	static int LUA_NATIVE_ZONE_GET_ZONE_FROM_NAME_ID( const char* zoneName )
+	{
+		auto retval = ZONE::GET_ZONE_FROM_NAME_ID(zoneName);
+		return retval;
+	}
+
+	static int LUA_NATIVE_ZONE_GET_ZONE_POPSCHEDULE( int zoneId )
+	{
+		auto retval = ZONE::GET_ZONE_POPSCHEDULE(zoneId);
+		return retval;
+	}
+
+	static const char* LUA_NATIVE_ZONE_GET_NAME_OF_ZONE( float x, float y, float z )
+	{
+		auto retval = ZONE::GET_NAME_OF_ZONE(x, y, z);
+		return retval;
+	}
+
+	static void LUA_NATIVE_ZONE_SET_ZONE_ENABLED( int zoneId, bool toggle )
+	{
+		ZONE::SET_ZONE_ENABLED(zoneId, toggle);
+	}
+
+	static int LUA_NATIVE_ZONE_GET_ZONE_SCUMMINESS( int zoneId )
+	{
+		auto retval = ZONE::GET_ZONE_SCUMMINESS(zoneId);
+		return retval;
+	}
+
+	static void LUA_NATIVE_ZONE_OVERRIDE_POPSCHEDULE_VEHICLE_MODEL( int scheduleId, Hash vehicleHash )
+	{
+		ZONE::OVERRIDE_POPSCHEDULE_VEHICLE_MODEL(scheduleId, vehicleHash);
+	}
+
+	static void LUA_NATIVE_ZONE_CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL( int scheduleId )
+	{
+		ZONE::CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL(scheduleId);
+	}
+
+	static Hash LUA_NATIVE_ZONE_GET_HASH_OF_MAP_AREA_AT_COORDS( float x, float y, float z )
+	{
+		auto retval = ZONE::GET_HASH_OF_MAP_AREA_AT_COORDS(x, y, z);
+		return retval;
+	}
+
+	void init_native_binding_ZONE(sol::state& L)
+	{
+		auto ZONE = L["ZONE"].get_or_create<sol::table>();
+		ZONE.set_function("GET_ZONE_AT_COORDS", LUA_NATIVE_ZONE_GET_ZONE_AT_COORDS);
+		ZONE.set_function("GET_ZONE_FROM_NAME_ID", LUA_NATIVE_ZONE_GET_ZONE_FROM_NAME_ID);
+		ZONE.set_function("GET_ZONE_POPSCHEDULE", LUA_NATIVE_ZONE_GET_ZONE_POPSCHEDULE);
+		ZONE.set_function("GET_NAME_OF_ZONE", LUA_NATIVE_ZONE_GET_NAME_OF_ZONE);
+		ZONE.set_function("SET_ZONE_ENABLED", LUA_NATIVE_ZONE_SET_ZONE_ENABLED);
+		ZONE.set_function("GET_ZONE_SCUMMINESS", LUA_NATIVE_ZONE_GET_ZONE_SCUMMINESS);
+		ZONE.set_function("OVERRIDE_POPSCHEDULE_VEHICLE_MODEL", LUA_NATIVE_ZONE_OVERRIDE_POPSCHEDULE_VEHICLE_MODEL);
+		ZONE.set_function("CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL", LUA_NATIVE_ZONE_CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL);
+		ZONE.set_function("GET_HASH_OF_MAP_AREA_AT_COORDS", LUA_NATIVE_ZONE_GET_HASH_OF_MAP_AREA_AT_COORDS);
+	}
+}

src/lua/natives/natives_gen.py

@@ -18,11 +18,6 @@ def print_hpp(text):
     hpp_print_buf += text + "\n"
 
 
-def print_hpp_native_wrapper(text):
-    global hpp_lua_native_wrappers_print_buf
-    hpp_lua_native_wrappers_print_buf += text + "\n"
-
-
 class Arg:
     def __init__(self, name, type_):
         self.name = name
@@ -227,29 +222,7 @@ def get_natives_func_from_natives_hpp_file(natives_hpp):
 
 functions_per_namespaces = get_natives_func_from_natives_hpp_file(natives_hpp)
 
-
-def generate_lua_native_wrapper_binding_hpp_file(functions_per_namespaces):
-    print_hpp_native_wrapper("#pragma once")
-    print_hpp_native_wrapper('#include "natives.hpp"')
-    print_hpp_native_wrapper("")
-    print_hpp_native_wrapper("namespace lua::native")
-    print_hpp_native_wrapper("{")
-
-    i = 0
-    for namespace_name, native_funcs in functions_per_namespaces.items():
-        for native_func in native_funcs:
-            i += 1
-            print_hpp_native_wrapper("\t" + str(native_func))
-            print_hpp_native_wrapper("")
-    print_hpp_native_wrapper("}")
-
-    print(f"Wrote lua native wrappers for {i} native functions")
-
-
-generate_lua_native_wrapper_binding_hpp_file(functions_per_namespaces)
-
-
-def generate_native_binding_cpp_and_hpp_file(functions_per_namespaces):
+def generate_native_binding_cpp_and_hpp_files(functions_per_namespaces):
     generated_function_name = "void init_native_binding(sol::state& L)"
 
     print_hpp("#pragma once")
@@ -258,42 +231,61 @@ def generate_native_binding_cpp_and_hpp_file(functions_per_namespaces):
     print_hpp("namespace lua::native")
     print_hpp("{")
     print_hpp("\t" + generated_function_name + ";")
+    print_hpp("")
+    for namespace_name, native_funcs in functions_per_namespaces.items():
+        print_hpp("\t" + "void init_native_binding_" + namespace_name + "(sol::state& L);")
     print_hpp("}")
 
     print_cpp('#include "lua_native_binding.hpp"')
-    print_cpp('#include "lua_native_wrappers_binding.hpp"')
+    print_cpp('#include "natives.hpp"')
     print_cpp("")
     print_cpp("namespace lua::native")
     print_cpp("{")
-    print_cpp("\t" + generated_function_name)
-    print_cpp("\t{")
 
     i = 0
+
     for namespace_name, native_funcs in functions_per_namespaces.items():
-        print_cpp(
-            "\t\tauto "
-            + namespace_name
-            + ' = L["'
-            + namespace_name
-            + '"].get_or_create<sol::table>();'
-        )
+
+
+        file_name_cpp = "lua_native_binding_" + namespace_name + ".cpp"
+        if os.path.exists(file_name_cpp):
+            os.remove(file_name_cpp)
+        f = open(file_name_cpp, "a")
+
+        file_buffer = ""
+
+
+        file_buffer += '#include "lua_native_binding.hpp"\n'
+        file_buffer += '#include "natives.hpp"\n'
+        file_buffer += "\n"
+        file_buffer += "namespace lua::native\n"
+        file_buffer += "{\n"
+
+        for native_func in native_funcs:
+            file_buffer += "\tstatic " + str(native_func) + "\n\n"
+
+        file_buffer += "\t" + "void init_native_binding_" + namespace_name + "(sol::state& L)\n"
+        file_buffer += "\t{\n"
+
+        file_buffer +=  "\t\tauto " + namespace_name + ' = L["' + namespace_name + '"].get_or_create<sol::table>();\n'
 
         for native_func in native_funcs:
             i += 1
-            print_cpp(
-                "\t\t"
-                + namespace_name
-                + '.set_function("'
-                + native_func.name
-                + '", '
-                + "LUA_NATIVE_"
-                + native_func.namespace
-                + "_"
-                + native_func.name
-                + ");"
-            )
+            file_buffer += "\t\t"+ namespace_name+ '.set_function("'+ native_func.name+ '", '+ "LUA_NATIVE_"+ native_func.namespace+ "_"+ native_func.name+ ");\n"
 
-        print_cpp("")
+        file_buffer+= "\t}\n" 
+        file_buffer+= "}\n"
+
+        f.write(file_buffer)
+        f.close()
+
+    print_cpp("\t" + generated_function_name)
+    print_cpp("\t{")
+
+    for namespace_name, native_funcs in functions_per_namespaces.items():
+        # call each binding functions inside generated_function_name
+
+        print_cpp("\t\t" + "init_native_binding_" + namespace_name + "(L);")
 
     print_cpp("\t}")
     print_cpp("}")
@@ -301,8 +293,7 @@ def generate_native_binding_cpp_and_hpp_file(functions_per_namespaces):
     print(f"Wrote binding for {i} native functions")
 
 
-generate_native_binding_cpp_and_hpp_file(functions_per_namespaces)
-
+generate_native_binding_cpp_and_hpp_files(functions_per_namespaces)
 
 def write_cpp_code(cpp_print_buf):
     file_name = "lua_native_binding.cpp"
@@ -321,16 +312,6 @@ def write_hpp_code(hpp_print_buf):
     f.write(hpp_print_buf)
     f.close()
 
-
-def write_lua_native_wrappers_hpp_code(hpp_lua_native_wrappers_print_buf):
-    file_name = "lua_native_wrappers_binding.hpp"
-    if os.path.exists(file_name):
-        os.remove(file_name)
-    f = open(file_name, "a")
-    f.write(hpp_lua_native_wrappers_print_buf)
-    f.close()
-
-
 write_cpp_code(cpp_print_buf)
 write_hpp_code(hpp_print_buf)
-write_lua_native_wrappers_hpp_code(hpp_lua_native_wrappers_print_buf)
+