steamclient: generate 1.47 support

build/makefile_base.mak

@@ -735,7 +735,7 @@ lsteamclient: lsteamclient32 lsteamclient64
 
 lsteamclient64: SHELL = $(CONTAINER_SHELL64)
 lsteamclient64: $(LSTEAMCLIENT_CONFIGURE_FILES64) | $(WINE_BUILDTOOLS64) $(filter $(MAKECMDGOALS),wine64 wine32 wine)
-	+env PATH="$(abspath $(TOOLS_DIR64))/bin:$(PATH)" CXXFLAGS="-Wno-attributes $(COMMON_FLAGS) -g" CFLAGS="$(COMMON_FLAGS) -g" \
+	+env PATH="$(abspath $(TOOLS_DIR64))/bin:$(PATH)" CXXFLAGS="-Wno-attributes $(COMMON_FLAGS) -std=gnu++11 -g" CFLAGS="$(COMMON_FLAGS) -g" \
 		$(MAKE) -C $(LSTEAMCLIENT_OBJ64)
 	[ x"$(STRIP)" = x ] || $(STRIP) $(LSTEAMCLIENT_OBJ64)/lsteamclient.dll.so
 	mkdir -pv $(DST_DIR)/lib64/wine/
@@ -743,7 +743,7 @@ lsteamclient64: $(LSTEAMCLIENT_CONFIGURE_FILES64) | $(WINE_BUILDTOOLS64) $(filte
 
 lsteamclient32: SHELL = $(CONTAINER_SHELL32)
 lsteamclient32: $(LSTEAMCLIENT_CONFIGURE_FILES32) | $(WINE_BUILDTOOLS32) $(filter $(MAKECMDGOALS),wine64 wine32 wine)
-	+env PATH="$(abspath $(TOOLS_DIR32))/bin:$(PATH)" LDFLAGS="-m32" CXXFLAGS="-m32 -Wno-attributes $(COMMON_FLAGS) -g" CFLAGS="-m32 $(COMMON_FLAGS) -g" \
+	+env PATH="$(abspath $(TOOLS_DIR32))/bin:$(PATH)" LDFLAGS="-m32" CXXFLAGS="-m32 -Wno-attributes $(COMMON_FLAGS) -std=gnu++11 -g" CFLAGS="-m32 $(COMMON_FLAGS) -g" \
 		$(MAKE) -C $(LSTEAMCLIENT_OBJ32)
 	[ x"$(STRIP)" = x ] || $(STRIP) $(LSTEAMCLIENT_OBJ32)/lsteamclient.dll.so
 	mkdir -pv $(DST_DIR)/lib/wine/

lsteamclient/cppISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001.h"
 uint32 cppISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001_GetNumInstalledApps(void *linux_side)

lsteamclient/cppISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
-#include "steamworks_sdk_146/isteamappticket.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/isteamappticket.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001.h"
 uint32 cppISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001_GetAppOwnershipTicketData(void *linux_side, uint32 nAppID, void * pvBuffer, uint32 cbBufferLength, uint32 * piAppId, uint32 * piSteamId, uint32 * piSignature, uint32 * pcbSignature)

lsteamclient/cppISteamApps_STEAMAPPS_INTERFACE_VERSION008.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamApps_STEAMAPPS_INTERFACE_VERSION008.h"
 bool cppISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribed(void *linux_side)

lsteamclient/cppISteamClient_SteamClient020.cpp

@@ -0,0 +1,227 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_147
+#include "struct_converters.h"
+#include "cppISteamClient_SteamClient020.h"
+HSteamPipe cppISteamClient_SteamClient020_CreateSteamPipe(void *linux_side)
+{
+    return ((ISteamClient*)linux_side)->CreateSteamPipe();
+}
+
+bool cppISteamClient_SteamClient020_BReleaseSteamPipe(void *linux_side, HSteamPipe hSteamPipe)
+{
+    return ((ISteamClient*)linux_side)->BReleaseSteamPipe((HSteamPipe)hSteamPipe);
+}
+
+HSteamUser cppISteamClient_SteamClient020_ConnectToGlobalUser(void *linux_side, HSteamPipe hSteamPipe)
+{
+    return ((ISteamClient*)linux_side)->ConnectToGlobalUser((HSteamPipe)hSteamPipe);
+}
+
+HSteamUser cppISteamClient_SteamClient020_CreateLocalUser(void *linux_side, HSteamPipe * phSteamPipe, EAccountType eAccountType)
+{
+    return ((ISteamClient*)linux_side)->CreateLocalUser((HSteamPipe *)phSteamPipe, (EAccountType)eAccountType);
+}
+
+void cppISteamClient_SteamClient020_ReleaseUser(void *linux_side, HSteamPipe hSteamPipe, HSteamUser hUser)
+{
+    ((ISteamClient*)linux_side)->ReleaseUser((HSteamPipe)hSteamPipe, (HSteamUser)hUser);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamUser(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamUser((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamGameServer(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamGameServer((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void cppISteamClient_SteamClient020_SetLocalIPBinding(void *linux_side, const SteamIPAddress_t * unIP, uint16 usPort)
+{
+    ((ISteamClient*)linux_side)->SetLocalIPBinding((const SteamIPAddress_t *)unIP, (uint16)usPort);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamFriends(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamFriends((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamUtils(void *linux_side, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamUtils((HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamMatchmaking(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamMatchmaking((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamMatchmakingServers(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamMatchmakingServers((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void * cppISteamClient_SteamClient020_GetISteamGenericInterface(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamGenericInterface((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamUserStats(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamUserStats((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamGameServerStats(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamGameServerStats((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamApps(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamApps((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamNetworking(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamNetworking((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamRemoteStorage(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamRemoteStorage((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamScreenshots(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamScreenshots((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamGameSearch(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamGameSearch((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void cppISteamClient_SteamClient020_RunFrame(void *linux_side)
+{
+    ((ISteamClient*)linux_side)->RunFrame();
+}
+
+uint32 cppISteamClient_SteamClient020_GetIPCCallCount(void *linux_side)
+{
+    return ((ISteamClient*)linux_side)->GetIPCCallCount();
+}
+
+void cppISteamClient_SteamClient020_SetWarningMessageHook(void *linux_side, SteamAPIWarningMessageHook_t pFunction)
+{
+    ((ISteamClient*)linux_side)->SetWarningMessageHook((SteamAPIWarningMessageHook_t)pFunction);
+}
+
+bool cppISteamClient_SteamClient020_BShutdownIfAllPipesClosed(void *linux_side)
+{
+    return ((ISteamClient*)linux_side)->BShutdownIfAllPipesClosed();
+}
+
+void *cppISteamClient_SteamClient020_GetISteamHTTP(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamHTTP((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void * cppISteamClient_SteamClient020_DEPRECATED_GetISteamUnifiedMessages(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->DEPRECATED_GetISteamUnifiedMessages((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamController(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamController((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamUGC(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamUGC((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamAppList(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamAppList((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamMusic(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamMusic((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamMusicRemote(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamMusicRemote((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamHTMLSurface(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamHTMLSurface((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void cppISteamClient_SteamClient020_DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess(void *linux_side, void * _a)
+{
+    ((ISteamClient*)linux_side)->DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess((void (*)())_a);
+}
+
+void cppISteamClient_SteamClient020_DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess(void *linux_side, void * _a)
+{
+    ((ISteamClient*)linux_side)->DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess((void (*)())_a);
+}
+
+void cppISteamClient_SteamClient020_Set_SteamAPI_CCheckCallbackRegisteredInProcess(void *linux_side, SteamAPI_CheckCallbackRegistered_t func)
+{
+    func = (SteamAPI_CheckCallbackRegistered_t)manual_convert_SteamAPI_CheckCallbackRegistered_t((void*)func);
+    ((ISteamClient*)linux_side)->Set_SteamAPI_CCheckCallbackRegisteredInProcess((SteamAPI_CheckCallbackRegistered_t)func);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamInventory(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamInventory((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamVideo(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamVideo((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamParentalSettings(void *linux_side, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamParentalSettings((HSteamUser)hSteamuser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamInput(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamInput((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamParties(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamParties((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void *cppISteamClient_SteamClient020_GetISteamRemotePlay(void *linux_side, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    return ((ISteamClient*)linux_side)->GetISteamRemotePlay((HSteamUser)hSteamUser, (HSteamPipe)hSteamPipe, (const char *)pchVersion);
+}
+
+void cppISteamClient_SteamClient020_DestroyAllInterfaces(void *linux_side)
+{
+    ((ISteamClient*)linux_side)->DestroyAllInterfaces();
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamClient_SteamClient020.h

@@ -0,0 +1,42 @@
+extern HSteamPipe cppISteamClient_SteamClient020_CreateSteamPipe(void *);
+extern bool cppISteamClient_SteamClient020_BReleaseSteamPipe(void *, HSteamPipe);
+extern HSteamUser cppISteamClient_SteamClient020_ConnectToGlobalUser(void *, HSteamPipe);
+extern HSteamUser cppISteamClient_SteamClient020_CreateLocalUser(void *, HSteamPipe *, EAccountType);
+extern void cppISteamClient_SteamClient020_ReleaseUser(void *, HSteamPipe, HSteamUser);
+extern void *cppISteamClient_SteamClient020_GetISteamUser(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamGameServer(void *, HSteamUser, HSteamPipe, const char *);
+extern void cppISteamClient_SteamClient020_SetLocalIPBinding(void *, const SteamIPAddress_t *, uint16);
+extern void *cppISteamClient_SteamClient020_GetISteamFriends(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamUtils(void *, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamMatchmaking(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamMatchmakingServers(void *, HSteamUser, HSteamPipe, const char *);
+extern void * cppISteamClient_SteamClient020_GetISteamGenericInterface(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamUserStats(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamGameServerStats(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamApps(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamNetworking(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamRemoteStorage(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamScreenshots(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamGameSearch(void *, HSteamUser, HSteamPipe, const char *);
+extern void cppISteamClient_SteamClient020_RunFrame(void *);
+extern uint32 cppISteamClient_SteamClient020_GetIPCCallCount(void *);
+extern void cppISteamClient_SteamClient020_SetWarningMessageHook(void *, SteamAPIWarningMessageHook_t);
+extern bool cppISteamClient_SteamClient020_BShutdownIfAllPipesClosed(void *);
+extern void *cppISteamClient_SteamClient020_GetISteamHTTP(void *, HSteamUser, HSteamPipe, const char *);
+extern void * cppISteamClient_SteamClient020_DEPRECATED_GetISteamUnifiedMessages(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamController(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamUGC(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamAppList(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamMusic(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamMusicRemote(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamHTMLSurface(void *, HSteamUser, HSteamPipe, const char *);
+extern void cppISteamClient_SteamClient020_DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess(void *, void *);
+extern void cppISteamClient_SteamClient020_DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess(void *, void *);
+extern void cppISteamClient_SteamClient020_Set_SteamAPI_CCheckCallbackRegisteredInProcess(void *, SteamAPI_CheckCallbackRegistered_t);
+extern void *cppISteamClient_SteamClient020_GetISteamInventory(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamVideo(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamParentalSettings(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamInput(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamParties(void *, HSteamUser, HSteamPipe, const char *);
+extern void *cppISteamClient_SteamClient020_GetISteamRemotePlay(void *, HSteamUser, HSteamPipe, const char *);
+extern void cppISteamClient_SteamClient020_DestroyAllInterfaces(void *);

lsteamclient/cppISteamController_SteamController007.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamController_SteamController007.h"
 bool cppISteamController_SteamController007_Init(void *linux_side)

lsteamclient/cppISteamFriends_SteamFriends017.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamFriends_SteamFriends017.h"
 const char * cppISteamFriends_SteamFriends017_GetPersonaName(void *linux_side)

lsteamclient/cppISteamGameCoordinator_SteamGameCoordinator001.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
-#include "steamworks_sdk_146/isteamgamecoordinator.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/isteamgamecoordinator.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamGameCoordinator_SteamGameCoordinator001.h"
 EGCResults cppISteamGameCoordinator_SteamGameCoordinator001_SendMessage(void *linux_side, uint32 unMsgType, const void * pubData, uint32 cubData)

lsteamclient/cppISteamGameSearch_SteamMatchGameSearch001.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamGameSearch_SteamMatchGameSearch001.h"
 EGameSearchErrorCode_t cppISteamGameSearch_SteamMatchGameSearch001_AddGameSearchParams(void *linux_side, const char * pchKeyToFind, const char * pchValuesToFind)

lsteamclient/cppISteamGameServerStats_SteamGameServerStats001.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
-#include "steamworks_sdk_146/isteamgameserverstats.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/isteamgameserverstats.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamGameServerStats_SteamGameServerStats001.h"
 SteamAPICall_t cppISteamGameServerStats_SteamGameServerStats001_RequestUserStats(void *linux_side, CSteamID steamIDUser)

lsteamclient/cppISteamGameServer_SteamGameServer013.cpp

@@ -0,0 +1,237 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/isteamgameserver.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_147
+#include "struct_converters.h"
+#include "cppISteamGameServer_SteamGameServer013.h"
+bool cppISteamGameServer_SteamGameServer013_InitGameServer(void *linux_side, uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char * pchVersionString)
+{
+    return ((ISteamGameServer*)linux_side)->InitGameServer((uint32)unIP, (uint16)usGamePort, (uint16)usQueryPort, (uint32)unFlags, (AppId_t)nGameAppId, (const char *)pchVersionString);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetProduct(void *linux_side, const char * pszProduct)
+{
+    ((ISteamGameServer*)linux_side)->SetProduct((const char *)pszProduct);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetGameDescription(void *linux_side, const char * pszGameDescription)
+{
+    ((ISteamGameServer*)linux_side)->SetGameDescription((const char *)pszGameDescription);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetModDir(void *linux_side, const char * pszModDir)
+{
+    ((ISteamGameServer*)linux_side)->SetModDir((const char *)pszModDir);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetDedicatedServer(void *linux_side, bool bDedicated)
+{
+    ((ISteamGameServer*)linux_side)->SetDedicatedServer((bool)bDedicated);
+}
+
+void cppISteamGameServer_SteamGameServer013_LogOn(void *linux_side, const char * pszToken)
+{
+    ((ISteamGameServer*)linux_side)->LogOn((const char *)pszToken);
+}
+
+void cppISteamGameServer_SteamGameServer013_LogOnAnonymous(void *linux_side)
+{
+    ((ISteamGameServer*)linux_side)->LogOnAnonymous();
+}
+
+void cppISteamGameServer_SteamGameServer013_LogOff(void *linux_side)
+{
+    ((ISteamGameServer*)linux_side)->LogOff();
+}
+
+bool cppISteamGameServer_SteamGameServer013_BLoggedOn(void *linux_side)
+{
+    return ((ISteamGameServer*)linux_side)->BLoggedOn();
+}
+
+bool cppISteamGameServer_SteamGameServer013_BSecure(void *linux_side)
+{
+    return ((ISteamGameServer*)linux_side)->BSecure();
+}
+
+CSteamID cppISteamGameServer_SteamGameServer013_GetSteamID(void *linux_side)
+{
+    return ((ISteamGameServer*)linux_side)->GetSteamID();
+}
+
+bool cppISteamGameServer_SteamGameServer013_WasRestartRequested(void *linux_side)
+{
+    return ((ISteamGameServer*)linux_side)->WasRestartRequested();
+}
+
+void cppISteamGameServer_SteamGameServer013_SetMaxPlayerCount(void *linux_side, int cPlayersMax)
+{
+    ((ISteamGameServer*)linux_side)->SetMaxPlayerCount((int)cPlayersMax);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetBotPlayerCount(void *linux_side, int cBotplayers)
+{
+    ((ISteamGameServer*)linux_side)->SetBotPlayerCount((int)cBotplayers);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetServerName(void *linux_side, const char * pszServerName)
+{
+    ((ISteamGameServer*)linux_side)->SetServerName((const char *)pszServerName);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetMapName(void *linux_side, const char * pszMapName)
+{
+    ((ISteamGameServer*)linux_side)->SetMapName((const char *)pszMapName);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetPasswordProtected(void *linux_side, bool bPasswordProtected)
+{
+    ((ISteamGameServer*)linux_side)->SetPasswordProtected((bool)bPasswordProtected);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetSpectatorPort(void *linux_side, uint16 unSpectatorPort)
+{
+    ((ISteamGameServer*)linux_side)->SetSpectatorPort((uint16)unSpectatorPort);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetSpectatorServerName(void *linux_side, const char * pszSpectatorServerName)
+{
+    ((ISteamGameServer*)linux_side)->SetSpectatorServerName((const char *)pszSpectatorServerName);
+}
+
+void cppISteamGameServer_SteamGameServer013_ClearAllKeyValues(void *linux_side)
+{
+    ((ISteamGameServer*)linux_side)->ClearAllKeyValues();
+}
+
+void cppISteamGameServer_SteamGameServer013_SetKeyValue(void *linux_side, const char * pKey, const char * pValue)
+{
+    ((ISteamGameServer*)linux_side)->SetKeyValue((const char *)pKey, (const char *)pValue);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetGameTags(void *linux_side, const char * pchGameTags)
+{
+    ((ISteamGameServer*)linux_side)->SetGameTags((const char *)pchGameTags);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetGameData(void *linux_side, const char * pchGameData)
+{
+    ((ISteamGameServer*)linux_side)->SetGameData((const char *)pchGameData);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetRegion(void *linux_side, const char * pszRegion)
+{
+    ((ISteamGameServer*)linux_side)->SetRegion((const char *)pszRegion);
+}
+
+bool cppISteamGameServer_SteamGameServer013_SendUserConnectAndAuthenticate(void *linux_side, uint32 unIPClient, const void * pvAuthBlob, uint32 cubAuthBlobSize, CSteamID * pSteamIDUser)
+{
+    return ((ISteamGameServer*)linux_side)->SendUserConnectAndAuthenticate((uint32)unIPClient, (const void *)pvAuthBlob, (uint32)cubAuthBlobSize, (CSteamID *)pSteamIDUser);
+}
+
+CSteamID cppISteamGameServer_SteamGameServer013_CreateUnauthenticatedUserConnection(void *linux_side)
+{
+    return ((ISteamGameServer*)linux_side)->CreateUnauthenticatedUserConnection();
+}
+
+void cppISteamGameServer_SteamGameServer013_SendUserDisconnect(void *linux_side, CSteamID steamIDUser)
+{
+    ((ISteamGameServer*)linux_side)->SendUserDisconnect((CSteamID)steamIDUser);
+}
+
+bool cppISteamGameServer_SteamGameServer013_BUpdateUserData(void *linux_side, CSteamID steamIDUser, const char * pchPlayerName, uint32 uScore)
+{
+    return ((ISteamGameServer*)linux_side)->BUpdateUserData((CSteamID)steamIDUser, (const char *)pchPlayerName, (uint32)uScore);
+}
+
+HAuthTicket cppISteamGameServer_SteamGameServer013_GetAuthSessionTicket(void *linux_side, void * pTicket, int cbMaxTicket, uint32 * pcbTicket)
+{
+    return ((ISteamGameServer*)linux_side)->GetAuthSessionTicket((void *)pTicket, (int)cbMaxTicket, (uint32 *)pcbTicket);
+}
+
+EBeginAuthSessionResult cppISteamGameServer_SteamGameServer013_BeginAuthSession(void *linux_side, const void * pAuthTicket, int cbAuthTicket, CSteamID steamID)
+{
+    return ((ISteamGameServer*)linux_side)->BeginAuthSession((const void *)pAuthTicket, (int)cbAuthTicket, (CSteamID)steamID);
+}
+
+void cppISteamGameServer_SteamGameServer013_EndAuthSession(void *linux_side, CSteamID steamID)
+{
+    ((ISteamGameServer*)linux_side)->EndAuthSession((CSteamID)steamID);
+}
+
+void cppISteamGameServer_SteamGameServer013_CancelAuthTicket(void *linux_side, HAuthTicket hAuthTicket)
+{
+    ((ISteamGameServer*)linux_side)->CancelAuthTicket((HAuthTicket)hAuthTicket);
+}
+
+EUserHasLicenseForAppResult cppISteamGameServer_SteamGameServer013_UserHasLicenseForApp(void *linux_side, CSteamID steamID, AppId_t appID)
+{
+    return ((ISteamGameServer*)linux_side)->UserHasLicenseForApp((CSteamID)steamID, (AppId_t)appID);
+}
+
+bool cppISteamGameServer_SteamGameServer013_RequestUserGroupStatus(void *linux_side, CSteamID steamIDUser, CSteamID steamIDGroup)
+{
+    return ((ISteamGameServer*)linux_side)->RequestUserGroupStatus((CSteamID)steamIDUser, (CSteamID)steamIDGroup);
+}
+
+void cppISteamGameServer_SteamGameServer013_GetGameplayStats(void *linux_side)
+{
+    ((ISteamGameServer*)linux_side)->GetGameplayStats();
+}
+
+SteamAPICall_t cppISteamGameServer_SteamGameServer013_GetServerReputation(void *linux_side)
+{
+    return ((ISteamGameServer*)linux_side)->GetServerReputation();
+}
+
+SteamIPAddress_t cppISteamGameServer_SteamGameServer013_GetPublicIP(void *linux_side)
+{
+    return ((ISteamGameServer*)linux_side)->GetPublicIP();
+}
+
+bool cppISteamGameServer_SteamGameServer013_HandleIncomingPacket(void *linux_side, const void * pData, int cbData, uint32 srcIP, uint16 srcPort)
+{
+    return ((ISteamGameServer*)linux_side)->HandleIncomingPacket((const void *)pData, (int)cbData, (uint32)srcIP, (uint16)srcPort);
+}
+
+int cppISteamGameServer_SteamGameServer013_GetNextOutgoingPacket(void *linux_side, void * pOut, int cbMaxOut, uint32 * pNetAdr, uint16 * pPort)
+{
+    return ((ISteamGameServer*)linux_side)->GetNextOutgoingPacket((void *)pOut, (int)cbMaxOut, (uint32 *)pNetAdr, (uint16 *)pPort);
+}
+
+void cppISteamGameServer_SteamGameServer013_EnableHeartbeats(void *linux_side, bool bActive)
+{
+    ((ISteamGameServer*)linux_side)->EnableHeartbeats((bool)bActive);
+}
+
+void cppISteamGameServer_SteamGameServer013_SetHeartbeatInterval(void *linux_side, int iHeartbeatInterval)
+{
+    ((ISteamGameServer*)linux_side)->SetHeartbeatInterval((int)iHeartbeatInterval);
+}
+
+void cppISteamGameServer_SteamGameServer013_ForceHeartbeat(void *linux_side)
+{
+    ((ISteamGameServer*)linux_side)->ForceHeartbeat();
+}
+
+SteamAPICall_t cppISteamGameServer_SteamGameServer013_AssociateWithClan(void *linux_side, CSteamID steamIDClan)
+{
+    return ((ISteamGameServer*)linux_side)->AssociateWithClan((CSteamID)steamIDClan);
+}
+
+SteamAPICall_t cppISteamGameServer_SteamGameServer013_ComputeNewPlayerCompatibility(void *linux_side, CSteamID steamIDNewPlayer)
+{
+    return ((ISteamGameServer*)linux_side)->ComputeNewPlayerCompatibility((CSteamID)steamIDNewPlayer);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamGameServer_SteamGameServer013.h

@@ -0,0 +1,44 @@
+extern bool cppISteamGameServer_SteamGameServer013_InitGameServer(void *, uint32, uint16, uint16, uint32, AppId_t, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetProduct(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetGameDescription(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetModDir(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetDedicatedServer(void *, bool);
+extern void cppISteamGameServer_SteamGameServer013_LogOn(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_LogOnAnonymous(void *);
+extern void cppISteamGameServer_SteamGameServer013_LogOff(void *);
+extern bool cppISteamGameServer_SteamGameServer013_BLoggedOn(void *);
+extern bool cppISteamGameServer_SteamGameServer013_BSecure(void *);
+extern CSteamID cppISteamGameServer_SteamGameServer013_GetSteamID(void *);
+extern bool cppISteamGameServer_SteamGameServer013_WasRestartRequested(void *);
+extern void cppISteamGameServer_SteamGameServer013_SetMaxPlayerCount(void *, int);
+extern void cppISteamGameServer_SteamGameServer013_SetBotPlayerCount(void *, int);
+extern void cppISteamGameServer_SteamGameServer013_SetServerName(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetMapName(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetPasswordProtected(void *, bool);
+extern void cppISteamGameServer_SteamGameServer013_SetSpectatorPort(void *, uint16);
+extern void cppISteamGameServer_SteamGameServer013_SetSpectatorServerName(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_ClearAllKeyValues(void *);
+extern void cppISteamGameServer_SteamGameServer013_SetKeyValue(void *, const char *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetGameTags(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetGameData(void *, const char *);
+extern void cppISteamGameServer_SteamGameServer013_SetRegion(void *, const char *);
+extern bool cppISteamGameServer_SteamGameServer013_SendUserConnectAndAuthenticate(void *, uint32, const void *, uint32, CSteamID *);
+extern CSteamID cppISteamGameServer_SteamGameServer013_CreateUnauthenticatedUserConnection(void *);
+extern void cppISteamGameServer_SteamGameServer013_SendUserDisconnect(void *, CSteamID);
+extern bool cppISteamGameServer_SteamGameServer013_BUpdateUserData(void *, CSteamID, const char *, uint32);
+extern HAuthTicket cppISteamGameServer_SteamGameServer013_GetAuthSessionTicket(void *, void *, int, uint32 *);
+extern EBeginAuthSessionResult cppISteamGameServer_SteamGameServer013_BeginAuthSession(void *, const void *, int, CSteamID);
+extern void cppISteamGameServer_SteamGameServer013_EndAuthSession(void *, CSteamID);
+extern void cppISteamGameServer_SteamGameServer013_CancelAuthTicket(void *, HAuthTicket);
+extern EUserHasLicenseForAppResult cppISteamGameServer_SteamGameServer013_UserHasLicenseForApp(void *, CSteamID, AppId_t);
+extern bool cppISteamGameServer_SteamGameServer013_RequestUserGroupStatus(void *, CSteamID, CSteamID);
+extern void cppISteamGameServer_SteamGameServer013_GetGameplayStats(void *);
+extern SteamAPICall_t cppISteamGameServer_SteamGameServer013_GetServerReputation(void *);
+extern SteamIPAddress_t cppISteamGameServer_SteamGameServer013_GetPublicIP(void *);
+extern bool cppISteamGameServer_SteamGameServer013_HandleIncomingPacket(void *, const void *, int, uint32, uint16);
+extern int cppISteamGameServer_SteamGameServer013_GetNextOutgoingPacket(void *, void *, int, uint32 *, uint16 *);
+extern void cppISteamGameServer_SteamGameServer013_EnableHeartbeats(void *, bool);
+extern void cppISteamGameServer_SteamGameServer013_SetHeartbeatInterval(void *, int);
+extern void cppISteamGameServer_SteamGameServer013_ForceHeartbeat(void *);
+extern SteamAPICall_t cppISteamGameServer_SteamGameServer013_AssociateWithClan(void *, CSteamID);
+extern SteamAPICall_t cppISteamGameServer_SteamGameServer013_ComputeNewPlayerCompatibility(void *, CSteamID);

lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_005.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_005.h"
 bool cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_005_Init(void *linux_side)

lsteamclient/cppISteamHTTP_STEAMHTTP_INTERFACE_VERSION003.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamHTTP_STEAMHTTP_INTERFACE_VERSION003.h"
 HTTPRequestHandle cppISteamHTTP_STEAMHTTP_INTERFACE_VERSION003_CreateHTTPRequest(void *linux_side, EHTTPMethod eHTTPRequestMethod, const char * pchAbsoluteURL)

lsteamclient/cppISteamInput_SteamInput001.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamInput_SteamInput001.h"
 bool cppISteamInput_SteamInput001_Init(void *linux_side)

lsteamclient/cppISteamInventory_STEAMINVENTORY_INTERFACE_V003.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamInventory_STEAMINVENTORY_INTERFACE_V003.h"
 EResult cppISteamInventory_STEAMINVENTORY_INTERFACE_V003_GetResultStatus(void *linux_side, SteamInventoryResult_t resultHandle)

lsteamclient/cppISteamMatchmakingServers_SteamMatchMakingServers002.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamMatchmakingServers_SteamMatchMakingServers002.h"
 HServerListRequest cppISteamMatchmakingServers_SteamMatchMakingServers002_RequestInternetServerList(void *linux_side, AppId_t iApp, MatchMakingKeyValuePair_t ** ppchFilters, uint32 nFilters, ISteamMatchmakingServerListResponse * pRequestServersResponse)

lsteamclient/cppISteamMatchmaking_SteamMatchMaking009.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamMatchmaking_SteamMatchMaking009.h"
 int cppISteamMatchmaking_SteamMatchMaking009_GetFavoriteGameCount(void *linux_side)

lsteamclient/cppISteamMusicRemote_STEAMMUSICREMOTE_INTERFACE_VERSION001.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamMusicRemote_STEAMMUSICREMOTE_INTERFACE_VERSION001.h"
 bool cppISteamMusicRemote_STEAMMUSICREMOTE_INTERFACE_VERSION001_RegisterSteamMusicRemote(void *linux_side, const char * pchName)

lsteamclient/cppISteamMusic_STEAMMUSIC_INTERFACE_VERSION001.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamMusic_STEAMMUSIC_INTERFACE_VERSION001.h"
 bool cppISteamMusic_STEAMMUSIC_INTERFACE_VERSION001_BIsEnabled(void *linux_side)

lsteamclient/cppISteamNetworkingSockets_SteamNetworkingSockets006.cpp

@@ -0,0 +1,172 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/isteamnetworkingsockets.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_147
+#include "struct_converters.h"
+#include "cppISteamNetworkingSockets_SteamNetworkingSockets006.h"
+HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketIP(void *linux_side, const SteamNetworkingIPAddr * localAddress, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->CreateListenSocketIP((const SteamNetworkingIPAddr *)localAddress, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+}
+
+HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectByIPAddress(void *linux_side, const SteamNetworkingIPAddr * address, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->ConnectByIPAddress((const SteamNetworkingIPAddr *)address, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+}
+
+HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketP2P(void *linux_side, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->CreateListenSocketP2P((int)nVirtualPort, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+}
+
+HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2P(void *linux_side, const SteamNetworkingIdentity * identityRemote, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->ConnectP2P((const SteamNetworkingIdentity *)identityRemote, (int)nVirtualPort, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+}
+
+EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_AcceptConnection(void *linux_side, HSteamNetConnection hConn)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->AcceptConnection((HSteamNetConnection)hConn);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_CloseConnection(void *linux_side, HSteamNetConnection hPeer, int nReason, const char * pszDebug, bool bEnableLinger)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->CloseConnection((HSteamNetConnection)hPeer, (int)nReason, (const char *)pszDebug, (bool)bEnableLinger);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_CloseListenSocket(void *linux_side, HSteamListenSocket hSocket)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->CloseListenSocket((HSteamListenSocket)hSocket);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionUserData(void *linux_side, HSteamNetConnection hPeer, int64 nUserData)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->SetConnectionUserData((HSteamNetConnection)hPeer, (int64)nUserData);
+}
+
+int64 cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionUserData(void *linux_side, HSteamNetConnection hPeer)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetConnectionUserData((HSteamNetConnection)hPeer);
+}
+
+void cppISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionName(void *linux_side, HSteamNetConnection hPeer, const char * pszName)
+{
+    ((ISteamNetworkingSockets*)linux_side)->SetConnectionName((HSteamNetConnection)hPeer, (const char *)pszName);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionName(void *linux_side, HSteamNetConnection hPeer, char * pszName, int nMaxLen)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetConnectionName((HSteamNetConnection)hPeer, (char *)pszName, (int)nMaxLen);
+}
+
+EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_SendMessageToConnection(void *linux_side, HSteamNetConnection hConn, const void * pData, uint32 cbData, int nSendFlags, int64 * pOutMessageNumber)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->SendMessageToConnection((HSteamNetConnection)hConn, (const void *)pData, (uint32)cbData, (int)nSendFlags, (int64 *)pOutMessageNumber);
+}
+
+EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_FlushMessagesOnConnection(void *linux_side, HSteamNetConnection hConn)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->FlushMessagesOnConnection((HSteamNetConnection)hConn);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionInfo(void *linux_side, HSteamNetConnection hConn, SteamNetConnectionInfo_t * pInfo)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetConnectionInfo((HSteamNetConnection)hConn, (SteamNetConnectionInfo_t *)pInfo);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetQuickConnectionStatus(void *linux_side, HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus * pStats)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetQuickConnectionStatus((HSteamNetConnection)hConn, (SteamNetworkingQuickConnectionStatus *)pStats);
+}
+
+int cppISteamNetworkingSockets_SteamNetworkingSockets006_GetDetailedConnectionStatus(void *linux_side, HSteamNetConnection hConn, char * pszBuf, int cbBuf)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetDetailedConnectionStatus((HSteamNetConnection)hConn, (char *)pszBuf, (int)cbBuf);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetListenSocketAddress(void *linux_side, HSteamListenSocket hSocket, SteamNetworkingIPAddr * address)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetListenSocketAddress((HSteamListenSocket)hSocket, (SteamNetworkingIPAddr *)address);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateSocketPair(void *linux_side, HSteamNetConnection * pOutConnection1, HSteamNetConnection * pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity * pIdentity1, const SteamNetworkingIdentity * pIdentity2)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->CreateSocketPair((HSteamNetConnection *)pOutConnection1, (HSteamNetConnection *)pOutConnection2, (bool)bUseNetworkLoopback, (const SteamNetworkingIdentity *)pIdentity1, (const SteamNetworkingIdentity *)pIdentity2);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetIdentity(void *linux_side, SteamNetworkingIdentity * pIdentity)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetIdentity((SteamNetworkingIdentity *)pIdentity);
+}
+
+ESteamNetworkingAvailability cppISteamNetworkingSockets_SteamNetworkingSockets006_InitAuthentication(void *linux_side)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->InitAuthentication();
+}
+
+ESteamNetworkingAvailability cppISteamNetworkingSockets_SteamNetworkingSockets006_GetAuthenticationStatus(void *linux_side, SteamNetAuthenticationStatus_t * pDetails)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetAuthenticationStatus((SteamNetAuthenticationStatus_t *)pDetails);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedRelayAuthTicket(void *linux_side, const void * pvTicket, int cbTicket, SteamDatagramRelayAuthTicket * pOutParsedTicket)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->ReceivedRelayAuthTicket((const void *)pvTicket, (int)cbTicket, (SteamDatagramRelayAuthTicket *)pOutParsedTicket);
+}
+
+int cppISteamNetworkingSockets_SteamNetworkingSockets006_FindRelayAuthTicketForServer(void *linux_side, const SteamNetworkingIdentity * identityGameServer, int nVirtualPort, SteamDatagramRelayAuthTicket * pOutParsedTicket)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->FindRelayAuthTicketForServer((const SteamNetworkingIdentity *)identityGameServer, (int)nVirtualPort, (SteamDatagramRelayAuthTicket *)pOutParsedTicket);
+}
+
+HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectToHostedDedicatedServer(void *linux_side, const SteamNetworkingIdentity * identityTarget, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->ConnectToHostedDedicatedServer((const SteamNetworkingIdentity *)identityTarget, (int)nVirtualPort, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+}
+
+uint16 cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPort(void *linux_side)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetHostedDedicatedServerPort();
+}
+
+SteamNetworkingPOPID cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPOPID(void *linux_side)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetHostedDedicatedServerPOPID();
+}
+
+EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerAddress(void *linux_side, SteamDatagramHostedAddress * pRouting)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetHostedDedicatedServerAddress((SteamDatagramHostedAddress *)pRouting);
+}
+
+HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateHostedDedicatedServerListenSocket(void *linux_side, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->CreateHostedDedicatedServerListenSocket((int)nVirtualPort, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+}
+
+EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_GetGameCoordinatorServerLogin(void *linux_side, SteamDatagramGameCoordinatorServerLogin * pLoginInfo, int * pcbSignedBlob, void * pBlob)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->GetGameCoordinatorServerLogin((SteamDatagramGameCoordinatorServerLogin *)pLoginInfo, (int *)pcbSignedBlob, (void *)pBlob);
+}
+
+HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2PCustomSignaling(void *linux_side, ISteamNetworkingConnectionCustomSignaling * pSignaling, const SteamNetworkingIdentity * pPeerIdentity, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->ConnectP2PCustomSignaling((ISteamNetworkingConnectionCustomSignaling *)pSignaling, (const SteamNetworkingIdentity *)pPeerIdentity, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+}
+
+bool cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedP2PCustomSignal(void *linux_side, const void * pMsg, int cbMsg, ISteamNetworkingCustomSignalingRecvContext * pContext)
+{
+    return ((ISteamNetworkingSockets*)linux_side)->ReceivedP2PCustomSignal((const void *)pMsg, (int)cbMsg, (ISteamNetworkingCustomSignalingRecvContext *)pContext);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamNetworkingSockets_SteamNetworkingSockets006.h

@@ -0,0 +1,34 @@
+extern HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketIP(void *, const SteamNetworkingIPAddr *, int, const SteamNetworkingConfigValue_t *);
+extern HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectByIPAddress(void *, const SteamNetworkingIPAddr *, int, const SteamNetworkingConfigValue_t *);
+extern HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketP2P(void *, int, int, const SteamNetworkingConfigValue_t *);
+extern HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2P(void *, const SteamNetworkingIdentity *, int, int, const SteamNetworkingConfigValue_t *);
+extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_AcceptConnection(void *, HSteamNetConnection);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_CloseConnection(void *, HSteamNetConnection, int, const char *, bool);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_CloseListenSocket(void *, HSteamListenSocket);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionUserData(void *, HSteamNetConnection, int64);
+extern int64 cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionUserData(void *, HSteamNetConnection);
+extern void cppISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionName(void *, HSteamNetConnection, const char *);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionName(void *, HSteamNetConnection, char *, int);
+extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_SendMessageToConnection(void *, HSteamNetConnection, const void *, uint32, int, int64 *);
+extern void cppISteamNetworkingSockets_SteamNetworkingSockets006_SendMessages(void *, int, winSteamNetworkingMessage_t_147 **, int64 *);
+extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_FlushMessagesOnConnection(void *, HSteamNetConnection);
+extern int cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnConnection(void *, HSteamNetConnection, winSteamNetworkingMessage_t_147 **, int);
+extern int cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnListenSocket(void *, HSteamListenSocket, winSteamNetworkingMessage_t_147 **, int);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionInfo(void *, HSteamNetConnection, SteamNetConnectionInfo_t *);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetQuickConnectionStatus(void *, HSteamNetConnection, SteamNetworkingQuickConnectionStatus *);
+extern int cppISteamNetworkingSockets_SteamNetworkingSockets006_GetDetailedConnectionStatus(void *, HSteamNetConnection, char *, int);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetListenSocketAddress(void *, HSteamListenSocket, SteamNetworkingIPAddr *);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateSocketPair(void *, HSteamNetConnection *, HSteamNetConnection *, bool, const SteamNetworkingIdentity *, const SteamNetworkingIdentity *);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_GetIdentity(void *, SteamNetworkingIdentity *);
+extern ESteamNetworkingAvailability cppISteamNetworkingSockets_SteamNetworkingSockets006_InitAuthentication(void *);
+extern ESteamNetworkingAvailability cppISteamNetworkingSockets_SteamNetworkingSockets006_GetAuthenticationStatus(void *, SteamNetAuthenticationStatus_t *);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedRelayAuthTicket(void *, const void *, int, SteamDatagramRelayAuthTicket *);
+extern int cppISteamNetworkingSockets_SteamNetworkingSockets006_FindRelayAuthTicketForServer(void *, const SteamNetworkingIdentity *, int, SteamDatagramRelayAuthTicket *);
+extern HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectToHostedDedicatedServer(void *, const SteamNetworkingIdentity *, int, int, const SteamNetworkingConfigValue_t *);
+extern uint16 cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPort(void *);
+extern SteamNetworkingPOPID cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPOPID(void *);
+extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerAddress(void *, SteamDatagramHostedAddress *);
+extern HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateHostedDedicatedServerListenSocket(void *, int, int, const SteamNetworkingConfigValue_t *);
+extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets006_GetGameCoordinatorServerLogin(void *, SteamDatagramGameCoordinatorServerLogin *, int *, void *);
+extern HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2PCustomSignaling(void *, ISteamNetworkingConnectionCustomSignaling *, const SteamNetworkingIdentity *, int, const SteamNetworkingConfigValue_t *);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedP2PCustomSignal(void *, const void *, int, ISteamNetworkingCustomSignalingRecvContext *);

lsteamclient/cppISteamNetworkingUtils_SteamNetworkingUtils003.cpp

@@ -0,0 +1,123 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/isteamnetworkingutils.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_147
+#include "struct_converters.h"
+#include "cppISteamNetworkingUtils_SteamNetworkingUtils003.h"
+ESteamNetworkingAvailability cppISteamNetworkingUtils_SteamNetworkingUtils003_GetRelayNetworkStatus(void *linux_side, SteamRelayNetworkStatus_t * pDetails)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetRelayNetworkStatus((SteamRelayNetworkStatus_t *)pDetails);
+}
+
+float cppISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalPingLocation(void *linux_side, SteamNetworkPingLocation_t * result)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetLocalPingLocation((SteamNetworkPingLocation_t *)result);
+}
+
+int cppISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeBetweenTwoLocations(void *linux_side, const SteamNetworkPingLocation_t * location1, const SteamNetworkPingLocation_t * location2)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->EstimatePingTimeBetweenTwoLocations((const SteamNetworkPingLocation_t *)location1, (const SteamNetworkPingLocation_t *)location2);
+}
+
+int cppISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeFromLocalHost(void *linux_side, const SteamNetworkPingLocation_t * remoteLocation)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->EstimatePingTimeFromLocalHost((const SteamNetworkPingLocation_t *)remoteLocation);
+}
+
+void cppISteamNetworkingUtils_SteamNetworkingUtils003_ConvertPingLocationToString(void *linux_side, const SteamNetworkPingLocation_t * location, char * pszBuf, int cchBufSize)
+{
+    ((ISteamNetworkingUtils*)linux_side)->ConvertPingLocationToString((const SteamNetworkPingLocation_t *)location, (char *)pszBuf, (int)cchBufSize);
+}
+
+bool cppISteamNetworkingUtils_SteamNetworkingUtils003_ParsePingLocationString(void *linux_side, const char * pszString, SteamNetworkPingLocation_t * result)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->ParsePingLocationString((const char *)pszString, (SteamNetworkPingLocation_t *)result);
+}
+
+bool cppISteamNetworkingUtils_SteamNetworkingUtils003_CheckPingDataUpToDate(void *linux_side, float flMaxAgeSeconds)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->CheckPingDataUpToDate((float)flMaxAgeSeconds);
+}
+
+int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPingToDataCenter(void *linux_side, SteamNetworkingPOPID popID, SteamNetworkingPOPID * pViaRelayPoP)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetPingToDataCenter((SteamNetworkingPOPID)popID, (SteamNetworkingPOPID *)pViaRelayPoP);
+}
+
+int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetDirectPingToPOP(void *linux_side, SteamNetworkingPOPID popID)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetDirectPingToPOP((SteamNetworkingPOPID)popID);
+}
+
+int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPCount(void *linux_side)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetPOPCount();
+}
+
+int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPList(void *linux_side, SteamNetworkingPOPID * list, int nListSz)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetPOPList((SteamNetworkingPOPID *)list, (int)nListSz);
+}
+
+SteamNetworkingMicroseconds cppISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalTimestamp(void *linux_side)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetLocalTimestamp();
+}
+
+void cppISteamNetworkingUtils_SteamNetworkingUtils003_SetDebugOutputFunction(void *linux_side, ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc)
+{
+    pfnFunc = (FSteamNetworkingSocketsDebugOutput)manual_convert_FSteamNetworkingSocketsDebugOutput((void*)pfnFunc);
+    ((ISteamNetworkingUtils*)linux_side)->SetDebugOutputFunction((ESteamNetworkingSocketsDebugOutputType)eDetailLevel, (FSteamNetworkingSocketsDebugOutput)pfnFunc);
+}
+
+bool cppISteamNetworkingUtils_SteamNetworkingUtils003_SetConfigValue(void *linux_side, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType eDataType, const void * pArg)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->SetConfigValue((ESteamNetworkingConfigValue)eValue, (ESteamNetworkingConfigScope)eScopeType, (intptr_t)scopeObj, (ESteamNetworkingConfigDataType)eDataType, (const void *)pArg);
+}
+
+ESteamNetworkingGetConfigValueResult cppISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValue(void *linux_side, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType * pOutDataType, void * pResult, size_t * cbResult)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetConfigValue((ESteamNetworkingConfigValue)eValue, (ESteamNetworkingConfigScope)eScopeType, (intptr_t)scopeObj, (ESteamNetworkingConfigDataType *)pOutDataType, (void *)pResult, (size_t *)cbResult);
+}
+
+bool cppISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValueInfo(void *linux_side, ESteamNetworkingConfigValue eValue, const char ** pOutName, ESteamNetworkingConfigDataType * pOutDataType, ESteamNetworkingConfigScope * pOutScope, ESteamNetworkingConfigValue * pOutNextValue)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetConfigValueInfo((ESteamNetworkingConfigValue)eValue, (const char **)pOutName, (ESteamNetworkingConfigDataType *)pOutDataType, (ESteamNetworkingConfigScope *)pOutScope, (ESteamNetworkingConfigValue *)pOutNextValue);
+}
+
+ESteamNetworkingConfigValue cppISteamNetworkingUtils_SteamNetworkingUtils003_GetFirstConfigValue(void *linux_side)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->GetFirstConfigValue();
+}
+
+void cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ToString(void *linux_side, const SteamNetworkingIPAddr * addr, char * buf, size_t cbBuf, bool bWithPort)
+{
+    ((ISteamNetworkingUtils*)linux_side)->SteamNetworkingIPAddr_ToString((const SteamNetworkingIPAddr *)addr, (char *)buf, (size_t)cbBuf, (bool)bWithPort);
+}
+
+bool cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ParseString(void *linux_side, SteamNetworkingIPAddr * pAddr, const char * pszStr)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->SteamNetworkingIPAddr_ParseString((SteamNetworkingIPAddr *)pAddr, (const char *)pszStr);
+}
+
+void cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ToString(void *linux_side, const SteamNetworkingIdentity * identity, char * buf, size_t cbBuf)
+{
+    ((ISteamNetworkingUtils*)linux_side)->SteamNetworkingIdentity_ToString((const SteamNetworkingIdentity *)identity, (char *)buf, (size_t)cbBuf);
+}
+
+bool cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ParseString(void *linux_side, SteamNetworkingIdentity * pIdentity, const char * pszStr)
+{
+    return ((ISteamNetworkingUtils*)linux_side)->SteamNetworkingIdentity_ParseString((SteamNetworkingIdentity *)pIdentity, (const char *)pszStr);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamNetworkingUtils_SteamNetworkingUtils003.h

@@ -0,0 +1,22 @@
+extern SteamNetworkingMessage_t * cppISteamNetworkingUtils_SteamNetworkingUtils003_AllocateMessage(void *, int);
+extern ESteamNetworkingAvailability cppISteamNetworkingUtils_SteamNetworkingUtils003_GetRelayNetworkStatus(void *, SteamRelayNetworkStatus_t *);
+extern float cppISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalPingLocation(void *, SteamNetworkPingLocation_t *);
+extern int cppISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeBetweenTwoLocations(void *, const SteamNetworkPingLocation_t *, const SteamNetworkPingLocation_t *);
+extern int cppISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeFromLocalHost(void *, const SteamNetworkPingLocation_t *);
+extern void cppISteamNetworkingUtils_SteamNetworkingUtils003_ConvertPingLocationToString(void *, const SteamNetworkPingLocation_t *, char *, int);
+extern bool cppISteamNetworkingUtils_SteamNetworkingUtils003_ParsePingLocationString(void *, const char *, SteamNetworkPingLocation_t *);
+extern bool cppISteamNetworkingUtils_SteamNetworkingUtils003_CheckPingDataUpToDate(void *, float);
+extern int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPingToDataCenter(void *, SteamNetworkingPOPID, SteamNetworkingPOPID *);
+extern int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetDirectPingToPOP(void *, SteamNetworkingPOPID);
+extern int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPCount(void *);
+extern int cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPList(void *, SteamNetworkingPOPID *, int);
+extern SteamNetworkingMicroseconds cppISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalTimestamp(void *);
+extern void cppISteamNetworkingUtils_SteamNetworkingUtils003_SetDebugOutputFunction(void *, ESteamNetworkingSocketsDebugOutputType, FSteamNetworkingSocketsDebugOutput);
+extern bool cppISteamNetworkingUtils_SteamNetworkingUtils003_SetConfigValue(void *, ESteamNetworkingConfigValue, ESteamNetworkingConfigScope, intptr_t, ESteamNetworkingConfigDataType, const void *);
+extern ESteamNetworkingGetConfigValueResult cppISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValue(void *, ESteamNetworkingConfigValue, ESteamNetworkingConfigScope, intptr_t, ESteamNetworkingConfigDataType *, void *, size_t *);
+extern bool cppISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValueInfo(void *, ESteamNetworkingConfigValue, const char **, ESteamNetworkingConfigDataType *, ESteamNetworkingConfigScope *, ESteamNetworkingConfigValue *);
+extern ESteamNetworkingConfigValue cppISteamNetworkingUtils_SteamNetworkingUtils003_GetFirstConfigValue(void *);
+extern void cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ToString(void *, const SteamNetworkingIPAddr *, char *, size_t, bool);
+extern bool cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ParseString(void *, SteamNetworkingIPAddr *, const char *);
+extern void cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ToString(void *, const SteamNetworkingIdentity *, char *, size_t);
+extern bool cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ParseString(void *, SteamNetworkingIdentity *, const char *);

lsteamclient/cppISteamNetworking_SteamNetworking006.cpp

@@ -0,0 +1,126 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_147
+#include "struct_converters.h"
+#include "cppISteamNetworking_SteamNetworking006.h"
+bool cppISteamNetworking_SteamNetworking006_SendP2PPacket(void *linux_side, CSteamID steamIDRemote, const void * pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel)
+{
+    return ((ISteamNetworking*)linux_side)->SendP2PPacket((CSteamID)steamIDRemote, (const void *)pubData, (uint32)cubData, (EP2PSend)eP2PSendType, (int)nChannel);
+}
+
+bool cppISteamNetworking_SteamNetworking006_IsP2PPacketAvailable(void *linux_side, uint32 * pcubMsgSize, int nChannel)
+{
+    return ((ISteamNetworking*)linux_side)->IsP2PPacketAvailable((uint32 *)pcubMsgSize, (int)nChannel);
+}
+
+bool cppISteamNetworking_SteamNetworking006_ReadP2PPacket(void *linux_side, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize, CSteamID * psteamIDRemote, int nChannel)
+{
+    return ((ISteamNetworking*)linux_side)->ReadP2PPacket((void *)pubDest, (uint32)cubDest, (uint32 *)pcubMsgSize, (CSteamID *)psteamIDRemote, (int)nChannel);
+}
+
+bool cppISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser(void *linux_side, CSteamID steamIDRemote)
+{
+    return ((ISteamNetworking*)linux_side)->AcceptP2PSessionWithUser((CSteamID)steamIDRemote);
+}
+
+bool cppISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser(void *linux_side, CSteamID steamIDRemote)
+{
+    return ((ISteamNetworking*)linux_side)->CloseP2PSessionWithUser((CSteamID)steamIDRemote);
+}
+
+bool cppISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser(void *linux_side, CSteamID steamIDRemote, int nChannel)
+{
+    return ((ISteamNetworking*)linux_side)->CloseP2PChannelWithUser((CSteamID)steamIDRemote, (int)nChannel);
+}
+
+bool cppISteamNetworking_SteamNetworking006_GetP2PSessionState(void *linux_side, CSteamID steamIDRemote, P2PSessionState_t * pConnectionState)
+{
+    return ((ISteamNetworking*)linux_side)->GetP2PSessionState((CSteamID)steamIDRemote, (P2PSessionState_t *)pConnectionState);
+}
+
+bool cppISteamNetworking_SteamNetworking006_AllowP2PPacketRelay(void *linux_side, bool bAllow)
+{
+    return ((ISteamNetworking*)linux_side)->AllowP2PPacketRelay((bool)bAllow);
+}
+
+SNetListenSocket_t cppISteamNetworking_SteamNetworking006_CreateListenSocket(void *linux_side, int nVirtualP2PPort, SteamIPAddress_t nIP, uint16 nPort, bool bAllowUseOfPacketRelay)
+{
+    return ((ISteamNetworking*)linux_side)->CreateListenSocket((int)nVirtualP2PPort, (SteamIPAddress_t)nIP, (uint16)nPort, (bool)bAllowUseOfPacketRelay);
+}
+
+SNetSocket_t cppISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket(void *linux_side, CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay)
+{
+    return ((ISteamNetworking*)linux_side)->CreateP2PConnectionSocket((CSteamID)steamIDTarget, (int)nVirtualPort, (int)nTimeoutSec, (bool)bAllowUseOfPacketRelay);
+}
+
+SNetSocket_t cppISteamNetworking_SteamNetworking006_CreateConnectionSocket(void *linux_side, SteamIPAddress_t nIP, uint16 nPort, int nTimeoutSec)
+{
+    return ((ISteamNetworking*)linux_side)->CreateConnectionSocket((SteamIPAddress_t)nIP, (uint16)nPort, (int)nTimeoutSec);
+}
+
+bool cppISteamNetworking_SteamNetworking006_DestroySocket(void *linux_side, SNetSocket_t hSocket, bool bNotifyRemoteEnd)
+{
+    return ((ISteamNetworking*)linux_side)->DestroySocket((SNetSocket_t)hSocket, (bool)bNotifyRemoteEnd);
+}
+
+bool cppISteamNetworking_SteamNetworking006_DestroyListenSocket(void *linux_side, SNetListenSocket_t hSocket, bool bNotifyRemoteEnd)
+{
+    return ((ISteamNetworking*)linux_side)->DestroyListenSocket((SNetListenSocket_t)hSocket, (bool)bNotifyRemoteEnd);
+}
+
+bool cppISteamNetworking_SteamNetworking006_SendDataOnSocket(void *linux_side, SNetSocket_t hSocket, void * pubData, uint32 cubData, bool bReliable)
+{
+    return ((ISteamNetworking*)linux_side)->SendDataOnSocket((SNetSocket_t)hSocket, (void *)pubData, (uint32)cubData, (bool)bReliable);
+}
+
+bool cppISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket(void *linux_side, SNetSocket_t hSocket, uint32 * pcubMsgSize)
+{
+    return ((ISteamNetworking*)linux_side)->IsDataAvailableOnSocket((SNetSocket_t)hSocket, (uint32 *)pcubMsgSize);
+}
+
+bool cppISteamNetworking_SteamNetworking006_RetrieveDataFromSocket(void *linux_side, SNetSocket_t hSocket, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize)
+{
+    return ((ISteamNetworking*)linux_side)->RetrieveDataFromSocket((SNetSocket_t)hSocket, (void *)pubDest, (uint32)cubDest, (uint32 *)pcubMsgSize);
+}
+
+bool cppISteamNetworking_SteamNetworking006_IsDataAvailable(void *linux_side, SNetListenSocket_t hListenSocket, uint32 * pcubMsgSize, SNetSocket_t * phSocket)
+{
+    return ((ISteamNetworking*)linux_side)->IsDataAvailable((SNetListenSocket_t)hListenSocket, (uint32 *)pcubMsgSize, (SNetSocket_t *)phSocket);
+}
+
+bool cppISteamNetworking_SteamNetworking006_RetrieveData(void *linux_side, SNetListenSocket_t hListenSocket, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize, SNetSocket_t * phSocket)
+{
+    return ((ISteamNetworking*)linux_side)->RetrieveData((SNetListenSocket_t)hListenSocket, (void *)pubDest, (uint32)cubDest, (uint32 *)pcubMsgSize, (SNetSocket_t *)phSocket);
+}
+
+bool cppISteamNetworking_SteamNetworking006_GetSocketInfo(void *linux_side, SNetSocket_t hSocket, CSteamID * pSteamIDRemote, int * peSocketStatus, SteamIPAddress_t * punIPRemote, uint16 * punPortRemote)
+{
+    return ((ISteamNetworking*)linux_side)->GetSocketInfo((SNetSocket_t)hSocket, (CSteamID *)pSteamIDRemote, (int *)peSocketStatus, (SteamIPAddress_t *)punIPRemote, (uint16 *)punPortRemote);
+}
+
+bool cppISteamNetworking_SteamNetworking006_GetListenSocketInfo(void *linux_side, SNetListenSocket_t hListenSocket, SteamIPAddress_t * pnIP, uint16 * pnPort)
+{
+    return ((ISteamNetworking*)linux_side)->GetListenSocketInfo((SNetListenSocket_t)hListenSocket, (SteamIPAddress_t *)pnIP, (uint16 *)pnPort);
+}
+
+ESNetSocketConnectionType cppISteamNetworking_SteamNetworking006_GetSocketConnectionType(void *linux_side, SNetSocket_t hSocket)
+{
+    return ((ISteamNetworking*)linux_side)->GetSocketConnectionType((SNetSocket_t)hSocket);
+}
+
+int cppISteamNetworking_SteamNetworking006_GetMaxPacketSize(void *linux_side, SNetSocket_t hSocket)
+{
+    return ((ISteamNetworking*)linux_side)->GetMaxPacketSize((SNetSocket_t)hSocket);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamNetworking_SteamNetworking006.h

@@ -0,0 +1,22 @@
+extern bool cppISteamNetworking_SteamNetworking006_SendP2PPacket(void *, CSteamID, const void *, uint32, EP2PSend, int);
+extern bool cppISteamNetworking_SteamNetworking006_IsP2PPacketAvailable(void *, uint32 *, int);
+extern bool cppISteamNetworking_SteamNetworking006_ReadP2PPacket(void *, void *, uint32, uint32 *, CSteamID *, int);
+extern bool cppISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser(void *, CSteamID);
+extern bool cppISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser(void *, CSteamID);
+extern bool cppISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser(void *, CSteamID, int);
+extern bool cppISteamNetworking_SteamNetworking006_GetP2PSessionState(void *, CSteamID, P2PSessionState_t *);
+extern bool cppISteamNetworking_SteamNetworking006_AllowP2PPacketRelay(void *, bool);
+extern SNetListenSocket_t cppISteamNetworking_SteamNetworking006_CreateListenSocket(void *, int, SteamIPAddress_t, uint16, bool);
+extern SNetSocket_t cppISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket(void *, CSteamID, int, int, bool);
+extern SNetSocket_t cppISteamNetworking_SteamNetworking006_CreateConnectionSocket(void *, SteamIPAddress_t, uint16, int);
+extern bool cppISteamNetworking_SteamNetworking006_DestroySocket(void *, SNetSocket_t, bool);
+extern bool cppISteamNetworking_SteamNetworking006_DestroyListenSocket(void *, SNetListenSocket_t, bool);
+extern bool cppISteamNetworking_SteamNetworking006_SendDataOnSocket(void *, SNetSocket_t, void *, uint32, bool);
+extern bool cppISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket(void *, SNetSocket_t, uint32 *);
+extern bool cppISteamNetworking_SteamNetworking006_RetrieveDataFromSocket(void *, SNetSocket_t, void *, uint32, uint32 *);
+extern bool cppISteamNetworking_SteamNetworking006_IsDataAvailable(void *, SNetListenSocket_t, uint32 *, SNetSocket_t *);
+extern bool cppISteamNetworking_SteamNetworking006_RetrieveData(void *, SNetListenSocket_t, void *, uint32, uint32 *, SNetSocket_t *);
+extern bool cppISteamNetworking_SteamNetworking006_GetSocketInfo(void *, SNetSocket_t, CSteamID *, int *, SteamIPAddress_t *, uint16 *);
+extern bool cppISteamNetworking_SteamNetworking006_GetListenSocketInfo(void *, SNetListenSocket_t, SteamIPAddress_t *, uint16 *);
+extern ESNetSocketConnectionType cppISteamNetworking_SteamNetworking006_GetSocketConnectionType(void *, SNetSocket_t);
+extern int cppISteamNetworking_SteamNetworking006_GetMaxPacketSize(void *, SNetSocket_t);

lsteamclient/cppISteamParentalSettings_STEAMPARENTALSETTINGS_INTERFACE_VERSION001.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
-#include "steamworks_sdk_146/isteamparentalsettings.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/isteamparentalsettings.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamParentalSettings_STEAMPARENTALSETTINGS_INTERFACE_VERSION001.h"
 bool cppISteamParentalSettings_STEAMPARENTALSETTINGS_INTERFACE_VERSION001_BIsParentalLockEnabled(void *linux_side)

lsteamclient/cppISteamParties_SteamParties002.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamParties_SteamParties002.h"
 uint32 cppISteamParties_SteamParties002_GetNumActiveBeacons(void *linux_side)
@@ -21,12 +21,12 @@ PartyBeaconID_t cppISteamParties_SteamParties002_GetBeaconByIndex(void *linux_si
     return ((ISteamParties*)linux_side)->GetBeaconByIndex((uint32)unIndex);
 }
 
-bool cppISteamParties_SteamParties002_GetBeaconDetails(void *linux_side, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, winSteamPartyBeaconLocation_t_146 * pLocation, char * pchMetadata, int cchMetadata)
+bool cppISteamParties_SteamParties002_GetBeaconDetails(void *linux_side, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, winSteamPartyBeaconLocation_t_147 * pLocation, char * pchMetadata, int cchMetadata)
 {
     SteamPartyBeaconLocation_t lin_pLocation;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_146(pLocation, &lin_pLocation);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_147(pLocation, &lin_pLocation);
     bool retval = ((ISteamParties*)linux_side)->GetBeaconDetails((PartyBeaconID_t)ulBeaconID, (CSteamID *)pSteamIDBeaconOwner, &lin_pLocation, (char *)pchMetadata, (int)cchMetadata);
-    lin_to_win_struct_SteamPartyBeaconLocation_t_146(&lin_pLocation, pLocation);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_147(&lin_pLocation, pLocation);
     return retval;
 }
 
@@ -40,21 +40,21 @@ bool cppISteamParties_SteamParties002_GetNumAvailableBeaconLocations(void *linux
     return ((ISteamParties*)linux_side)->GetNumAvailableBeaconLocations((uint32 *)puNumLocations);
 }
 
-bool cppISteamParties_SteamParties002_GetAvailableBeaconLocations(void *linux_side, winSteamPartyBeaconLocation_t_146 * pLocationList, uint32 uMaxNumLocations)
+bool cppISteamParties_SteamParties002_GetAvailableBeaconLocations(void *linux_side, winSteamPartyBeaconLocation_t_147 * pLocationList, uint32 uMaxNumLocations)
 {
     SteamPartyBeaconLocation_t lin_pLocationList;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_146(pLocationList, &lin_pLocationList);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_147(pLocationList, &lin_pLocationList);
     bool retval = ((ISteamParties*)linux_side)->GetAvailableBeaconLocations(&lin_pLocationList, (uint32)uMaxNumLocations);
-    lin_to_win_struct_SteamPartyBeaconLocation_t_146(&lin_pLocationList, pLocationList);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_147(&lin_pLocationList, pLocationList);
     return retval;
 }
 
-SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *linux_side, uint32 unOpenSlots, winSteamPartyBeaconLocation_t_146 * pBeaconLocation, const char * pchConnectString, const char * pchMetadata)
+SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *linux_side, uint32 unOpenSlots, winSteamPartyBeaconLocation_t_147 * pBeaconLocation, const char * pchConnectString, const char * pchMetadata)
 {
     SteamPartyBeaconLocation_t lin_pBeaconLocation;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_146(pBeaconLocation, &lin_pBeaconLocation);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_147(pBeaconLocation, &lin_pBeaconLocation);
     SteamAPICall_t retval = ((ISteamParties*)linux_side)->CreateBeacon((uint32)unOpenSlots, &lin_pBeaconLocation, (const char *)pchConnectString, (const char *)pchMetadata);
-    lin_to_win_struct_SteamPartyBeaconLocation_t_146(&lin_pBeaconLocation, pBeaconLocation);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_147(&lin_pBeaconLocation, pBeaconLocation);
     return retval;
 }
 
@@ -78,12 +78,12 @@ bool cppISteamParties_SteamParties002_DestroyBeacon(void *linux_side, PartyBeaco
     return ((ISteamParties*)linux_side)->DestroyBeacon((PartyBeaconID_t)ulBeacon);
 }
 
-bool cppISteamParties_SteamParties002_GetBeaconLocationData(void *linux_side, winSteamPartyBeaconLocation_t_146 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
+bool cppISteamParties_SteamParties002_GetBeaconLocationData(void *linux_side, winSteamPartyBeaconLocation_t_147 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
 {
     SteamPartyBeaconLocation_t lin_BeaconLocation;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_146(&BeaconLocation, &lin_BeaconLocation);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_147(&BeaconLocation, &lin_BeaconLocation);
     bool retval = ((ISteamParties*)linux_side)->GetBeaconLocationData(lin_BeaconLocation, (ESteamPartyBeaconLocationData)eData, (char *)pchDataStringOut, (int)cchDataStringOut);
-    lin_to_win_struct_SteamPartyBeaconLocation_t_146(&lin_BeaconLocation, &BeaconLocation);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_147(&lin_BeaconLocation, &BeaconLocation);
     return retval;
 }
 

lsteamclient/cppISteamParties_SteamParties002.h

@@ -1,12 +1,12 @@
 extern uint32 cppISteamParties_SteamParties002_GetNumActiveBeacons(void *);
 extern PartyBeaconID_t cppISteamParties_SteamParties002_GetBeaconByIndex(void *, uint32);
-extern bool cppISteamParties_SteamParties002_GetBeaconDetails(void *, PartyBeaconID_t, CSteamID *, winSteamPartyBeaconLocation_t_146 *, char *, int);
+extern bool cppISteamParties_SteamParties002_GetBeaconDetails(void *, PartyBeaconID_t, CSteamID *, winSteamPartyBeaconLocation_t_147 *, char *, int);
 extern SteamAPICall_t cppISteamParties_SteamParties002_JoinParty(void *, PartyBeaconID_t);
 extern bool cppISteamParties_SteamParties002_GetNumAvailableBeaconLocations(void *, uint32 *);
-extern bool cppISteamParties_SteamParties002_GetAvailableBeaconLocations(void *, winSteamPartyBeaconLocation_t_146 *, uint32);
-extern SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *, uint32, winSteamPartyBeaconLocation_t_146 *, const char *, const char *);
+extern bool cppISteamParties_SteamParties002_GetAvailableBeaconLocations(void *, winSteamPartyBeaconLocation_t_147 *, uint32);
+extern SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *, uint32, winSteamPartyBeaconLocation_t_147 *, const char *, const char *);
 extern void cppISteamParties_SteamParties002_OnReservationCompleted(void *, PartyBeaconID_t, CSteamID);
 extern void cppISteamParties_SteamParties002_CancelReservation(void *, PartyBeaconID_t, CSteamID);
 extern SteamAPICall_t cppISteamParties_SteamParties002_ChangeNumOpenSlots(void *, PartyBeaconID_t, uint32);
 extern bool cppISteamParties_SteamParties002_DestroyBeacon(void *, PartyBeaconID_t);
-extern bool cppISteamParties_SteamParties002_GetBeaconLocationData(void *, winSteamPartyBeaconLocation_t_146, ESteamPartyBeaconLocationData, char *, int);
+extern bool cppISteamParties_SteamParties002_GetBeaconLocationData(void *, winSteamPartyBeaconLocation_t_147, ESteamPartyBeaconLocationData, char *, int);

lsteamclient/cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001.h"
 uint32 cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionCount(void *linux_side)
@@ -16,29 +16,34 @@ uint32 cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionCount(
     return ((ISteamRemotePlay*)linux_side)->GetSessionCount();
 }
 
-uint32 cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID(void *linux_side, int iSessionIndex)
+RemotePlaySessionID_t cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID(void *linux_side, int iSessionIndex)
 {
     return ((ISteamRemotePlay*)linux_side)->GetSessionID((int)iSessionIndex);
 }
 
-CSteamID cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID(void *linux_side, uint32 unSessionID)
+CSteamID cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID(void *linux_side, RemotePlaySessionID_t unSessionID)
 {
-    return ((ISteamRemotePlay*)linux_side)->GetSessionSteamID((uint32)unSessionID);
+    return ((ISteamRemotePlay*)linux_side)->GetSessionSteamID((RemotePlaySessionID_t)unSessionID);
 }
 
-const char * cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName(void *linux_side, uint32 unSessionID)
+const char * cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName(void *linux_side, RemotePlaySessionID_t unSessionID)
 {
-    return ((ISteamRemotePlay*)linux_side)->GetSessionClientName((uint32)unSessionID);
+    return ((ISteamRemotePlay*)linux_side)->GetSessionClientName((RemotePlaySessionID_t)unSessionID);
 }
 
-ESteamDeviceFormFactor cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor(void *linux_side, uint32 unSessionID)
+ESteamDeviceFormFactor cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor(void *linux_side, RemotePlaySessionID_t unSessionID)
 {
-    return ((ISteamRemotePlay*)linux_side)->GetSessionClientFormFactor((uint32)unSessionID);
+    return ((ISteamRemotePlay*)linux_side)->GetSessionClientFormFactor((RemotePlaySessionID_t)unSessionID);
 }
 
-bool cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution(void *linux_side, uint32 unSessionID, int * pnResolutionX, int * pnResolutionY)
+bool cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution(void *linux_side, RemotePlaySessionID_t unSessionID, int * pnResolutionX, int * pnResolutionY)
 {
-    return ((ISteamRemotePlay*)linux_side)->BGetSessionClientResolution((uint32)unSessionID, (int *)pnResolutionX, (int *)pnResolutionY);
+    return ((ISteamRemotePlay*)linux_side)->BGetSessionClientResolution((RemotePlaySessionID_t)unSessionID, (int *)pnResolutionX, (int *)pnResolutionY);
+}
+
+bool cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BSendRemotePlayTogetherInvite(void *linux_side, CSteamID steamIDFriend)
+{
+    return ((ISteamRemotePlay*)linux_side)->BSendRemotePlayTogetherInvite((CSteamID)steamIDFriend);
 }
 
 #ifdef __cplusplus

lsteamclient/cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001.h

@@ -1,6 +1,7 @@
 extern uint32 cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionCount(void *);
-extern uint32 cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID(void *, int);
-extern CSteamID cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID(void *, uint32);
-extern const char * cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName(void *, uint32);
-extern ESteamDeviceFormFactor cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor(void *, uint32);
-extern bool cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution(void *, uint32, int *, int *);
+extern RemotePlaySessionID_t cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID(void *, int);
+extern CSteamID cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID(void *, RemotePlaySessionID_t);
+extern const char * cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName(void *, RemotePlaySessionID_t);
+extern ESteamDeviceFormFactor cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor(void *, RemotePlaySessionID_t);
+extern bool cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution(void *, RemotePlaySessionID_t, int *, int *);
+extern bool cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BSendRemotePlayTogetherInvite(void *, CSteamID);

lsteamclient/cppISteamRemoteStorage_STEAMREMOTESTORAGE_INTERFACE_VERSION014.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamRemoteStorage_STEAMREMOTESTORAGE_INTERFACE_VERSION014.h"
 bool cppISteamRemoteStorage_STEAMREMOTESTORAGE_INTERFACE_VERSION014_FileWrite(void *linux_side, const char * pchFile, const void * pvData, int32 cubData)

lsteamclient/cppISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003.h"
 ScreenshotHandle cppISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003_WriteScreenshot(void *linux_side, void * pubRGB, uint32 cubRGB, int nWidth, int nHeight)

lsteamclient/cppISteamUGC_STEAMUGC_INTERFACE_VERSION014.cpp

@@ -0,0 +1,415 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_147
+#include "struct_converters.h"
+#include "cppISteamUGC_STEAMUGC_INTERFACE_VERSION014.h"
+UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUserUGCRequest(void *linux_side, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage)
+{
+    return ((ISteamUGC*)linux_side)->CreateQueryUserUGCRequest((AccountID_t)unAccountID, (EUserUGCList)eListType, (EUGCMatchingUGCType)eMatchingUGCType, (EUserUGCListSortOrder)eSortOrder, (AppId_t)nCreatorAppID, (AppId_t)nConsumerAppID, (uint32)unPage);
+}
+
+UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest(void *linux_side, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage)
+{
+    return ((ISteamUGC*)linux_side)->CreateQueryAllUGCRequest((EUGCQuery)eQueryType, (EUGCMatchingUGCType)eMatchingeMatchingUGCTypeFileType, (AppId_t)nCreatorAppID, (AppId_t)nConsumerAppID, (uint32)unPage);
+}
+
+UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest_2(void *linux_side, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor)
+{
+    return ((ISteamUGC*)linux_side)->CreateQueryAllUGCRequest((EUGCQuery)eQueryType, (EUGCMatchingUGCType)eMatchingeMatchingUGCTypeFileType, (AppId_t)nCreatorAppID, (AppId_t)nConsumerAppID, (const char *)pchCursor);
+}
+
+UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUGCDetailsRequest(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    return ((ISteamUGC*)linux_side)->CreateQueryUGCDetailsRequest((PublishedFileId_t *)pvecPublishedFileID, (uint32)unNumPublishedFileIDs);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SendQueryUGCRequest(void *linux_side, UGCQueryHandle_t handle)
+{
+    return ((ISteamUGC*)linux_side)->SendQueryUGCRequest((UGCQueryHandle_t)handle);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCResult(void *linux_side, UGCQueryHandle_t handle, uint32 index, winSteamUGCDetails_t_147 * pDetails)
+{
+    SteamUGCDetails_t lin_pDetails;
+    win_to_lin_struct_SteamUGCDetails_t_147(pDetails, &lin_pDetails);
+    bool retval = ((ISteamUGC*)linux_side)->GetQueryUGCResult((UGCQueryHandle_t)handle, (uint32)index, &lin_pDetails);
+    lin_to_win_struct_SteamUGCDetails_t_147(&lin_pDetails, pDetails);
+    return retval;
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCPreviewURL(void *linux_side, UGCQueryHandle_t handle, uint32 index, char * pchURL, uint32 cchURLSize)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCPreviewURL((UGCQueryHandle_t)handle, (uint32)index, (char *)pchURL, (uint32)cchURLSize);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCMetadata(void *linux_side, UGCQueryHandle_t handle, uint32 index, char * pchMetadata, uint32 cchMetadatasize)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCMetadata((UGCQueryHandle_t)handle, (uint32)index, (char *)pchMetadata, (uint32)cchMetadatasize);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCChildren(void *linux_side, UGCQueryHandle_t handle, uint32 index, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCChildren((UGCQueryHandle_t)handle, (uint32)index, (PublishedFileId_t *)pvecPublishedFileID, (uint32)cMaxEntries);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCStatistic(void *linux_side, UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 * pStatValue)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCStatistic((UGCQueryHandle_t)handle, (uint32)index, (EItemStatistic)eStatType, (uint64 *)pStatValue);
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumAdditionalPreviews(void *linux_side, UGCQueryHandle_t handle, uint32 index)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCNumAdditionalPreviews((UGCQueryHandle_t)handle, (uint32)index);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCAdditionalPreview(void *linux_side, UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, char * pchURLOrVideoID, uint32 cchURLSize, char * pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType * pPreviewType)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCAdditionalPreview((UGCQueryHandle_t)handle, (uint32)index, (uint32)previewIndex, (char *)pchURLOrVideoID, (uint32)cchURLSize, (char *)pchOriginalFileName, (uint32)cchOriginalFileNameSize, (EItemPreviewType *)pPreviewType);
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumKeyValueTags(void *linux_side, UGCQueryHandle_t handle, uint32 index)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCNumKeyValueTags((UGCQueryHandle_t)handle, (uint32)index);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag(void *linux_side, UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char * pchKey, uint32 cchKeySize, char * pchValue, uint32 cchValueSize)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCKeyValueTag((UGCQueryHandle_t)handle, (uint32)index, (uint32)keyValueTagIndex, (char *)pchKey, (uint32)cchKeySize, (char *)pchValue, (uint32)cchValueSize);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag_2(void *linux_side, UGCQueryHandle_t handle, uint32 index, const char * pchKey, char * pchValue, uint32 cchValueSize)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCKeyValueTag((UGCQueryHandle_t)handle, (uint32)index, (const char *)pchKey, (char *)pchValue, (uint32)cchValueSize);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_ReleaseQueryUGCRequest(void *linux_side, UGCQueryHandle_t handle)
+{
+    return ((ISteamUGC*)linux_side)->ReleaseQueryUGCRequest((UGCQueryHandle_t)handle);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTag(void *linux_side, UGCQueryHandle_t handle, const char * pTagName)
+{
+    return ((ISteamUGC*)linux_side)->AddRequiredTag((UGCQueryHandle_t)handle, (const char *)pTagName);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTagGroup(void *linux_side, UGCQueryHandle_t handle, const SteamParamStringArray_t * pTagGroups)
+{
+    return ((ISteamUGC*)linux_side)->AddRequiredTagGroup((UGCQueryHandle_t)handle, (const SteamParamStringArray_t *)pTagGroups);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddExcludedTag(void *linux_side, UGCQueryHandle_t handle, const char * pTagName)
+{
+    return ((ISteamUGC*)linux_side)->AddExcludedTag((UGCQueryHandle_t)handle, (const char *)pTagName);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnOnlyIDs(void *linux_side, UGCQueryHandle_t handle, bool bReturnOnlyIDs)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnOnlyIDs((UGCQueryHandle_t)handle, (bool)bReturnOnlyIDs);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnKeyValueTags(void *linux_side, UGCQueryHandle_t handle, bool bReturnKeyValueTags)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnKeyValueTags((UGCQueryHandle_t)handle, (bool)bReturnKeyValueTags);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnLongDescription(void *linux_side, UGCQueryHandle_t handle, bool bReturnLongDescription)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnLongDescription((UGCQueryHandle_t)handle, (bool)bReturnLongDescription);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnMetadata(void *linux_side, UGCQueryHandle_t handle, bool bReturnMetadata)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnMetadata((UGCQueryHandle_t)handle, (bool)bReturnMetadata);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnChildren(void *linux_side, UGCQueryHandle_t handle, bool bReturnChildren)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnChildren((UGCQueryHandle_t)handle, (bool)bReturnChildren);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnAdditionalPreviews(void *linux_side, UGCQueryHandle_t handle, bool bReturnAdditionalPreviews)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnAdditionalPreviews((UGCQueryHandle_t)handle, (bool)bReturnAdditionalPreviews);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnTotalOnly(void *linux_side, UGCQueryHandle_t handle, bool bReturnTotalOnly)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnTotalOnly((UGCQueryHandle_t)handle, (bool)bReturnTotalOnly);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnPlaytimeStats(void *linux_side, UGCQueryHandle_t handle, uint32 unDays)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnPlaytimeStats((UGCQueryHandle_t)handle, (uint32)unDays);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetLanguage(void *linux_side, UGCQueryHandle_t handle, const char * pchLanguage)
+{
+    return ((ISteamUGC*)linux_side)->SetLanguage((UGCQueryHandle_t)handle, (const char *)pchLanguage);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowCachedResponse(void *linux_side, UGCQueryHandle_t handle, uint32 unMaxAgeSeconds)
+{
+    return ((ISteamUGC*)linux_side)->SetAllowCachedResponse((UGCQueryHandle_t)handle, (uint32)unMaxAgeSeconds);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetCloudFileNameFilter(void *linux_side, UGCQueryHandle_t handle, const char * pMatchCloudFileName)
+{
+    return ((ISteamUGC*)linux_side)->SetCloudFileNameFilter((UGCQueryHandle_t)handle, (const char *)pMatchCloudFileName);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetMatchAnyTag(void *linux_side, UGCQueryHandle_t handle, bool bMatchAnyTag)
+{
+    return ((ISteamUGC*)linux_side)->SetMatchAnyTag((UGCQueryHandle_t)handle, (bool)bMatchAnyTag);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetSearchText(void *linux_side, UGCQueryHandle_t handle, const char * pSearchText)
+{
+    return ((ISteamUGC*)linux_side)->SetSearchText((UGCQueryHandle_t)handle, (const char *)pSearchText);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetRankedByTrendDays(void *linux_side, UGCQueryHandle_t handle, uint32 unDays)
+{
+    return ((ISteamUGC*)linux_side)->SetRankedByTrendDays((UGCQueryHandle_t)handle, (uint32)unDays);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredKeyValueTag(void *linux_side, UGCQueryHandle_t handle, const char * pKey, const char * pValue)
+{
+    return ((ISteamUGC*)linux_side)->AddRequiredKeyValueTag((UGCQueryHandle_t)handle, (const char *)pKey, (const char *)pValue);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RequestUGCDetails(void *linux_side, PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds)
+{
+    return ((ISteamUGC*)linux_side)->RequestUGCDetails((PublishedFileId_t)nPublishedFileID, (uint32)unMaxAgeSeconds);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateItem(void *linux_side, AppId_t nConsumerAppId, EWorkshopFileType eFileType)
+{
+    return ((ISteamUGC*)linux_side)->CreateItem((AppId_t)nConsumerAppId, (EWorkshopFileType)eFileType);
+}
+
+UGCUpdateHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartItemUpdate(void *linux_side, AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->StartItemUpdate((AppId_t)nConsumerAppId, (PublishedFileId_t)nPublishedFileID);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTitle(void *linux_side, UGCUpdateHandle_t handle, const char * pchTitle)
+{
+    return ((ISteamUGC*)linux_side)->SetItemTitle((UGCUpdateHandle_t)handle, (const char *)pchTitle);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemDescription(void *linux_side, UGCUpdateHandle_t handle, const char * pchDescription)
+{
+    return ((ISteamUGC*)linux_side)->SetItemDescription((UGCUpdateHandle_t)handle, (const char *)pchDescription);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemUpdateLanguage(void *linux_side, UGCUpdateHandle_t handle, const char * pchLanguage)
+{
+    return ((ISteamUGC*)linux_side)->SetItemUpdateLanguage((UGCUpdateHandle_t)handle, (const char *)pchLanguage);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemMetadata(void *linux_side, UGCUpdateHandle_t handle, const char * pchMetaData)
+{
+    return ((ISteamUGC*)linux_side)->SetItemMetadata((UGCUpdateHandle_t)handle, (const char *)pchMetaData);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemVisibility(void *linux_side, UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility)
+{
+    return ((ISteamUGC*)linux_side)->SetItemVisibility((UGCUpdateHandle_t)handle, (ERemoteStoragePublishedFileVisibility)eVisibility);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTags(void *linux_side, UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t * pTags)
+{
+    return ((ISteamUGC*)linux_side)->SetItemTags((UGCUpdateHandle_t)updateHandle, (const SteamParamStringArray_t *)pTags);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemContent(void *linux_side, UGCUpdateHandle_t handle, const char * pszContentFolder)
+{
+    return ((ISteamUGC*)linux_side)->SetItemContent((UGCUpdateHandle_t)handle, (const char *)pszContentFolder);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemPreview(void *linux_side, UGCUpdateHandle_t handle, const char * pszPreviewFile)
+{
+    return ((ISteamUGC*)linux_side)->SetItemPreview((UGCUpdateHandle_t)handle, (const char *)pszPreviewFile);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowLegacyUpload(void *linux_side, UGCUpdateHandle_t handle, bool bAllowLegacyUpload)
+{
+    return ((ISteamUGC*)linux_side)->SetAllowLegacyUpload((UGCUpdateHandle_t)handle, (bool)bAllowLegacyUpload);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAllItemKeyValueTags(void *linux_side, UGCUpdateHandle_t handle)
+{
+    return ((ISteamUGC*)linux_side)->RemoveAllItemKeyValueTags((UGCUpdateHandle_t)handle);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemKeyValueTags(void *linux_side, UGCUpdateHandle_t handle, const char * pchKey)
+{
+    return ((ISteamUGC*)linux_side)->RemoveItemKeyValueTags((UGCUpdateHandle_t)handle, (const char *)pchKey);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemKeyValueTag(void *linux_side, UGCUpdateHandle_t handle, const char * pchKey, const char * pchValue)
+{
+    return ((ISteamUGC*)linux_side)->AddItemKeyValueTag((UGCUpdateHandle_t)handle, (const char *)pchKey, (const char *)pchValue);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewFile(void *linux_side, UGCUpdateHandle_t handle, const char * pszPreviewFile, EItemPreviewType type)
+{
+    return ((ISteamUGC*)linux_side)->AddItemPreviewFile((UGCUpdateHandle_t)handle, (const char *)pszPreviewFile, (EItemPreviewType)type);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewVideo(void *linux_side, UGCUpdateHandle_t handle, const char * pszVideoID)
+{
+    return ((ISteamUGC*)linux_side)->AddItemPreviewVideo((UGCUpdateHandle_t)handle, (const char *)pszVideoID);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewFile(void *linux_side, UGCUpdateHandle_t handle, uint32 index, const char * pszPreviewFile)
+{
+    return ((ISteamUGC*)linux_side)->UpdateItemPreviewFile((UGCUpdateHandle_t)handle, (uint32)index, (const char *)pszPreviewFile);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewVideo(void *linux_side, UGCUpdateHandle_t handle, uint32 index, const char * pszVideoID)
+{
+    return ((ISteamUGC*)linux_side)->UpdateItemPreviewVideo((UGCUpdateHandle_t)handle, (uint32)index, (const char *)pszVideoID);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemPreview(void *linux_side, UGCUpdateHandle_t handle, uint32 index)
+{
+    return ((ISteamUGC*)linux_side)->RemoveItemPreview((UGCUpdateHandle_t)handle, (uint32)index);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubmitItemUpdate(void *linux_side, UGCUpdateHandle_t handle, const char * pchChangeNote)
+{
+    return ((ISteamUGC*)linux_side)->SubmitItemUpdate((UGCUpdateHandle_t)handle, (const char *)pchChangeNote);
+}
+
+EItemUpdateStatus cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemUpdateProgress(void *linux_side, UGCUpdateHandle_t handle, uint64 * punBytesProcessed, uint64 * punBytesTotal)
+{
+    return ((ISteamUGC*)linux_side)->GetItemUpdateProgress((UGCUpdateHandle_t)handle, (uint64 *)punBytesProcessed, (uint64 *)punBytesTotal);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetUserItemVote(void *linux_side, PublishedFileId_t nPublishedFileID, bool bVoteUp)
+{
+    return ((ISteamUGC*)linux_side)->SetUserItemVote((PublishedFileId_t)nPublishedFileID, (bool)bVoteUp);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetUserItemVote(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->GetUserItemVote((PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemToFavorites(void *linux_side, AppId_t nAppId, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->AddItemToFavorites((AppId_t)nAppId, (PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemFromFavorites(void *linux_side, AppId_t nAppId, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->RemoveItemFromFavorites((AppId_t)nAppId, (PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubscribeItem(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->SubscribeItem((PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UnsubscribeItem(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->UnsubscribeItem((PublishedFileId_t)nPublishedFileID);
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetNumSubscribedItems(void *linux_side)
+{
+    return ((ISteamUGC*)linux_side)->GetNumSubscribedItems();
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetSubscribedItems(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries)
+{
+    return ((ISteamUGC*)linux_side)->GetSubscribedItems((PublishedFileId_t *)pvecPublishedFileID, (uint32)cMaxEntries);
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemState(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->GetItemState((PublishedFileId_t)nPublishedFileID);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemInstallInfo(void *linux_side, PublishedFileId_t nPublishedFileID, uint64 * punSizeOnDisk, char * pchFolder, uint32 cchFolderSize, uint32 * punTimeStamp)
+{
+    return ((ISteamUGC*)linux_side)->GetItemInstallInfo((PublishedFileId_t)nPublishedFileID, (uint64 *)punSizeOnDisk, (char *)pchFolder, (uint32)cchFolderSize, (uint32 *)punTimeStamp);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemDownloadInfo(void *linux_side, PublishedFileId_t nPublishedFileID, uint64 * punBytesDownloaded, uint64 * punBytesTotal)
+{
+    return ((ISteamUGC*)linux_side)->GetItemDownloadInfo((PublishedFileId_t)nPublishedFileID, (uint64 *)punBytesDownloaded, (uint64 *)punBytesTotal);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_DownloadItem(void *linux_side, PublishedFileId_t nPublishedFileID, bool bHighPriority)
+{
+    return ((ISteamUGC*)linux_side)->DownloadItem((PublishedFileId_t)nPublishedFileID, (bool)bHighPriority);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_BInitWorkshopForGameServer(void *linux_side, DepotId_t unWorkshopDepotID, const char * pszFolder)
+{
+    return ((ISteamUGC*)linux_side)->BInitWorkshopForGameServer((DepotId_t)unWorkshopDepotID, (const char *)pszFolder);
+}
+
+void cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SuspendDownloads(void *linux_side, bool bSuspend)
+{
+    ((ISteamUGC*)linux_side)->SuspendDownloads((bool)bSuspend);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartPlaytimeTracking(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    return ((ISteamUGC*)linux_side)->StartPlaytimeTracking((PublishedFileId_t *)pvecPublishedFileID, (uint32)unNumPublishedFileIDs);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTracking(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    return ((ISteamUGC*)linux_side)->StopPlaytimeTracking((PublishedFileId_t *)pvecPublishedFileID, (uint32)unNumPublishedFileIDs);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTrackingForAllItems(void *linux_side)
+{
+    return ((ISteamUGC*)linux_side)->StopPlaytimeTrackingForAllItems();
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddDependency(void *linux_side, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->AddDependency((PublishedFileId_t)nParentPublishedFileID, (PublishedFileId_t)nChildPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveDependency(void *linux_side, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->RemoveDependency((PublishedFileId_t)nParentPublishedFileID, (PublishedFileId_t)nChildPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddAppDependency(void *linux_side, PublishedFileId_t nPublishedFileID, AppId_t nAppID)
+{
+    return ((ISteamUGC*)linux_side)->AddAppDependency((PublishedFileId_t)nPublishedFileID, (AppId_t)nAppID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAppDependency(void *linux_side, PublishedFileId_t nPublishedFileID, AppId_t nAppID)
+{
+    return ((ISteamUGC*)linux_side)->RemoveAppDependency((PublishedFileId_t)nPublishedFileID, (AppId_t)nAppID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetAppDependencies(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->GetAppDependencies((PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_DeleteItem(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->DeleteItem((PublishedFileId_t)nPublishedFileID);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamUGC_STEAMUGC_INTERFACE_VERSION014.h

@@ -0,0 +1,79 @@
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUserUGCRequest(void *, AccountID_t, EUserUGCList, EUGCMatchingUGCType, EUserUGCListSortOrder, AppId_t, AppId_t, uint32);
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest(void *, EUGCQuery, EUGCMatchingUGCType, AppId_t, AppId_t, uint32);
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest_2(void *, EUGCQuery, EUGCMatchingUGCType, AppId_t, AppId_t, const char *);
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUGCDetailsRequest(void *, PublishedFileId_t *, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SendQueryUGCRequest(void *, UGCQueryHandle_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCResult(void *, UGCQueryHandle_t, uint32, winSteamUGCDetails_t_147 *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCPreviewURL(void *, UGCQueryHandle_t, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCMetadata(void *, UGCQueryHandle_t, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCChildren(void *, UGCQueryHandle_t, uint32, PublishedFileId_t *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCStatistic(void *, UGCQueryHandle_t, uint32, EItemStatistic, uint64 *);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumAdditionalPreviews(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCAdditionalPreview(void *, UGCQueryHandle_t, uint32, uint32, char *, uint32, char *, uint32, EItemPreviewType *);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumKeyValueTags(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag(void *, UGCQueryHandle_t, uint32, uint32, char *, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag_2(void *, UGCQueryHandle_t, uint32, const char *, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_ReleaseQueryUGCRequest(void *, UGCQueryHandle_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTag(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTagGroup(void *, UGCQueryHandle_t, const SteamParamStringArray_t *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddExcludedTag(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnOnlyIDs(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnKeyValueTags(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnLongDescription(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnMetadata(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnChildren(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnAdditionalPreviews(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnTotalOnly(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnPlaytimeStats(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetLanguage(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowCachedResponse(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetCloudFileNameFilter(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetMatchAnyTag(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetSearchText(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetRankedByTrendDays(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredKeyValueTag(void *, UGCQueryHandle_t, const char *, const char *);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RequestUGCDetails(void *, PublishedFileId_t, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateItem(void *, AppId_t, EWorkshopFileType);
+extern UGCUpdateHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartItemUpdate(void *, AppId_t, PublishedFileId_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTitle(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemDescription(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemUpdateLanguage(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemMetadata(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemVisibility(void *, UGCUpdateHandle_t, ERemoteStoragePublishedFileVisibility);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTags(void *, UGCUpdateHandle_t, const SteamParamStringArray_t *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemContent(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemPreview(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowLegacyUpload(void *, UGCUpdateHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAllItemKeyValueTags(void *, UGCUpdateHandle_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemKeyValueTags(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemKeyValueTag(void *, UGCUpdateHandle_t, const char *, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewFile(void *, UGCUpdateHandle_t, const char *, EItemPreviewType);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewVideo(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewFile(void *, UGCUpdateHandle_t, uint32, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewVideo(void *, UGCUpdateHandle_t, uint32, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemPreview(void *, UGCUpdateHandle_t, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubmitItemUpdate(void *, UGCUpdateHandle_t, const char *);
+extern EItemUpdateStatus cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemUpdateProgress(void *, UGCUpdateHandle_t, uint64 *, uint64 *);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetUserItemVote(void *, PublishedFileId_t, bool);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetUserItemVote(void *, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemToFavorites(void *, AppId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemFromFavorites(void *, AppId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubscribeItem(void *, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UnsubscribeItem(void *, PublishedFileId_t);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetNumSubscribedItems(void *);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetSubscribedItems(void *, PublishedFileId_t *, uint32);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemState(void *, PublishedFileId_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemInstallInfo(void *, PublishedFileId_t, uint64 *, char *, uint32, uint32 *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemDownloadInfo(void *, PublishedFileId_t, uint64 *, uint64 *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_DownloadItem(void *, PublishedFileId_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_BInitWorkshopForGameServer(void *, DepotId_t, const char *);
+extern void cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SuspendDownloads(void *, bool);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartPlaytimeTracking(void *, PublishedFileId_t *, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTracking(void *, PublishedFileId_t *, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTrackingForAllItems(void *);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddDependency(void *, PublishedFileId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveDependency(void *, PublishedFileId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddAppDependency(void *, PublishedFileId_t, AppId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAppDependency(void *, PublishedFileId_t, AppId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetAppDependencies(void *, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_DeleteItem(void *, PublishedFileId_t);

lsteamclient/cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011.h"
 bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_RequestCurrentStats(void *linux_side)
@@ -161,12 +161,12 @@ SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_DownloadLe
     return ((ISteamUserStats*)linux_side)->DownloadLeaderboardEntriesForUsers((SteamLeaderboard_t)hSteamLeaderboard, (CSteamID *)prgUsers, (int)cUsers);
 }
 
-bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry(void *linux_side, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_146 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
+bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry(void *linux_side, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_147 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
 {
     LeaderboardEntry_t lin_pLeaderboardEntry;
-    win_to_lin_struct_LeaderboardEntry_t_146(pLeaderboardEntry, &lin_pLeaderboardEntry);
+    win_to_lin_struct_LeaderboardEntry_t_147(pLeaderboardEntry, &lin_pLeaderboardEntry);
     bool retval = ((ISteamUserStats*)linux_side)->GetDownloadedLeaderboardEntry((SteamLeaderboardEntries_t)hSteamLeaderboardEntries, (int)index, &lin_pLeaderboardEntry, (int32 *)pDetails, (int)cDetailsMax);
-    lin_to_win_struct_LeaderboardEntry_t_146(&lin_pLeaderboardEntry, pLeaderboardEntry);
+    lin_to_win_struct_LeaderboardEntry_t_147(&lin_pLeaderboardEntry, pLeaderboardEntry);
     return retval;
 }
 

lsteamclient/cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011.h

@@ -28,7 +28,7 @@ extern ELeaderboardSortMethod cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSIO
 extern ELeaderboardDisplayType cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetLeaderboardDisplayType(void *, SteamLeaderboard_t);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_DownloadLeaderboardEntries(void *, SteamLeaderboard_t, ELeaderboardDataRequest, int, int);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_DownloadLeaderboardEntriesForUsers(void *, SteamLeaderboard_t, CSteamID *, int);
-extern bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry(void *, SteamLeaderboardEntries_t, int, winLeaderboardEntry_t_146 *, int32 *, int);
+extern bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry(void *, SteamLeaderboardEntries_t, int, winLeaderboardEntry_t_147 *, int32 *, int);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_UploadLeaderboardScore(void *, SteamLeaderboard_t, ELeaderboardUploadScoreMethod, int32, const int32 *, int);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_AttachLeaderboardUGC(void *, SteamLeaderboard_t, UGCHandle_t);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetNumberOfCurrentPlayers(void *);

lsteamclient/cppISteamUser_SteamUser020.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamUser_SteamUser020.h"
 HSteamUser cppISteamUser_SteamUser020_GetHSteamUser(void *linux_side)

lsteamclient/cppISteamUtils_SteamUtils009.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamUtils_SteamUtils009.h"
 uint32 cppISteamUtils_SteamUtils009_GetSecondsSinceAppActive(void *linux_side)
@@ -176,6 +176,11 @@ int cppISteamUtils_SteamUtils009_FilterText(void *linux_side, char * pchOutFilte
     return ((ISteamUtils*)linux_side)->FilterText((char *)pchOutFilteredText, (uint32)nByteSizeOutFilteredText, (const char *)pchInputMessage, (bool)bLegalOnly);
 }
 
+ESteamIPv6ConnectivityState cppISteamUtils_SteamUtils009_GetIPv6ConnectivityState(void *linux_side, ESteamIPv6ConnectivityProtocol eProtocol)
+{
+    return ((ISteamUtils*)linux_side)->GetIPv6ConnectivityState((ESteamIPv6ConnectivityProtocol)eProtocol);
+}
+
 #ifdef __cplusplus
 }
 #endif

lsteamclient/cppISteamUtils_SteamUtils009.h

@@ -31,3 +31,4 @@ extern void cppISteamUtils_SteamUtils009_SetVRHeadsetStreamingEnabled(void *, bo
 extern bool cppISteamUtils_SteamUtils009_IsSteamChinaLauncher(void *);
 extern bool cppISteamUtils_SteamUtils009_InitFilterText(void *);
 extern int cppISteamUtils_SteamUtils009_FilterText(void *, char *, uint32, const char *, bool);
+extern ESteamIPv6ConnectivityState cppISteamUtils_SteamUtils009_GetIPv6ConnectivityState(void *, ESteamIPv6ConnectivityProtocol);

lsteamclient/cppISteamVideo_STEAMVIDEO_INTERFACE_V002.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_146/steam_api.h"
-#include "steamworks_sdk_146/steamnetworkingtypes.h"
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_146
+#define SDKVER_147
 #include "struct_converters.h"
 #include "cppISteamVideo_STEAMVIDEO_INTERFACE_V002.h"
 void cppISteamVideo_STEAMVIDEO_INTERFACE_V002_GetVideoURL(void *linux_side, AppId_t unVideoAppID)

lsteamclient/gen_wrapper.py

@@ -5,7 +5,7 @@
 
 from __future__ import print_function
 
-CLANG_PATH='/usr/lib/clang/8.0.1'
+CLANG_PATH='/usr/lib/clang/9.0.0'
 
 import pprint
 import sys
@@ -181,7 +181,15 @@ manually_handled_methods = {
         "cppISteamNetworkingSockets_SteamNetworkingSockets003": [
             "ReceiveMessagesOnConnection",
             "ReceiveMessagesOnListenSocket"
-        ]
+        ],
+        "cppISteamNetworkingSockets_SteamNetworkingSockets006": [
+            "ReceiveMessagesOnConnection",
+            "ReceiveMessagesOnListenSocket",
+            "SendMessages"
+        ],
+        "cppISteamNetworkingUtils_SteamNetworkingUtils003": [
+            "AllocateMessage",
+        ],
 }
 
 # manual converters for simple types (function pointers)

lsteamclient/steam_defs.h

@@ -94,9 +94,15 @@ typedef uint32_t EUserUGCList,
         EGameSearchErrorCode_t,
         EPlayerResult_t,
         ESteamNetworkingAvailability,
-        ESteamDeviceFormFactor
+        ESteamDeviceFormFactor,
+        ESteamIPv6ConnectivityState,
+        ESteamIPv6ConnectivityProtocol
 ;
 
+/* XXX NO */
+typedef struct ISteamNetworkingCustomSignalingRecvContext ISteamNetworkingCustomSignalingRecvContext;
+typedef struct ISteamNetworkingConnectionCustomSignaling ISteamNetworkingConnectionCustomSignaling;
+
 /* structs below are PODs with identical size & layout across platforms */
 
 typedef struct CSteamID { unsigned char a[8]; } CSteamID;
@@ -107,6 +113,9 @@ typedef struct ControllerDigitalActionData_t { unsigned char a[2]; } ControllerD
 typedef struct ControllerMotionData_t { unsigned char a[40]; } ControllerMotionData_t;
 typedef struct SteamNetworkPingLocation_t { uint8 m_data[ 512 ]; } SteamNetworkPingLocation_t;
 
+/* XXX GET SIZE */
+typedef struct SteamIPAddress_t { uint8 m_data[12]; } SteamIPAddress_t;
+
 #pragma pack( push, 1 )
 
 typedef struct InputAnalogActionData_t
@@ -209,6 +218,9 @@ typedef struct SteamDatagramHostedAddress SteamDatagramHostedAddress;
 typedef struct SteamNetAuthenticationStatus_t SteamNetAuthenticationStatus_t;
 typedef struct SteamDatagramGameCoordinatorServerLogin SteamDatagramGameCoordinatorServerLogin;
 typedef struct SteamRelayNetworkStatus_t SteamRelayNetworkStatus_t;
+typedef struct SteamIPAddress_t SteamIPAddress_t;
+typedef struct SteamNetworkingConfigValue_t SteamNetworkingConfigValue_t;
+typedef struct SteamNetworkingMessage_t SteamNetworkingMessage_t;
 
 typedef uint32 (*SteamAPI_CheckCallbackRegistered_t)(int cb);
 typedef void *SteamAPIWarningMessageHook_t; //already cdecl, no need for conversion(?)
@@ -270,6 +282,7 @@ typedef uint32 HSteamNetConnection;
 typedef int64 SteamNetworkingMicroseconds;
 typedef uint32 HSteamListenSocket;
 typedef uint32 SteamNetworkingPOPID;
+typedef uint32 RemotePlaySessionID_t;
 
 #pragma pack( push, 4 )
 typedef struct CallbackMsg_t

lsteamclient/steamclient_manual_144.cpp

@@ -34,10 +34,10 @@ struct msg_wrapper {
     SLIST_ENTRY(msg_wrapper) entry;
 };
 
-SLIST_HEAD(free_msgs_head, msg_wrapper) free_msgs = SLIST_HEAD_INITIALIZER(free_msgs);
-CRITICAL_SECTION free_msgs_lock = { NULL, -1, 0, 0, 0, 0 };
+static SLIST_HEAD(free_msgs_head, msg_wrapper) free_msgs = SLIST_HEAD_INITIALIZER(free_msgs);
+static CRITICAL_SECTION free_msgs_lock = { NULL, -1, 0, 0, 0, 0 };
 
-void __attribute__((ms_abi)) win_FreeData(struct winSteamNetworkingMessage_t_144 *win_msg)
+static void __attribute__((ms_abi)) win_FreeData(struct winSteamNetworkingMessage_t_144 *win_msg)
 {
     struct msg_wrapper *msg = CONTAINING_RECORD(win_msg, struct msg_wrapper, win_msg);
     TRACE("%p\n", msg);
@@ -48,7 +48,7 @@ void __attribute__((ms_abi)) win_FreeData(struct winSteamNetworkingMessage_t_144
     }
 }
 
-void __attribute__((ms_abi)) win_Release(struct winSteamNetworkingMessage_t_144 *win_msg)
+static void __attribute__((ms_abi)) win_Release(struct winSteamNetworkingMessage_t_144 *win_msg)
 {
     struct msg_wrapper *msg = CONTAINING_RECORD(win_msg, struct msg_wrapper, win_msg);
     TRACE("%p\n", msg);
@@ -60,7 +60,7 @@ void __attribute__((ms_abi)) win_Release(struct winSteamNetworkingMessage_t_144
     LeaveCriticalSection(&free_msgs_lock);
 }
 
-void lin_FreeData(struct SteamNetworkingMessage_t *lin_msg)
+static void lin_FreeData(struct SteamNetworkingMessage_t *lin_msg)
 {
     struct msg_wrapper *msg = (struct msg_wrapper *)lin_msg->m_pData; /* ! see assignment, below */
     TRACE("%p\n", msg);

lsteamclient/steamclient_manual_147.cpp

@@ -0,0 +1,212 @@
+extern "C" {
+#include <stdarg.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
+}
+
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_147/steam_api.h"
+#include "steamworks_sdk_147/isteamnetworkingsockets.h"
+#include "steamworks_sdk_147/isteamnetworkingutils.h"
+#include "steamworks_sdk_147/steamnetworkingtypes.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+
+extern "C" {
+#define SDKVER_147
+#include "struct_converters.h"
+
+#include "queue.h"
+
+/***** manual struct converter for SteamNetworkingMessage_t *****/
+
+struct msg_wrapper {
+    struct winSteamNetworkingMessage_t_147 win_msg;
+    struct SteamNetworkingMessage_t *lin_msg;
+
+    void (*orig_FreeData)(SteamNetworkingMessage_t *);
+
+    SLIST_ENTRY(msg_wrapper) entry;
+};
+
+static SLIST_HEAD(free_msgs_head, msg_wrapper) free_msgs = SLIST_HEAD_INITIALIZER(free_msgs);
+static CRITICAL_SECTION free_msgs_lock = { NULL, -1, 0, 0, 0, 0 };
+
+static void __attribute__((ms_abi)) win_FreeData(struct winSteamNetworkingMessage_t_147 *win_msg)
+{
+    struct msg_wrapper *msg = CONTAINING_RECORD(win_msg, struct msg_wrapper, win_msg);
+    TRACE("%p\n", msg);
+    if(msg->orig_FreeData)
+    {
+        msg->lin_msg->m_pData = msg->win_msg.m_pData;
+        msg->orig_FreeData(msg->lin_msg);
+    }
+}
+
+static void __attribute__((ms_abi)) win_Release(struct winSteamNetworkingMessage_t_147 *win_msg)
+{
+    struct msg_wrapper *msg = CONTAINING_RECORD(win_msg, struct msg_wrapper, win_msg);
+    TRACE("%p\n", msg);
+    msg->lin_msg->m_pfnRelease(msg->lin_msg);
+    msg->lin_msg = NULL;
+    msg->orig_FreeData = NULL;
+    EnterCriticalSection(&free_msgs_lock);
+    SLIST_INSERT_HEAD(&free_msgs, msg, entry);
+    LeaveCriticalSection(&free_msgs_lock);
+}
+
+static void lin_FreeData(struct SteamNetworkingMessage_t *lin_msg)
+{
+    struct msg_wrapper *msg = (struct msg_wrapper *)lin_msg->m_pData; /* ! see assignment, below */
+    TRACE("%p\n", msg);
+    if(msg->win_msg.m_pfnFreeData)
+        ((void (__attribute__((ms_abi))*)(struct winSteamNetworkingMessage_t_147 *))msg->win_msg.m_pfnFreeData)(&msg->win_msg);
+}
+
+static struct msg_wrapper *clone_msg(struct SteamNetworkingMessage_t *lin_msg)
+{
+    struct msg_wrapper *msg;
+
+    EnterCriticalSection(&free_msgs_lock);
+    
+    msg = SLIST_FIRST(&free_msgs);
+
+    if(!msg){
+        int n;
+        /* allocs can be pricey, so alloc in blocks */
+#define MSGS_PER_BLOCK 16
+        struct msg_wrapper *msgs = (struct msg_wrapper *)HeapAlloc(GetProcessHeap(), 0, sizeof(struct msg_wrapper) * MSGS_PER_BLOCK);
+        for(n = 1; n < MSGS_PER_BLOCK; ++n)
+            SLIST_INSERT_HEAD(&free_msgs, &msgs[n], entry);
+        msg = &msgs[0];
+    }else
+        SLIST_REMOVE_HEAD(&free_msgs, entry);
+
+    LeaveCriticalSection(&free_msgs_lock);
+
+    msg->lin_msg = lin_msg;
+
+    msg->win_msg.m_pData = msg->lin_msg->m_pData;
+    msg->win_msg.m_cbSize = msg->lin_msg->m_cbSize;
+    msg->win_msg.m_conn = msg->lin_msg->m_conn;
+    msg->win_msg.m_identityPeer = msg->lin_msg->m_identityPeer;
+    msg->win_msg.m_nConnUserData = msg->lin_msg->m_nConnUserData;
+    msg->win_msg.m_usecTimeReceived= msg->lin_msg->m_usecTimeReceived;
+    msg->win_msg.m_nMessageNumber = msg->lin_msg->m_nMessageNumber;
+    msg->win_msg.m_pfnFreeData = (void*)win_FreeData;
+    msg->win_msg.m_pfnRelease = (void*)win_Release;
+    msg->win_msg.m_nChannel = msg->lin_msg->m_nChannel;
+    msg->win_msg.m_nFlags = msg->lin_msg->m_nFlags;
+    msg->win_msg.m_nUserData = msg->lin_msg->m_nUserData;
+
+    msg->orig_FreeData = msg->lin_msg->m_pfnFreeData;
+    msg->lin_msg->m_pfnFreeData = lin_FreeData;
+    /* ! store the wrapper here and restore the original pointer from win_msg before calling orig_FreeData */
+    msg->lin_msg->m_pData = msg;
+
+    return msg;
+}
+
+void lin_to_win_struct_SteamNetworkingMessage_t_147(int n_messages, struct SteamNetworkingMessage_t **l, struct winSteamNetworkingMessage_t_147 **w, int max_messages)
+{
+    int i;
+
+    if(n_messages > 0)
+        TRACE("%u %p %p\n", n_messages, l, w);
+
+    for(i = 0; i < n_messages; ++i)
+    {
+        struct msg_wrapper *msg;
+
+        msg = clone_msg(l[i]);
+
+        w[i] = &msg->win_msg;
+
+        TRACE("done with %u, returned wrapper %p\n", i, msg);
+    }
+
+    for(; i < max_messages; ++i)
+        w[i] = NULL;
+}
+
+int cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnConnection(
+        void *linux_side, HSteamNetConnection hConn,
+        winSteamNetworkingMessage_t_147 **ppOutMessages, int nMaxMessages)
+{
+    SteamNetworkingMessage_t *lin_ppOutMessages[nMaxMessages];
+    int retval = ((ISteamNetworkingSockets*)linux_side)->ReceiveMessagesOnConnection(hConn, lin_ppOutMessages, nMaxMessages);
+    lin_to_win_struct_SteamNetworkingMessage_t_147(retval, lin_ppOutMessages, ppOutMessages, nMaxMessages);
+    return retval;
+}
+
+int cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnListenSocket(
+        void *linux_side, HSteamListenSocket hSocket,
+        winSteamNetworkingMessage_t_147 **ppOutMessages, int nMaxMessages)
+{
+    SteamNetworkingMessage_t *lin_ppOutMessages[nMaxMessages];
+    int retval = ((ISteamNetworkingSockets*)linux_side)->ReceiveMessagesOnListenSocket(hSocket, lin_ppOutMessages, nMaxMessages);
+    lin_to_win_struct_SteamNetworkingMessage_t_147(retval, lin_ppOutMessages, ppOutMessages, nMaxMessages);
+    return retval;
+}
+
+void cppISteamNetworkingSockets_SteamNetworkingSockets006_SendMessages(
+        void *linux_side, int nMessages, winSteamNetworkingMessage_t_147 **pMessages,
+        int64 *pOutMessageNumberOrResult)
+{
+#define MAX_SEND_MESSAGES 64
+    /* use the stack to avoid heap allocation */
+    struct SteamNetworkingMessage_t *lin_msgs[MAX_SEND_MESSAGES];
+    int i;
+
+    if (nMessages > MAX_SEND_MESSAGES)
+    {
+        /* if we ever hit this, increase MAX_SEND_MESSAGES appropriately */
+        FIXME("Trying to send %u messages, which is more than %u! Will break up into pieces.\n", nMessages, MAX_SEND_MESSAGES);
+    }
+
+    while(nMessages)
+    {
+        for(i = 0; i < nMessages && i < MAX_SEND_MESSAGES; ++i)
+        {
+            struct msg_wrapper *msg = CONTAINING_RECORD(pMessages[i], struct msg_wrapper, win_msg);
+            lin_msgs[i] = msg->lin_msg;
+
+            lin_msgs[i]->m_pData = msg->win_msg.m_pData;
+            lin_msgs[i]->m_cbSize = msg->win_msg.m_cbSize;
+            lin_msgs[i]->m_conn = msg->win_msg.m_conn;
+            lin_msgs[i]->m_identityPeer = msg->win_msg.m_identityPeer;
+            lin_msgs[i]->m_nConnUserData = msg->win_msg.m_nConnUserData;
+            lin_msgs[i]->m_usecTimeReceived= msg->win_msg.m_usecTimeReceived;
+            lin_msgs[i]->m_nMessageNumber = msg->win_msg.m_nMessageNumber;
+            lin_msgs[i]->m_nChannel = msg->win_msg.m_nChannel;
+            lin_msgs[i]->m_nFlags = msg->win_msg.m_nFlags;
+            lin_msgs[i]->m_nUserData = msg->win_msg.m_nUserData;
+        }
+
+        ((ISteamNetworkingSockets*)linux_side)->SendMessages(i, lin_msgs, pOutMessageNumberOrResult);
+
+        nMessages -= i;
+        pMessages += i;
+        if(pOutMessageNumberOrResult)
+            pOutMessageNumberOrResult += i;
+    }
+}
+
+SteamNetworkingMessage_t *cppISteamNetworkingUtils_SteamNetworkingUtils003_AllocateMessage(
+        void *linux_side, int cbAllocateBuffer)
+{
+    struct msg_wrapper *msg;
+    SteamNetworkingMessage_t *retval = ((ISteamNetworkingUtils*)linux_side)->AllocateMessage(cbAllocateBuffer);
+
+    msg = clone_msg(retval);
+
+    return (SteamNetworkingMessage_t*)&msg->win_msg;
+}
+
+}

lsteamclient/steamclient_private.h

@@ -63,3 +63,4 @@ bool do_cb_wrap(HSteamPipe pipe, void *linux_side, bool (*cpp_func)(void *, Stea
 #define TRACE WINE_TRACE
 #define ERR WINE_ERR
 #define WARN WINE_WARN
+#define FIXME WINE_FIXME

lsteamclient/struct_converters.h

@@ -1,3 +1,90 @@
+#if defined(SDKVER_147) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winSteamPartyBeaconLocation_t_147 {
+    ESteamPartyBeaconLocationType m_eType;
+    uint64 m_ulLocationID;
+}  __attribute__ ((ms_struct));
+#pragma pack( pop )
+typedef struct winSteamPartyBeaconLocation_t_147 winSteamPartyBeaconLocation_t_147;
+struct SteamPartyBeaconLocation_t;
+extern void win_to_lin_struct_SteamPartyBeaconLocation_t_147(const struct winSteamPartyBeaconLocation_t_147 *w, struct SteamPartyBeaconLocation_t *l);
+extern void lin_to_win_struct_SteamPartyBeaconLocation_t_147(const struct SteamPartyBeaconLocation_t *l, struct winSteamPartyBeaconLocation_t_147 *w);
+#endif
+
+#if defined(SDKVER_147) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winLeaderboardEntry_t_147 {
+    CSteamID m_steamIDUser __attribute__((aligned(1)));
+    int32 m_nGlobalRank;
+    int32 m_nScore;
+    int32 m_cDetails;
+    UGCHandle_t m_hUGC;
+}  __attribute__ ((ms_struct));
+#pragma pack( pop )
+typedef struct winLeaderboardEntry_t_147 winLeaderboardEntry_t_147;
+struct LeaderboardEntry_t;
+extern void win_to_lin_struct_LeaderboardEntry_t_147(const struct winLeaderboardEntry_t_147 *w, struct LeaderboardEntry_t *l);
+extern void lin_to_win_struct_LeaderboardEntry_t_147(const struct LeaderboardEntry_t *l, struct winLeaderboardEntry_t_147 *w);
+#endif
+
+#if defined(SDKVER_147) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winSteamUGCDetails_t_147 {
+    PublishedFileId_t m_nPublishedFileId;
+    EResult m_eResult;
+    EWorkshopFileType m_eFileType;
+    AppId_t m_nCreatorAppID;
+    AppId_t m_nConsumerAppID;
+    char m_rgchTitle[129];
+    char m_rgchDescription[8000];
+    uint64 m_ulSteamIDOwner;
+    uint32 m_rtimeCreated;
+    uint32 m_rtimeUpdated;
+    uint32 m_rtimeAddedToUserList;
+    ERemoteStoragePublishedFileVisibility m_eVisibility;
+    bool m_bBanned;
+    bool m_bAcceptedForUse;
+    bool m_bTagsTruncated;
+    char m_rgchTags[1025];
+    UGCHandle_t m_hFile;
+    UGCHandle_t m_hPreviewFile;
+    char m_pchFileName[260];
+    int32 m_nFileSize;
+    int32 m_nPreviewFileSize;
+    char m_rgchURL[256];
+    uint32 m_unVotesUp;
+    uint32 m_unVotesDown;
+    float m_flScore;
+    uint32 m_unNumChildren;
+}  __attribute__ ((ms_struct));
+#pragma pack( pop )
+typedef struct winSteamUGCDetails_t_147 winSteamUGCDetails_t_147;
+struct SteamUGCDetails_t;
+extern void win_to_lin_struct_SteamUGCDetails_t_147(const struct winSteamUGCDetails_t_147 *w, struct SteamUGCDetails_t *l);
+extern void lin_to_win_struct_SteamUGCDetails_t_147(const struct SteamUGCDetails_t *l, struct winSteamUGCDetails_t_147 *w);
+#endif
+
+#if defined(SDKVER_147) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winSteamNetworkingMessage_t_147 {
+    void * m_pData;
+    int m_cbSize;
+    HSteamNetConnection m_conn;
+    SteamNetworkingIdentity m_identityPeer __attribute__((aligned(1)));
+    int64 m_nConnUserData;
+    SteamNetworkingMicroseconds m_usecTimeReceived;
+    int64 m_nMessageNumber;
+    void *m_pfnFreeData; /*fn pointer*/
+    void *m_pfnRelease; /*fn pointer*/
+    int m_nChannel;
+    int m_nFlags;
+    int64 m_nUserData;
+}  __attribute__ ((ms_struct));
+#pragma pack( pop )
+typedef struct winSteamNetworkingMessage_t_147 winSteamNetworkingMessage_t_147;
+struct SteamNetworkingMessage_t;
+#endif
+
 #if defined(SDKVER_146) || !defined(__cplusplus)
 #pragma pack( push, 8 )
 struct winSteamPartyBeaconLocation_t_146 {

lsteamclient/winISteamClient.c

@@ -15,6 +15,396 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamClient_SteamClient020.h"
+
+typedef struct __winISteamClient_SteamClient020 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamClient_SteamClient020;
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_CreateSteamPipe, 4)
+HSteamPipe __thiscall winISteamClient_SteamClient020_CreateSteamPipe(winISteamClient_SteamClient020 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamClient_SteamClient020_CreateSteamPipe(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_BReleaseSteamPipe, 8)
+bool __thiscall winISteamClient_SteamClient020_BReleaseSteamPipe(winISteamClient_SteamClient020 *_this, HSteamPipe hSteamPipe)
+{
+    TRACE("%p\n", _this);
+    return cppISteamClient_SteamClient020_BReleaseSteamPipe(_this->linux_side, hSteamPipe);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_ConnectToGlobalUser, 8)
+HSteamUser __thiscall winISteamClient_SteamClient020_ConnectToGlobalUser(winISteamClient_SteamClient020 *_this, HSteamPipe hSteamPipe)
+{
+    TRACE("%p\n", _this);
+    return cppISteamClient_SteamClient020_ConnectToGlobalUser(_this->linux_side, hSteamPipe);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_CreateLocalUser, 12)
+HSteamUser __thiscall winISteamClient_SteamClient020_CreateLocalUser(winISteamClient_SteamClient020 *_this, HSteamPipe * phSteamPipe, EAccountType eAccountType)
+{
+    TRACE("%p\n", _this);
+    return cppISteamClient_SteamClient020_CreateLocalUser(_this->linux_side, phSteamPipe, eAccountType);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_ReleaseUser, 12)
+void __thiscall winISteamClient_SteamClient020_ReleaseUser(winISteamClient_SteamClient020 *_this, HSteamPipe hSteamPipe, HSteamUser hUser)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_ReleaseUser(_this->linux_side, hSteamPipe, hUser);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamUser, 16)
+winISteamUser * __thiscall winISteamClient_SteamClient020_GetISteamUser(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamUser(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamGameServer, 16)
+winISteamGameServer * __thiscall winISteamClient_SteamClient020_GetISteamGameServer(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamGameServer(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_SetLocalIPBinding, 12)
+void __thiscall winISteamClient_SteamClient020_SetLocalIPBinding(winISteamClient_SteamClient020 *_this, const SteamIPAddress_t * unIP, uint16 usPort)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_SetLocalIPBinding(_this->linux_side, unIP, usPort);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamFriends, 16)
+winISteamFriends * __thiscall winISteamClient_SteamClient020_GetISteamFriends(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamFriends(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamUtils, 12)
+winISteamUtils * __thiscall winISteamClient_SteamClient020_GetISteamUtils(winISteamClient_SteamClient020 *_this, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamUtils(_this->linux_side, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamMatchmaking, 16)
+winISteamMatchmaking * __thiscall winISteamClient_SteamClient020_GetISteamMatchmaking(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamMatchmaking(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamMatchmakingServers, 16)
+winISteamMatchmakingServers * __thiscall winISteamClient_SteamClient020_GetISteamMatchmakingServers(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamMatchmakingServers(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamGenericInterface, 16)
+void * __thiscall winISteamClient_SteamClient020_GetISteamGenericInterface(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamGenericInterface(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamUserStats, 16)
+winISteamUserStats * __thiscall winISteamClient_SteamClient020_GetISteamUserStats(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamUserStats(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamGameServerStats, 16)
+winISteamGameServerStats * __thiscall winISteamClient_SteamClient020_GetISteamGameServerStats(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamGameServerStats(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamApps, 16)
+winISteamApps * __thiscall winISteamClient_SteamClient020_GetISteamApps(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamApps(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamNetworking, 16)
+winISteamNetworking * __thiscall winISteamClient_SteamClient020_GetISteamNetworking(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamNetworking(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamRemoteStorage, 16)
+winISteamRemoteStorage * __thiscall winISteamClient_SteamClient020_GetISteamRemoteStorage(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamRemoteStorage(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamScreenshots, 16)
+winISteamScreenshots * __thiscall winISteamClient_SteamClient020_GetISteamScreenshots(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamScreenshots(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamGameSearch, 16)
+winISteamGameSearch * __thiscall winISteamClient_SteamClient020_GetISteamGameSearch(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamGameSearch(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_RunFrame, 4)
+void __thiscall winISteamClient_SteamClient020_RunFrame(winISteamClient_SteamClient020 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_RunFrame(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetIPCCallCount, 4)
+uint32 __thiscall winISteamClient_SteamClient020_GetIPCCallCount(winISteamClient_SteamClient020 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamClient_SteamClient020_GetIPCCallCount(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_SetWarningMessageHook, 8)
+void __thiscall winISteamClient_SteamClient020_SetWarningMessageHook(winISteamClient_SteamClient020 *_this, SteamAPIWarningMessageHook_t pFunction)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_SetWarningMessageHook(_this->linux_side, pFunction);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_BShutdownIfAllPipesClosed, 4)
+bool __thiscall winISteamClient_SteamClient020_BShutdownIfAllPipesClosed(winISteamClient_SteamClient020 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamClient_SteamClient020_BShutdownIfAllPipesClosed(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamHTTP, 16)
+winISteamHTTP * __thiscall winISteamClient_SteamClient020_GetISteamHTTP(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamHTTP(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_DEPRECATED_GetISteamUnifiedMessages, 16)
+void * __thiscall winISteamClient_SteamClient020_DEPRECATED_GetISteamUnifiedMessages(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return cppISteamClient_SteamClient020_DEPRECATED_GetISteamUnifiedMessages(_this->linux_side, hSteamuser, hSteamPipe, pchVersion);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamController, 16)
+winISteamController * __thiscall winISteamClient_SteamClient020_GetISteamController(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamController(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamUGC, 16)
+winISteamUGC * __thiscall winISteamClient_SteamClient020_GetISteamUGC(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamUGC(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamAppList, 16)
+winISteamAppList * __thiscall winISteamClient_SteamClient020_GetISteamAppList(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamAppList(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamMusic, 16)
+winISteamMusic * __thiscall winISteamClient_SteamClient020_GetISteamMusic(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamMusic(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamMusicRemote, 16)
+winISteamMusicRemote * __thiscall winISteamClient_SteamClient020_GetISteamMusicRemote(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamMusicRemote(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamHTMLSurface, 16)
+winISteamHTMLSurface * __thiscall winISteamClient_SteamClient020_GetISteamHTMLSurface(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamHTMLSurface(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess, 8)
+void __thiscall winISteamClient_SteamClient020_DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess(winISteamClient_SteamClient020 *_this, void * _a)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess(_this->linux_side, _a);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess, 8)
+void __thiscall winISteamClient_SteamClient020_DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess(winISteamClient_SteamClient020 *_this, void * _a)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess(_this->linux_side, _a);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_Set_SteamAPI_CCheckCallbackRegisteredInProcess, 8)
+void __thiscall winISteamClient_SteamClient020_Set_SteamAPI_CCheckCallbackRegisteredInProcess(winISteamClient_SteamClient020 *_this, SteamAPI_CheckCallbackRegistered_t func)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_Set_SteamAPI_CCheckCallbackRegisteredInProcess(_this->linux_side, func);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamInventory, 16)
+winISteamInventory * __thiscall winISteamClient_SteamClient020_GetISteamInventory(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamInventory(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamVideo, 16)
+winISteamVideo * __thiscall winISteamClient_SteamClient020_GetISteamVideo(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamVideo(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamParentalSettings, 16)
+winISteamParentalSettings * __thiscall winISteamClient_SteamClient020_GetISteamParentalSettings(winISteamClient_SteamClient020 *_this, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamParentalSettings(_this->linux_side, hSteamuser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamInput, 16)
+winISteamInput * __thiscall winISteamClient_SteamClient020_GetISteamInput(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamInput(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamParties, 16)
+winISteamParties * __thiscall winISteamClient_SteamClient020_GetISteamParties(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamParties(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_GetISteamRemotePlay, 16)
+winISteamRemotePlay * __thiscall winISteamClient_SteamClient020_GetISteamRemotePlay(winISteamClient_SteamClient020 *_this, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion)
+{
+    TRACE("%p\n", _this);
+    return create_win_interface(pchVersion,
+        cppISteamClient_SteamClient020_GetISteamRemotePlay(_this->linux_side, hSteamUser, hSteamPipe, pchVersion));
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamClient_SteamClient020_DestroyAllInterfaces, 4)
+void __thiscall winISteamClient_SteamClient020_DestroyAllInterfaces(winISteamClient_SteamClient020 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamClient_SteamClient020_DestroyAllInterfaces(_this->linux_side);
+}
+
+extern vtable_ptr winISteamClient_SteamClient020_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamClient_SteamClient020,
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_CreateSteamPipe)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_BReleaseSteamPipe)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_ConnectToGlobalUser)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_CreateLocalUser)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_ReleaseUser)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamUser)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamGameServer)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_SetLocalIPBinding)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamFriends)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamUtils)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamMatchmaking)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamMatchmakingServers)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamGenericInterface)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamUserStats)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamGameServerStats)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamApps)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamNetworking)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamRemoteStorage)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamScreenshots)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamGameSearch)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_RunFrame)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetIPCCallCount)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_SetWarningMessageHook)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_BShutdownIfAllPipesClosed)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamHTTP)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_DEPRECATED_GetISteamUnifiedMessages)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamController)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamUGC)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamAppList)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamMusic)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamMusicRemote)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamHTMLSurface)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_DEPRECATED_Set_SteamAPI_CPostAPIResultInProcess)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_DEPRECATED_Remove_SteamAPI_CPostAPIResultInProcess)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_Set_SteamAPI_CCheckCallbackRegisteredInProcess)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamInventory)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamVideo)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamParentalSettings)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamInput)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamParties)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_GetISteamRemotePlay)
+        VTABLE_ADD_FUNC(winISteamClient_SteamClient020_DestroyAllInterfaces)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamClient_SteamClient020 *create_winISteamClient_SteamClient020(void *linux_side)
+{
+    winISteamClient_SteamClient020 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamClient_SteamClient020));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamClient_SteamClient020_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamClient_SteamClient019.h"
 
 typedef struct __winISteamClient_SteamClient019 {

lsteamclient/winISteamGameServer.c

@@ -15,6 +15,388 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamGameServer_SteamGameServer013.h"
+
+typedef struct __winISteamGameServer_SteamGameServer013 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamGameServer_SteamGameServer013;
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_InitGameServer, 28)
+bool __thiscall winISteamGameServer_SteamGameServer013_InitGameServer(winISteamGameServer_SteamGameServer013 *_this, uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char * pchVersionString)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_InitGameServer(_this->linux_side, unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetProduct, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetProduct(winISteamGameServer_SteamGameServer013 *_this, const char * pszProduct)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetProduct(_this->linux_side, pszProduct);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetGameDescription, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetGameDescription(winISteamGameServer_SteamGameServer013 *_this, const char * pszGameDescription)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetGameDescription(_this->linux_side, pszGameDescription);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetModDir, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetModDir(winISteamGameServer_SteamGameServer013 *_this, const char * pszModDir)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetModDir(_this->linux_side, pszModDir);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetDedicatedServer, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetDedicatedServer(winISteamGameServer_SteamGameServer013 *_this, bool bDedicated)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetDedicatedServer(_this->linux_side, bDedicated);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_LogOn, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_LogOn(winISteamGameServer_SteamGameServer013 *_this, const char * pszToken)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_LogOn(_this->linux_side, pszToken);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_LogOnAnonymous, 4)
+void __thiscall winISteamGameServer_SteamGameServer013_LogOnAnonymous(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_LogOnAnonymous(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_LogOff, 4)
+void __thiscall winISteamGameServer_SteamGameServer013_LogOff(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_LogOff(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_BLoggedOn, 4)
+bool __thiscall winISteamGameServer_SteamGameServer013_BLoggedOn(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_BLoggedOn(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_BSecure, 4)
+bool __thiscall winISteamGameServer_SteamGameServer013_BSecure(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_BSecure(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_GetSteamID, 8)
+CSteamID *__thiscall winISteamGameServer_SteamGameServer013_GetSteamID(winISteamGameServer_SteamGameServer013 *_this, CSteamID *_r)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamGameServer_SteamGameServer013_GetSteamID(_this->linux_side);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_WasRestartRequested, 4)
+bool __thiscall winISteamGameServer_SteamGameServer013_WasRestartRequested(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_WasRestartRequested(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetMaxPlayerCount, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetMaxPlayerCount(winISteamGameServer_SteamGameServer013 *_this, int cPlayersMax)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetMaxPlayerCount(_this->linux_side, cPlayersMax);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetBotPlayerCount, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetBotPlayerCount(winISteamGameServer_SteamGameServer013 *_this, int cBotplayers)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetBotPlayerCount(_this->linux_side, cBotplayers);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetServerName, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetServerName(winISteamGameServer_SteamGameServer013 *_this, const char * pszServerName)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetServerName(_this->linux_side, pszServerName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetMapName, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetMapName(winISteamGameServer_SteamGameServer013 *_this, const char * pszMapName)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetMapName(_this->linux_side, pszMapName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetPasswordProtected, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetPasswordProtected(winISteamGameServer_SteamGameServer013 *_this, bool bPasswordProtected)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetPasswordProtected(_this->linux_side, bPasswordProtected);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetSpectatorPort, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetSpectatorPort(winISteamGameServer_SteamGameServer013 *_this, uint16 unSpectatorPort)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetSpectatorPort(_this->linux_side, unSpectatorPort);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetSpectatorServerName, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetSpectatorServerName(winISteamGameServer_SteamGameServer013 *_this, const char * pszSpectatorServerName)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetSpectatorServerName(_this->linux_side, pszSpectatorServerName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_ClearAllKeyValues, 4)
+void __thiscall winISteamGameServer_SteamGameServer013_ClearAllKeyValues(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_ClearAllKeyValues(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetKeyValue, 12)
+void __thiscall winISteamGameServer_SteamGameServer013_SetKeyValue(winISteamGameServer_SteamGameServer013 *_this, const char * pKey, const char * pValue)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetKeyValue(_this->linux_side, pKey, pValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetGameTags, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetGameTags(winISteamGameServer_SteamGameServer013 *_this, const char * pchGameTags)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetGameTags(_this->linux_side, pchGameTags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetGameData, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetGameData(winISteamGameServer_SteamGameServer013 *_this, const char * pchGameData)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetGameData(_this->linux_side, pchGameData);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetRegion, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetRegion(winISteamGameServer_SteamGameServer013 *_this, const char * pszRegion)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetRegion(_this->linux_side, pszRegion);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SendUserConnectAndAuthenticate, 20)
+bool __thiscall winISteamGameServer_SteamGameServer013_SendUserConnectAndAuthenticate(winISteamGameServer_SteamGameServer013 *_this, uint32 unIPClient, const void * pvAuthBlob, uint32 cubAuthBlobSize, CSteamID * pSteamIDUser)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_SendUserConnectAndAuthenticate(_this->linux_side, unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_CreateUnauthenticatedUserConnection, 8)
+CSteamID *__thiscall winISteamGameServer_SteamGameServer013_CreateUnauthenticatedUserConnection(winISteamGameServer_SteamGameServer013 *_this, CSteamID *_r)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamGameServer_SteamGameServer013_CreateUnauthenticatedUserConnection(_this->linux_side);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SendUserDisconnect, 12)
+void __thiscall winISteamGameServer_SteamGameServer013_SendUserDisconnect(winISteamGameServer_SteamGameServer013 *_this, CSteamID steamIDUser)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SendUserDisconnect(_this->linux_side, steamIDUser);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_BUpdateUserData, 20)
+bool __thiscall winISteamGameServer_SteamGameServer013_BUpdateUserData(winISteamGameServer_SteamGameServer013 *_this, CSteamID steamIDUser, const char * pchPlayerName, uint32 uScore)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_BUpdateUserData(_this->linux_side, steamIDUser, pchPlayerName, uScore);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_GetAuthSessionTicket, 16)
+HAuthTicket __thiscall winISteamGameServer_SteamGameServer013_GetAuthSessionTicket(winISteamGameServer_SteamGameServer013 *_this, void * pTicket, int cbMaxTicket, uint32 * pcbTicket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_GetAuthSessionTicket(_this->linux_side, pTicket, cbMaxTicket, pcbTicket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_BeginAuthSession, 20)
+EBeginAuthSessionResult __thiscall winISteamGameServer_SteamGameServer013_BeginAuthSession(winISteamGameServer_SteamGameServer013 *_this, const void * pAuthTicket, int cbAuthTicket, CSteamID steamID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_BeginAuthSession(_this->linux_side, pAuthTicket, cbAuthTicket, steamID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_EndAuthSession, 12)
+void __thiscall winISteamGameServer_SteamGameServer013_EndAuthSession(winISteamGameServer_SteamGameServer013 *_this, CSteamID steamID)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_EndAuthSession(_this->linux_side, steamID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_CancelAuthTicket, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_CancelAuthTicket(winISteamGameServer_SteamGameServer013 *_this, HAuthTicket hAuthTicket)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_CancelAuthTicket(_this->linux_side, hAuthTicket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_UserHasLicenseForApp, 16)
+EUserHasLicenseForAppResult __thiscall winISteamGameServer_SteamGameServer013_UserHasLicenseForApp(winISteamGameServer_SteamGameServer013 *_this, CSteamID steamID, AppId_t appID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_UserHasLicenseForApp(_this->linux_side, steamID, appID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_RequestUserGroupStatus, 20)
+bool __thiscall winISteamGameServer_SteamGameServer013_RequestUserGroupStatus(winISteamGameServer_SteamGameServer013 *_this, CSteamID steamIDUser, CSteamID steamIDGroup)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_RequestUserGroupStatus(_this->linux_side, steamIDUser, steamIDGroup);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_GetGameplayStats, 4)
+void __thiscall winISteamGameServer_SteamGameServer013_GetGameplayStats(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_GetGameplayStats(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_GetServerReputation, 4)
+SteamAPICall_t __thiscall winISteamGameServer_SteamGameServer013_GetServerReputation(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_GetServerReputation(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_GetPublicIP, 8)
+SteamIPAddress_t *__thiscall winISteamGameServer_SteamGameServer013_GetPublicIP(winISteamGameServer_SteamGameServer013 *_this, SteamIPAddress_t *_r)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamGameServer_SteamGameServer013_GetPublicIP(_this->linux_side);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_HandleIncomingPacket, 20)
+bool __thiscall winISteamGameServer_SteamGameServer013_HandleIncomingPacket(winISteamGameServer_SteamGameServer013 *_this, const void * pData, int cbData, uint32 srcIP, uint16 srcPort)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_HandleIncomingPacket(_this->linux_side, pData, cbData, srcIP, srcPort);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_GetNextOutgoingPacket, 20)
+int __thiscall winISteamGameServer_SteamGameServer013_GetNextOutgoingPacket(winISteamGameServer_SteamGameServer013 *_this, void * pOut, int cbMaxOut, uint32 * pNetAdr, uint16 * pPort)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_GetNextOutgoingPacket(_this->linux_side, pOut, cbMaxOut, pNetAdr, pPort);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_EnableHeartbeats, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_EnableHeartbeats(winISteamGameServer_SteamGameServer013 *_this, bool bActive)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_EnableHeartbeats(_this->linux_side, bActive);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_SetHeartbeatInterval, 8)
+void __thiscall winISteamGameServer_SteamGameServer013_SetHeartbeatInterval(winISteamGameServer_SteamGameServer013 *_this, int iHeartbeatInterval)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_SetHeartbeatInterval(_this->linux_side, iHeartbeatInterval);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_ForceHeartbeat, 4)
+void __thiscall winISteamGameServer_SteamGameServer013_ForceHeartbeat(winISteamGameServer_SteamGameServer013 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamGameServer_SteamGameServer013_ForceHeartbeat(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_AssociateWithClan, 12)
+SteamAPICall_t __thiscall winISteamGameServer_SteamGameServer013_AssociateWithClan(winISteamGameServer_SteamGameServer013 *_this, CSteamID steamIDClan)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_AssociateWithClan(_this->linux_side, steamIDClan);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamGameServer_SteamGameServer013_ComputeNewPlayerCompatibility, 12)
+SteamAPICall_t __thiscall winISteamGameServer_SteamGameServer013_ComputeNewPlayerCompatibility(winISteamGameServer_SteamGameServer013 *_this, CSteamID steamIDNewPlayer)
+{
+    TRACE("%p\n", _this);
+    return cppISteamGameServer_SteamGameServer013_ComputeNewPlayerCompatibility(_this->linux_side, steamIDNewPlayer);
+}
+
+extern vtable_ptr winISteamGameServer_SteamGameServer013_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamGameServer_SteamGameServer013,
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_InitGameServer)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetProduct)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetGameDescription)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetModDir)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetDedicatedServer)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_LogOn)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_LogOnAnonymous)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_LogOff)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_BLoggedOn)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_BSecure)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_GetSteamID)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_WasRestartRequested)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetMaxPlayerCount)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetBotPlayerCount)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetServerName)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetMapName)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetPasswordProtected)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetSpectatorPort)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetSpectatorServerName)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_ClearAllKeyValues)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetKeyValue)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetGameTags)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetGameData)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetRegion)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SendUserConnectAndAuthenticate)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_CreateUnauthenticatedUserConnection)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SendUserDisconnect)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_BUpdateUserData)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_GetAuthSessionTicket)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_BeginAuthSession)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_EndAuthSession)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_CancelAuthTicket)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_UserHasLicenseForApp)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_RequestUserGroupStatus)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_GetGameplayStats)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_GetServerReputation)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_GetPublicIP)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_HandleIncomingPacket)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_GetNextOutgoingPacket)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_EnableHeartbeats)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_SetHeartbeatInterval)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_ForceHeartbeat)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_AssociateWithClan)
+        VTABLE_ADD_FUNC(winISteamGameServer_SteamGameServer013_ComputeNewPlayerCompatibility)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamGameServer_SteamGameServer013 *create_winISteamGameServer_SteamGameServer013(void *linux_side)
+{
+    winISteamGameServer_SteamGameServer013 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamGameServer_SteamGameServer013));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamGameServer_SteamGameServer013_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamGameServer_SteamGameServer012.h"
 
 typedef struct __winISteamGameServer_SteamGameServer012 {

lsteamclient/winISteamNetworking.c

@@ -15,6 +15,209 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamNetworking_SteamNetworking006.h"
+
+typedef struct __winISteamNetworking_SteamNetworking006 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamNetworking_SteamNetworking006;
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_SendP2PPacket, 28)
+bool __thiscall winISteamNetworking_SteamNetworking006_SendP2PPacket(winISteamNetworking_SteamNetworking006 *_this, CSteamID steamIDRemote, const void * pubData, uint32 cubData, EP2PSend eP2PSendType, int nChannel)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_SendP2PPacket(_this->linux_side, steamIDRemote, pubData, cubData, eP2PSendType, nChannel);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_IsP2PPacketAvailable, 12)
+bool __thiscall winISteamNetworking_SteamNetworking006_IsP2PPacketAvailable(winISteamNetworking_SteamNetworking006 *_this, uint32 * pcubMsgSize, int nChannel)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_IsP2PPacketAvailable(_this->linux_side, pcubMsgSize, nChannel);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_ReadP2PPacket, 24)
+bool __thiscall winISteamNetworking_SteamNetworking006_ReadP2PPacket(winISteamNetworking_SteamNetworking006 *_this, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize, CSteamID * psteamIDRemote, int nChannel)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_ReadP2PPacket(_this->linux_side, pubDest, cubDest, pcubMsgSize, psteamIDRemote, nChannel);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser, 12)
+bool __thiscall winISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser(winISteamNetworking_SteamNetworking006 *_this, CSteamID steamIDRemote)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser(_this->linux_side, steamIDRemote);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser, 12)
+bool __thiscall winISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser(winISteamNetworking_SteamNetworking006 *_this, CSteamID steamIDRemote)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser(_this->linux_side, steamIDRemote);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser, 16)
+bool __thiscall winISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser(winISteamNetworking_SteamNetworking006 *_this, CSteamID steamIDRemote, int nChannel)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser(_this->linux_side, steamIDRemote, nChannel);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_GetP2PSessionState, 16)
+bool __thiscall winISteamNetworking_SteamNetworking006_GetP2PSessionState(winISteamNetworking_SteamNetworking006 *_this, CSteamID steamIDRemote, P2PSessionState_t * pConnectionState)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_GetP2PSessionState(_this->linux_side, steamIDRemote, pConnectionState);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_AllowP2PPacketRelay, 8)
+bool __thiscall winISteamNetworking_SteamNetworking006_AllowP2PPacketRelay(winISteamNetworking_SteamNetworking006 *_this, bool bAllow)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_AllowP2PPacketRelay(_this->linux_side, bAllow);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_CreateListenSocket, 20)
+SNetListenSocket_t __thiscall winISteamNetworking_SteamNetworking006_CreateListenSocket(winISteamNetworking_SteamNetworking006 *_this, int nVirtualP2PPort, SteamIPAddress_t nIP, uint16 nPort, bool bAllowUseOfPacketRelay)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_CreateListenSocket(_this->linux_side, nVirtualP2PPort, nIP, nPort, bAllowUseOfPacketRelay);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket, 24)
+SNetSocket_t __thiscall winISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket(winISteamNetworking_SteamNetworking006 *_this, CSteamID steamIDTarget, int nVirtualPort, int nTimeoutSec, bool bAllowUseOfPacketRelay)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket(_this->linux_side, steamIDTarget, nVirtualPort, nTimeoutSec, bAllowUseOfPacketRelay);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_CreateConnectionSocket, 16)
+SNetSocket_t __thiscall winISteamNetworking_SteamNetworking006_CreateConnectionSocket(winISteamNetworking_SteamNetworking006 *_this, SteamIPAddress_t nIP, uint16 nPort, int nTimeoutSec)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_CreateConnectionSocket(_this->linux_side, nIP, nPort, nTimeoutSec);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_DestroySocket, 12)
+bool __thiscall winISteamNetworking_SteamNetworking006_DestroySocket(winISteamNetworking_SteamNetworking006 *_this, SNetSocket_t hSocket, bool bNotifyRemoteEnd)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_DestroySocket(_this->linux_side, hSocket, bNotifyRemoteEnd);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_DestroyListenSocket, 12)
+bool __thiscall winISteamNetworking_SteamNetworking006_DestroyListenSocket(winISteamNetworking_SteamNetworking006 *_this, SNetListenSocket_t hSocket, bool bNotifyRemoteEnd)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_DestroyListenSocket(_this->linux_side, hSocket, bNotifyRemoteEnd);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_SendDataOnSocket, 20)
+bool __thiscall winISteamNetworking_SteamNetworking006_SendDataOnSocket(winISteamNetworking_SteamNetworking006 *_this, SNetSocket_t hSocket, void * pubData, uint32 cubData, bool bReliable)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_SendDataOnSocket(_this->linux_side, hSocket, pubData, cubData, bReliable);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket, 12)
+bool __thiscall winISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket(winISteamNetworking_SteamNetworking006 *_this, SNetSocket_t hSocket, uint32 * pcubMsgSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket(_this->linux_side, hSocket, pcubMsgSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_RetrieveDataFromSocket, 20)
+bool __thiscall winISteamNetworking_SteamNetworking006_RetrieveDataFromSocket(winISteamNetworking_SteamNetworking006 *_this, SNetSocket_t hSocket, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_RetrieveDataFromSocket(_this->linux_side, hSocket, pubDest, cubDest, pcubMsgSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_IsDataAvailable, 16)
+bool __thiscall winISteamNetworking_SteamNetworking006_IsDataAvailable(winISteamNetworking_SteamNetworking006 *_this, SNetListenSocket_t hListenSocket, uint32 * pcubMsgSize, SNetSocket_t * phSocket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_IsDataAvailable(_this->linux_side, hListenSocket, pcubMsgSize, phSocket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_RetrieveData, 24)
+bool __thiscall winISteamNetworking_SteamNetworking006_RetrieveData(winISteamNetworking_SteamNetworking006 *_this, SNetListenSocket_t hListenSocket, void * pubDest, uint32 cubDest, uint32 * pcubMsgSize, SNetSocket_t * phSocket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_RetrieveData(_this->linux_side, hListenSocket, pubDest, cubDest, pcubMsgSize, phSocket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_GetSocketInfo, 24)
+bool __thiscall winISteamNetworking_SteamNetworking006_GetSocketInfo(winISteamNetworking_SteamNetworking006 *_this, SNetSocket_t hSocket, CSteamID * pSteamIDRemote, int * peSocketStatus, SteamIPAddress_t * punIPRemote, uint16 * punPortRemote)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_GetSocketInfo(_this->linux_side, hSocket, pSteamIDRemote, peSocketStatus, punIPRemote, punPortRemote);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_GetListenSocketInfo, 16)
+bool __thiscall winISteamNetworking_SteamNetworking006_GetListenSocketInfo(winISteamNetworking_SteamNetworking006 *_this, SNetListenSocket_t hListenSocket, SteamIPAddress_t * pnIP, uint16 * pnPort)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_GetListenSocketInfo(_this->linux_side, hListenSocket, pnIP, pnPort);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_GetSocketConnectionType, 8)
+ESNetSocketConnectionType __thiscall winISteamNetworking_SteamNetworking006_GetSocketConnectionType(winISteamNetworking_SteamNetworking006 *_this, SNetSocket_t hSocket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_GetSocketConnectionType(_this->linux_side, hSocket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworking_SteamNetworking006_GetMaxPacketSize, 8)
+int __thiscall winISteamNetworking_SteamNetworking006_GetMaxPacketSize(winISteamNetworking_SteamNetworking006 *_this, SNetSocket_t hSocket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworking_SteamNetworking006_GetMaxPacketSize(_this->linux_side, hSocket);
+}
+
+extern vtable_ptr winISteamNetworking_SteamNetworking006_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamNetworking_SteamNetworking006,
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_SendP2PPacket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_IsP2PPacketAvailable)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_ReadP2PPacket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_AcceptP2PSessionWithUser)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_CloseP2PSessionWithUser)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_CloseP2PChannelWithUser)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_GetP2PSessionState)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_AllowP2PPacketRelay)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_CreateListenSocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_CreateP2PConnectionSocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_CreateConnectionSocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_DestroySocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_DestroyListenSocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_SendDataOnSocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_IsDataAvailableOnSocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_RetrieveDataFromSocket)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_IsDataAvailable)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_RetrieveData)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_GetSocketInfo)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_GetListenSocketInfo)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_GetSocketConnectionType)
+        VTABLE_ADD_FUNC(winISteamNetworking_SteamNetworking006_GetMaxPacketSize)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamNetworking_SteamNetworking006 *create_winISteamNetworking_SteamNetworking006(void *linux_side)
+{
+    winISteamNetworking_SteamNetworking006 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamNetworking_SteamNetworking006));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamNetworking_SteamNetworking006_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamNetworking_SteamNetworking005.h"
 
 typedef struct __winISteamNetworking_SteamNetworking005 {

lsteamclient/winISteamNetworkingSockets.c

@@ -15,6 +15,310 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamNetworkingSockets_SteamNetworkingSockets006.h"
+
+typedef struct __winISteamNetworkingSockets_SteamNetworkingSockets006 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamNetworkingSockets_SteamNetworkingSockets006;
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketIP, 16)
+HSteamListenSocket __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketIP(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, const SteamNetworkingIPAddr * localAddress, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketIP(_this->linux_side, localAddress, nOptions, pOptions);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectByIPAddress, 16)
+HSteamNetConnection __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectByIPAddress(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, const SteamNetworkingIPAddr * address, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectByIPAddress(_this->linux_side, address, nOptions, pOptions);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketP2P, 16)
+HSteamListenSocket __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketP2P(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketP2P(_this->linux_side, nVirtualPort, nOptions, pOptions);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2P, 20)
+HSteamNetConnection __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2P(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, const SteamNetworkingIdentity * identityRemote, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2P(_this->linux_side, identityRemote, nVirtualPort, nOptions, pOptions);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_AcceptConnection, 8)
+EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_AcceptConnection(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hConn)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_AcceptConnection(_this->linux_side, hConn);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_CloseConnection, 20)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_CloseConnection(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hPeer, int nReason, const char * pszDebug, bool bEnableLinger)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_CloseConnection(_this->linux_side, hPeer, nReason, pszDebug, bEnableLinger);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_CloseListenSocket, 8)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_CloseListenSocket(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamListenSocket hSocket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_CloseListenSocket(_this->linux_side, hSocket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionUserData, 16)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionUserData(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hPeer, int64 nUserData)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionUserData(_this->linux_side, hPeer, nUserData);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionUserData, 8)
+int64 __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionUserData(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hPeer)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionUserData(_this->linux_side, hPeer);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionName, 12)
+void __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionName(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hPeer, const char * pszName)
+{
+    TRACE("%p\n", _this);
+    cppISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionName(_this->linux_side, hPeer, pszName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionName, 16)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionName(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hPeer, char * pszName, int nMaxLen)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionName(_this->linux_side, hPeer, pszName, nMaxLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_SendMessageToConnection, 24)
+EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_SendMessageToConnection(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hConn, const void * pData, uint32 cbData, int nSendFlags, int64 * pOutMessageNumber)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_SendMessageToConnection(_this->linux_side, hConn, pData, cbData, nSendFlags, pOutMessageNumber);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_SendMessages, 16)
+void __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_SendMessages(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, int nMessages, winSteamNetworkingMessage_t_147 ** pMessages, int64 * pOutMessageNumberOrResult)
+{
+    TRACE("%p\n", _this);
+    cppISteamNetworkingSockets_SteamNetworkingSockets006_SendMessages(_this->linux_side, nMessages, pMessages, pOutMessageNumberOrResult);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_FlushMessagesOnConnection, 8)
+EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_FlushMessagesOnConnection(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hConn)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_FlushMessagesOnConnection(_this->linux_side, hConn);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnConnection, 16)
+int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnConnection(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hConn, winSteamNetworkingMessage_t_147 ** ppOutMessages, int nMaxMessages)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnConnection(_this->linux_side, hConn, ppOutMessages, nMaxMessages);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnListenSocket, 16)
+int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnListenSocket(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamListenSocket hSocket, winSteamNetworkingMessage_t_147 ** ppOutMessages, int nMaxMessages)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnListenSocket(_this->linux_side, hSocket, ppOutMessages, nMaxMessages);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionInfo, 12)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionInfo(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hConn, SteamNetConnectionInfo_t * pInfo)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionInfo(_this->linux_side, hConn, pInfo);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetQuickConnectionStatus, 12)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetQuickConnectionStatus(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hConn, SteamNetworkingQuickConnectionStatus * pStats)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetQuickConnectionStatus(_this->linux_side, hConn, pStats);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetDetailedConnectionStatus, 16)
+int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetDetailedConnectionStatus(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection hConn, char * pszBuf, int cbBuf)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetDetailedConnectionStatus(_this->linux_side, hConn, pszBuf, cbBuf);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetListenSocketAddress, 12)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetListenSocketAddress(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamListenSocket hSocket, SteamNetworkingIPAddr * address)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetListenSocketAddress(_this->linux_side, hSocket, address);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateSocketPair, 24)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_CreateSocketPair(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, HSteamNetConnection * pOutConnection1, HSteamNetConnection * pOutConnection2, bool bUseNetworkLoopback, const SteamNetworkingIdentity * pIdentity1, const SteamNetworkingIdentity * pIdentity2)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateSocketPair(_this->linux_side, pOutConnection1, pOutConnection2, bUseNetworkLoopback, pIdentity1, pIdentity2);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetIdentity, 8)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetIdentity(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, SteamNetworkingIdentity * pIdentity)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetIdentity(_this->linux_side, pIdentity);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_InitAuthentication, 4)
+ESteamNetworkingAvailability __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_InitAuthentication(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_InitAuthentication(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetAuthenticationStatus, 8)
+ESteamNetworkingAvailability __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetAuthenticationStatus(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, SteamNetAuthenticationStatus_t * pDetails)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetAuthenticationStatus(_this->linux_side, pDetails);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedRelayAuthTicket, 16)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedRelayAuthTicket(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, const void * pvTicket, int cbTicket, SteamDatagramRelayAuthTicket * pOutParsedTicket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedRelayAuthTicket(_this->linux_side, pvTicket, cbTicket, pOutParsedTicket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_FindRelayAuthTicketForServer, 16)
+int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_FindRelayAuthTicketForServer(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, const SteamNetworkingIdentity * identityGameServer, int nVirtualPort, SteamDatagramRelayAuthTicket * pOutParsedTicket)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_FindRelayAuthTicketForServer(_this->linux_side, identityGameServer, nVirtualPort, pOutParsedTicket);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectToHostedDedicatedServer, 20)
+HSteamNetConnection __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectToHostedDedicatedServer(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, const SteamNetworkingIdentity * identityTarget, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectToHostedDedicatedServer(_this->linux_side, identityTarget, nVirtualPort, nOptions, pOptions);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPort, 4)
+uint16 __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPort(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPort(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPOPID, 4)
+SteamNetworkingPOPID __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPOPID(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPOPID(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerAddress, 8)
+EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerAddress(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, SteamDatagramHostedAddress * pRouting)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerAddress(_this->linux_side, pRouting);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateHostedDedicatedServerListenSocket, 16)
+HSteamListenSocket __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_CreateHostedDedicatedServerListenSocket(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, int nVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_CreateHostedDedicatedServerListenSocket(_this->linux_side, nVirtualPort, nOptions, pOptions);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_GetGameCoordinatorServerLogin, 16)
+EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_GetGameCoordinatorServerLogin(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, SteamDatagramGameCoordinatorServerLogin * pLoginInfo, int * pcbSignedBlob, void * pBlob)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_GetGameCoordinatorServerLogin(_this->linux_side, pLoginInfo, pcbSignedBlob, pBlob);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2PCustomSignaling, 20)
+HSteamNetConnection __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2PCustomSignaling(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, ISteamNetworkingConnectionCustomSignaling * pSignaling, const SteamNetworkingIdentity * pPeerIdentity, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2PCustomSignaling(_this->linux_side, pSignaling, pPeerIdentity, nOptions, pOptions);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedP2PCustomSignal, 16)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedP2PCustomSignal(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this, const void * pMsg, int cbMsg, ISteamNetworkingCustomSignalingRecvContext * pContext)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedP2PCustomSignal(_this->linux_side, pMsg, cbMsg, pContext);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets006_destructor, 4)
+void __thiscall winISteamNetworkingSockets_SteamNetworkingSockets006_destructor(winISteamNetworkingSockets_SteamNetworkingSockets006 *_this)
+{/* never called */}
+
+extern vtable_ptr winISteamNetworkingSockets_SteamNetworkingSockets006_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamNetworkingSockets_SteamNetworkingSockets006,
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketIP)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectByIPAddress)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateListenSocketP2P)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2P)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_AcceptConnection)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_CloseConnection)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_CloseListenSocket)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionUserData)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionUserData)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_SetConnectionName)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionName)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_SendMessageToConnection)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_SendMessages)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_FlushMessagesOnConnection)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnConnection)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceiveMessagesOnListenSocket)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetConnectionInfo)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetQuickConnectionStatus)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetDetailedConnectionStatus)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetListenSocketAddress)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateSocketPair)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetIdentity)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_InitAuthentication)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetAuthenticationStatus)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedRelayAuthTicket)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_FindRelayAuthTicketForServer)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectToHostedDedicatedServer)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPort)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerPOPID)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetHostedDedicatedServerAddress)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_CreateHostedDedicatedServerListenSocket)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_GetGameCoordinatorServerLogin)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ConnectP2PCustomSignaling)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_ReceivedP2PCustomSignal)
+        VTABLE_ADD_FUNC(winISteamNetworkingSockets_SteamNetworkingSockets006_destructor)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamNetworkingSockets_SteamNetworkingSockets006 *create_winISteamNetworkingSockets_SteamNetworkingSockets006(void *linux_side)
+{
+    winISteamNetworkingSockets_SteamNetworkingSockets006 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamNetworkingSockets_SteamNetworkingSockets006));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamNetworkingSockets_SteamNetworkingSockets006_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamNetworkingSockets_SteamNetworkingSockets003.h"
 
 typedef struct __winISteamNetworkingSockets_SteamNetworkingSockets003 {

lsteamclient/winISteamNetworkingUtils.c

@@ -15,6 +15,214 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamNetworkingUtils_SteamNetworkingUtils003.h"
+
+typedef struct __winISteamNetworkingUtils_SteamNetworkingUtils003 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamNetworkingUtils_SteamNetworkingUtils003;
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_AllocateMessage, 8)
+SteamNetworkingMessage_t * __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_AllocateMessage(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, int cbAllocateBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_AllocateMessage(_this->linux_side, cbAllocateBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetRelayNetworkStatus, 8)
+ESteamNetworkingAvailability __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetRelayNetworkStatus(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, SteamRelayNetworkStatus_t * pDetails)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetRelayNetworkStatus(_this->linux_side, pDetails);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalPingLocation, 8)
+float __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalPingLocation(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, SteamNetworkPingLocation_t * result)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalPingLocation(_this->linux_side, result);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeBetweenTwoLocations, 12)
+int __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeBetweenTwoLocations(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, const SteamNetworkPingLocation_t * location1, const SteamNetworkPingLocation_t * location2)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeBetweenTwoLocations(_this->linux_side, location1, location2);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeFromLocalHost, 8)
+int __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeFromLocalHost(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, const SteamNetworkPingLocation_t * remoteLocation)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeFromLocalHost(_this->linux_side, remoteLocation);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_ConvertPingLocationToString, 16)
+void __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_ConvertPingLocationToString(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, const SteamNetworkPingLocation_t * location, char * pszBuf, int cchBufSize)
+{
+    TRACE("%p\n", _this);
+    cppISteamNetworkingUtils_SteamNetworkingUtils003_ConvertPingLocationToString(_this->linux_side, location, pszBuf, cchBufSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_ParsePingLocationString, 12)
+bool __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_ParsePingLocationString(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, const char * pszString, SteamNetworkPingLocation_t * result)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_ParsePingLocationString(_this->linux_side, pszString, result);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_CheckPingDataUpToDate, 8)
+bool __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_CheckPingDataUpToDate(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, float flMaxAgeSeconds)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_CheckPingDataUpToDate(_this->linux_side, flMaxAgeSeconds);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetPingToDataCenter, 12)
+int __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetPingToDataCenter(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, SteamNetworkingPOPID popID, SteamNetworkingPOPID * pViaRelayPoP)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPingToDataCenter(_this->linux_side, popID, pViaRelayPoP);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetDirectPingToPOP, 8)
+int __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetDirectPingToPOP(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, SteamNetworkingPOPID popID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetDirectPingToPOP(_this->linux_side, popID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPCount, 4)
+int __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPCount(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPCount(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPList, 12)
+int __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPList(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, SteamNetworkingPOPID * list, int nListSz)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPList(_this->linux_side, list, nListSz);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalTimestamp, 4)
+SteamNetworkingMicroseconds __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalTimestamp(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalTimestamp(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_SetDebugOutputFunction, 12)
+void __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_SetDebugOutputFunction(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, ESteamNetworkingSocketsDebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc)
+{
+    TRACE("%p\n", _this);
+    cppISteamNetworkingUtils_SteamNetworkingUtils003_SetDebugOutputFunction(_this->linux_side, eDetailLevel, pfnFunc);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_SetConfigValue, 24)
+bool __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_SetConfigValue(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType eDataType, const void * pArg)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_SetConfigValue(_this->linux_side, eValue, eScopeType, scopeObj, eDataType, pArg);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValue, 28)
+ESteamNetworkingGetConfigValueResult __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValue(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType * pOutDataType, void * pResult, size_t * cbResult)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValue(_this->linux_side, eValue, eScopeType, scopeObj, pOutDataType, pResult, cbResult);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValueInfo, 24)
+bool __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValueInfo(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, ESteamNetworkingConfigValue eValue, const char ** pOutName, ESteamNetworkingConfigDataType * pOutDataType, ESteamNetworkingConfigScope * pOutScope, ESteamNetworkingConfigValue * pOutNextValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValueInfo(_this->linux_side, eValue, pOutName, pOutDataType, pOutScope, pOutNextValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_GetFirstConfigValue, 4)
+ESteamNetworkingConfigValue __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_GetFirstConfigValue(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_GetFirstConfigValue(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ToString, 20)
+void __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ToString(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, const SteamNetworkingIPAddr * addr, char * buf, size_t cbBuf, bool bWithPort)
+{
+    TRACE("%p\n", _this);
+    cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ToString(_this->linux_side, addr, buf, cbBuf, bWithPort);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ParseString, 12)
+bool __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ParseString(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, SteamNetworkingIPAddr * pAddr, const char * pszStr)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ParseString(_this->linux_side, pAddr, pszStr);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ToString, 16)
+void __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ToString(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, const SteamNetworkingIdentity * identity, char * buf, size_t cbBuf)
+{
+    TRACE("%p\n", _this);
+    cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ToString(_this->linux_side, identity, buf, cbBuf);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ParseString, 12)
+bool __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ParseString(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this, SteamNetworkingIdentity * pIdentity, const char * pszStr)
+{
+    TRACE("%p\n", _this);
+    return cppISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ParseString(_this->linux_side, pIdentity, pszStr);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamNetworkingUtils_SteamNetworkingUtils003_destructor, 4)
+void __thiscall winISteamNetworkingUtils_SteamNetworkingUtils003_destructor(winISteamNetworkingUtils_SteamNetworkingUtils003 *_this)
+{/* never called */}
+
+extern vtable_ptr winISteamNetworkingUtils_SteamNetworkingUtils003_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamNetworkingUtils_SteamNetworkingUtils003,
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_AllocateMessage)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetRelayNetworkStatus)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalPingLocation)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeBetweenTwoLocations)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_EstimatePingTimeFromLocalHost)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_ConvertPingLocationToString)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_ParsePingLocationString)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_CheckPingDataUpToDate)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetPingToDataCenter)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetDirectPingToPOP)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPCount)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetPOPList)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetLocalTimestamp)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_SetDebugOutputFunction)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_SetConfigValue)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValue)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetConfigValueInfo)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_GetFirstConfigValue)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ToString)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIPAddr_ParseString)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ToString)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_SteamNetworkingIdentity_ParseString)
+        VTABLE_ADD_FUNC(winISteamNetworkingUtils_SteamNetworkingUtils003_destructor)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamNetworkingUtils_SteamNetworkingUtils003 *create_winISteamNetworkingUtils_SteamNetworkingUtils003(void *linux_side)
+{
+    winISteamNetworkingUtils_SteamNetworkingUtils003 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamNetworkingUtils_SteamNetworkingUtils003));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamNetworkingUtils_SteamNetworkingUtils003_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamNetworkingUtils_SteamNetworkingUtils002.h"
 
 typedef struct __winISteamNetworkingUtils_SteamNetworkingUtils002 {

lsteamclient/winISteamParties.c

@@ -37,7 +37,7 @@ PartyBeaconID_t __thiscall winISteamParties_SteamParties002_GetBeaconByIndex(win
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamParties_SteamParties002_GetBeaconDetails, 28)
-bool __thiscall winISteamParties_SteamParties002_GetBeaconDetails(winISteamParties_SteamParties002 *_this, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, winSteamPartyBeaconLocation_t_146 * pLocation, char * pchMetadata, int cchMetadata)
+bool __thiscall winISteamParties_SteamParties002_GetBeaconDetails(winISteamParties_SteamParties002 *_this, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, winSteamPartyBeaconLocation_t_147 * pLocation, char * pchMetadata, int cchMetadata)
 {
     TRACE("%p\n", _this);
     return cppISteamParties_SteamParties002_GetBeaconDetails(_this->linux_side, ulBeaconID, pSteamIDBeaconOwner, pLocation, pchMetadata, cchMetadata);
@@ -58,14 +58,14 @@ bool __thiscall winISteamParties_SteamParties002_GetNumAvailableBeaconLocations(
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamParties_SteamParties002_GetAvailableBeaconLocations, 12)
-bool __thiscall winISteamParties_SteamParties002_GetAvailableBeaconLocations(winISteamParties_SteamParties002 *_this, winSteamPartyBeaconLocation_t_146 * pLocationList, uint32 uMaxNumLocations)
+bool __thiscall winISteamParties_SteamParties002_GetAvailableBeaconLocations(winISteamParties_SteamParties002 *_this, winSteamPartyBeaconLocation_t_147 * pLocationList, uint32 uMaxNumLocations)
 {
     TRACE("%p\n", _this);
     return cppISteamParties_SteamParties002_GetAvailableBeaconLocations(_this->linux_side, pLocationList, uMaxNumLocations);
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamParties_SteamParties002_CreateBeacon, 20)
-SteamAPICall_t __thiscall winISteamParties_SteamParties002_CreateBeacon(winISteamParties_SteamParties002 *_this, uint32 unOpenSlots, winSteamPartyBeaconLocation_t_146 * pBeaconLocation, const char * pchConnectString, const char * pchMetadata)
+SteamAPICall_t __thiscall winISteamParties_SteamParties002_CreateBeacon(winISteamParties_SteamParties002 *_this, uint32 unOpenSlots, winSteamPartyBeaconLocation_t_147 * pBeaconLocation, const char * pchConnectString, const char * pchMetadata)
 {
     TRACE("%p\n", _this);
     return cppISteamParties_SteamParties002_CreateBeacon(_this->linux_side, unOpenSlots, pBeaconLocation, pchConnectString, pchMetadata);
@@ -100,7 +100,7 @@ bool __thiscall winISteamParties_SteamParties002_DestroyBeacon(winISteamParties_
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamParties_SteamParties002_GetBeaconLocationData, 28)
-bool __thiscall winISteamParties_SteamParties002_GetBeaconLocationData(winISteamParties_SteamParties002 *_this, winSteamPartyBeaconLocation_t_146 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
+bool __thiscall winISteamParties_SteamParties002_GetBeaconLocationData(winISteamParties_SteamParties002 *_this, winSteamPartyBeaconLocation_t_147 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
 {
     TRACE("%p\n", _this);
     return cppISteamParties_SteamParties002_GetBeaconLocationData(_this->linux_side, BeaconLocation, eData, pchDataStringOut, cchDataStringOut);

lsteamclient/winISteamRemotePlay.c

@@ -30,14 +30,14 @@ uint32 __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSe
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID, 8)
-uint32 __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, int iSessionIndex)
+RemotePlaySessionID_t __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, int iSessionIndex)
 {
     TRACE("%p\n", _this);
     return cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionID(_this->linux_side, iSessionIndex);
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID, 12)
-CSteamID *__thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, CSteamID *_r, uint32 unSessionID)
+CSteamID *__thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, CSteamID *_r, RemotePlaySessionID_t unSessionID)
 {
     TRACE("%p\n", _this);
     *_r = cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionSteamID(_this->linux_side, unSessionID);
@@ -45,26 +45,33 @@ CSteamID *__thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_Ge
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName, 8)
-const char * __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, uint32 unSessionID)
+const char * __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, RemotePlaySessionID_t unSessionID)
 {
     TRACE("%p\n", _this);
     return cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName(_this->linux_side, unSessionID);
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor, 8)
-ESteamDeviceFormFactor __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, uint32 unSessionID)
+ESteamDeviceFormFactor __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, RemotePlaySessionID_t unSessionID)
 {
     TRACE("%p\n", _this);
     return cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor(_this->linux_side, unSessionID);
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution, 16)
-bool __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, uint32 unSessionID, int * pnResolutionX, int * pnResolutionY)
+bool __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, RemotePlaySessionID_t unSessionID, int * pnResolutionX, int * pnResolutionY)
 {
     TRACE("%p\n", _this);
     return cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution(_this->linux_side, unSessionID, pnResolutionX, pnResolutionY);
 }
 
+DEFINE_THISCALL_WRAPPER(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BSendRemotePlayTogetherInvite, 12)
+bool __thiscall winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BSendRemotePlayTogetherInvite(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001 *_this, CSteamID steamIDFriend)
+{
+    TRACE("%p\n", _this);
+    return cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BSendRemotePlayTogetherInvite(_this->linux_side, steamIDFriend);
+}
+
 extern vtable_ptr winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_vtable;
 
 #ifndef __GNUC__
@@ -77,6 +84,7 @@ void __asm_dummy_vtables(void) {
         VTABLE_ADD_FUNC(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientName)
         VTABLE_ADD_FUNC(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionClientFormFactor)
         VTABLE_ADD_FUNC(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BGetSessionClientResolution)
+        VTABLE_ADD_FUNC(winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_BSendRemotePlayTogetherInvite)
     );
 #ifndef __GNUC__
 }

lsteamclient/winISteamUGC.c

@@ -15,6 +15,681 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamUGC_STEAMUGC_INTERFACE_VERSION014.h"
+
+typedef struct __winISteamUGC_STEAMUGC_INTERFACE_VERSION014 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamUGC_STEAMUGC_INTERFACE_VERSION014;
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUserUGCRequest, 32)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUserUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUserUGCRequest(_this->linux_side, unAccountID, eListType, eMatchingUGCType, eSortOrder, nCreatorAppID, nConsumerAppID, unPage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest, 24)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest(_this->linux_side, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, unPage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest_2, 24)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest_2(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest_2(_this->linux_side, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUGCDetailsRequest, 12)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUGCDetailsRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUGCDetailsRequest(_this->linux_side, pvecPublishedFileID, unNumPublishedFileIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SendQueryUGCRequest, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SendQueryUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SendQueryUGCRequest(_this->linux_side, handle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCResult, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCResult(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, winSteamUGCDetails_t_147 * pDetails)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCResult(_this->linux_side, handle, index, pDetails);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCPreviewURL, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCPreviewURL(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, char * pchURL, uint32 cchURLSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCPreviewURL(_this->linux_side, handle, index, pchURL, cchURLSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCMetadata, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCMetadata(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, char * pchMetadata, uint32 cchMetadatasize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCMetadata(_this->linux_side, handle, index, pchMetadata, cchMetadatasize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCChildren, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCChildren(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCChildren(_this->linux_side, handle, index, pvecPublishedFileID, cMaxEntries);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCStatistic, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCStatistic(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 * pStatValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCStatistic(_this->linux_side, handle, index, eStatType, pStatValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumAdditionalPreviews, 16)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumAdditionalPreviews(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumAdditionalPreviews(_this->linux_side, handle, index);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCAdditionalPreview, 40)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCAdditionalPreview(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, char * pchURLOrVideoID, uint32 cchURLSize, char * pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType * pPreviewType)
+{
+    bool path_result;
+    TRACE("%p\n", _this);
+    path_result = cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCAdditionalPreview(_this->linux_side, handle, index, previewIndex, pchURLOrVideoID, cchURLSize, pchOriginalFileName, cchOriginalFileNameSize, pPreviewType);
+    steamclient_unix_path_to_dos_path(path_result, pchURLOrVideoID, pchURLOrVideoID, cchURLSize, 1);
+    return path_result;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumKeyValueTags, 16)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumKeyValueTags(_this->linux_side, handle, index);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag, 36)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char * pchKey, uint32 cchKeySize, char * pchValue, uint32 cchValueSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag(_this->linux_side, handle, index, keyValueTagIndex, pchKey, cchKeySize, pchValue, cchValueSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag_2, 28)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag_2(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 index, const char * pchKey, char * pchValue, uint32 cchValueSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag_2(_this->linux_side, handle, index, pchKey, pchValue, cchValueSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_ReleaseQueryUGCRequest, 12)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_ReleaseQueryUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_ReleaseQueryUGCRequest(_this->linux_side, handle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTag, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, const char * pTagName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTag(_this->linux_side, handle, pTagName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTagGroup, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTagGroup(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, const SteamParamStringArray_t * pTagGroups)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTagGroup(_this->linux_side, handle, pTagGroups);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddExcludedTag, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddExcludedTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, const char * pTagName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddExcludedTag(_this->linux_side, handle, pTagName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnOnlyIDs, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnOnlyIDs(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bReturnOnlyIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnOnlyIDs(_this->linux_side, handle, bReturnOnlyIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnKeyValueTags, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bReturnKeyValueTags)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnKeyValueTags(_this->linux_side, handle, bReturnKeyValueTags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnLongDescription, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnLongDescription(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bReturnLongDescription)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnLongDescription(_this->linux_side, handle, bReturnLongDescription);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnMetadata, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnMetadata(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bReturnMetadata)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnMetadata(_this->linux_side, handle, bReturnMetadata);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnChildren, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnChildren(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bReturnChildren)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnChildren(_this->linux_side, handle, bReturnChildren);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnAdditionalPreviews, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnAdditionalPreviews(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bReturnAdditionalPreviews)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnAdditionalPreviews(_this->linux_side, handle, bReturnAdditionalPreviews);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnTotalOnly, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnTotalOnly(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bReturnTotalOnly)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnTotalOnly(_this->linux_side, handle, bReturnTotalOnly);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnPlaytimeStats, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnPlaytimeStats(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 unDays)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnPlaytimeStats(_this->linux_side, handle, unDays);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetLanguage, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetLanguage(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, const char * pchLanguage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetLanguage(_this->linux_side, handle, pchLanguage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowCachedResponse, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowCachedResponse(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 unMaxAgeSeconds)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowCachedResponse(_this->linux_side, handle, unMaxAgeSeconds);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetCloudFileNameFilter, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetCloudFileNameFilter(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, const char * pMatchCloudFileName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetCloudFileNameFilter(_this->linux_side, handle, pMatchCloudFileName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetMatchAnyTag, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetMatchAnyTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, bool bMatchAnyTag)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetMatchAnyTag(_this->linux_side, handle, bMatchAnyTag);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetSearchText, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetSearchText(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, const char * pSearchText)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetSearchText(_this->linux_side, handle, pSearchText);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetRankedByTrendDays, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetRankedByTrendDays(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, uint32 unDays)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetRankedByTrendDays(_this->linux_side, handle, unDays);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredKeyValueTag, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredKeyValueTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCQueryHandle_t handle, const char * pKey, const char * pValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredKeyValueTag(_this->linux_side, handle, pKey, pValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RequestUGCDetails, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RequestUGCDetails(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RequestUGCDetails(_this->linux_side, nPublishedFileID, unMaxAgeSeconds);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, AppId_t nConsumerAppId, EWorkshopFileType eFileType)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateItem(_this->linux_side, nConsumerAppId, eFileType);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartItemUpdate, 16)
+UGCUpdateHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartItemUpdate(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartItemUpdate(_this->linux_side, nConsumerAppId, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTitle, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTitle(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pchTitle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTitle(_this->linux_side, handle, pchTitle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemDescription, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemDescription(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pchDescription)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemDescription(_this->linux_side, handle, pchDescription);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemUpdateLanguage, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemUpdateLanguage(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pchLanguage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemUpdateLanguage(_this->linux_side, handle, pchLanguage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemMetadata, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemMetadata(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pchMetaData)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemMetadata(_this->linux_side, handle, pchMetaData);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemVisibility, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemVisibility(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemVisibility(_this->linux_side, handle, eVisibility);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTags, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t * pTags)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTags(_this->linux_side, updateHandle, pTags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemContent, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemContent(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pszContentFolder)
+{
+    char lin_pszContentFolder[PATH_MAX];
+    steamclient_dos_path_to_unix_path(pszContentFolder, lin_pszContentFolder, 0);
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemContent(_this->linux_side, handle, pszContentFolder ? lin_pszContentFolder : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemPreview, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemPreview(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pszPreviewFile)
+{
+    char lin_pszPreviewFile[PATH_MAX];
+    steamclient_dos_path_to_unix_path(pszPreviewFile, lin_pszPreviewFile, 0);
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemPreview(_this->linux_side, handle, pszPreviewFile ? lin_pszPreviewFile : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowLegacyUpload, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowLegacyUpload(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, bool bAllowLegacyUpload)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowLegacyUpload(_this->linux_side, handle, bAllowLegacyUpload);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAllItemKeyValueTags, 12)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAllItemKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAllItemKeyValueTags(_this->linux_side, handle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemKeyValueTags, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pchKey)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemKeyValueTags(_this->linux_side, handle, pchKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemKeyValueTag, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemKeyValueTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pchKey, const char * pchValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemKeyValueTag(_this->linux_side, handle, pchKey, pchValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewFile, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewFile(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pszPreviewFile, EItemPreviewType type)
+{
+    char lin_pszPreviewFile[PATH_MAX];
+    steamclient_dos_path_to_unix_path(pszPreviewFile, lin_pszPreviewFile, 0);
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewFile(_this->linux_side, handle, pszPreviewFile ? lin_pszPreviewFile : NULL, type);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewVideo, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewVideo(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pszVideoID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewVideo(_this->linux_side, handle, pszVideoID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewFile, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewFile(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, uint32 index, const char * pszPreviewFile)
+{
+    char lin_pszPreviewFile[PATH_MAX];
+    steamclient_dos_path_to_unix_path(pszPreviewFile, lin_pszPreviewFile, 0);
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewFile(_this->linux_side, handle, index, pszPreviewFile ? lin_pszPreviewFile : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewVideo, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewVideo(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, uint32 index, const char * pszVideoID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewVideo(_this->linux_side, handle, index, pszVideoID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemPreview, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemPreview(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, uint32 index)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemPreview(_this->linux_side, handle, index);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubmitItemUpdate, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubmitItemUpdate(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, const char * pchChangeNote)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubmitItemUpdate(_this->linux_side, handle, pchChangeNote);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemUpdateProgress, 20)
+EItemUpdateStatus __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemUpdateProgress(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, UGCUpdateHandle_t handle, uint64 * punBytesProcessed, uint64 * punBytesTotal)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemUpdateProgress(_this->linux_side, handle, punBytesProcessed, punBytesTotal);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetUserItemVote, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetUserItemVote(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID, bool bVoteUp)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetUserItemVote(_this->linux_side, nPublishedFileID, bVoteUp);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetUserItemVote, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetUserItemVote(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetUserItemVote(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemToFavorites, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemToFavorites(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, AppId_t nAppId, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemToFavorites(_this->linux_side, nAppId, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemFromFavorites, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemFromFavorites(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, AppId_t nAppId, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemFromFavorites(_this->linux_side, nAppId, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubscribeItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubscribeItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubscribeItem(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UnsubscribeItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UnsubscribeItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_UnsubscribeItem(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetNumSubscribedItems, 4)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetNumSubscribedItems(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetNumSubscribedItems(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetSubscribedItems, 12)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetSubscribedItems(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetSubscribedItems(_this->linux_side, pvecPublishedFileID, cMaxEntries);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemState, 12)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemState(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemState(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemInstallInfo, 28)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemInstallInfo(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID, uint64 * punSizeOnDisk, char * pchFolder, uint32 cchFolderSize, uint32 * punTimeStamp)
+{
+    bool path_result;
+    TRACE("%p\n", _this);
+    path_result = cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemInstallInfo(_this->linux_side, nPublishedFileID, punSizeOnDisk, pchFolder, cchFolderSize, punTimeStamp);
+    steamclient_unix_path_to_dos_path(path_result, pchFolder, pchFolder, cchFolderSize, 0);
+    return path_result;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemDownloadInfo, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemDownloadInfo(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID, uint64 * punBytesDownloaded, uint64 * punBytesTotal)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemDownloadInfo(_this->linux_side, nPublishedFileID, punBytesDownloaded, punBytesTotal);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_DownloadItem, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_DownloadItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID, bool bHighPriority)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_DownloadItem(_this->linux_side, nPublishedFileID, bHighPriority);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_BInitWorkshopForGameServer, 12)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_BInitWorkshopForGameServer(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, DepotId_t unWorkshopDepotID, const char * pszFolder)
+{
+    char lin_pszFolder[PATH_MAX];
+    steamclient_dos_path_to_unix_path(pszFolder, lin_pszFolder, 0);
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_BInitWorkshopForGameServer(_this->linux_side, unWorkshopDepotID, pszFolder ? lin_pszFolder : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SuspendDownloads, 8)
+void __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SuspendDownloads(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, bool bSuspend)
+{
+    TRACE("%p\n", _this);
+    cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_SuspendDownloads(_this->linux_side, bSuspend);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartPlaytimeTracking, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartPlaytimeTracking(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartPlaytimeTracking(_this->linux_side, pvecPublishedFileID, unNumPublishedFileIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTracking, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTracking(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTracking(_this->linux_side, pvecPublishedFileID, unNumPublishedFileIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTrackingForAllItems, 4)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTrackingForAllItems(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTrackingForAllItems(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddDependency, 20)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddDependency(_this->linux_side, nParentPublishedFileID, nChildPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveDependency, 20)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveDependency(_this->linux_side, nParentPublishedFileID, nChildPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddAppDependency, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddAppDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID, AppId_t nAppID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddAppDependency(_this->linux_side, nPublishedFileID, nAppID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAppDependency, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAppDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID, AppId_t nAppID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAppDependency(_this->linux_side, nPublishedFileID, nAppID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetAppDependencies, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetAppDependencies(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetAppDependencies(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_DeleteItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION014_DeleteItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION014_DeleteItem(_this->linux_side, nPublishedFileID);
+}
+
+extern vtable_ptr winISteamUGC_STEAMUGC_INTERFACE_VERSION014_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamUGC_STEAMUGC_INTERFACE_VERSION014,
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUserUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest_2)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryAllUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateQueryUGCDetailsRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SendQueryUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCResult)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCPreviewURL)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCMetadata)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCChildren)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCStatistic)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumAdditionalPreviews)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCAdditionalPreview)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCNumKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag_2)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetQueryUGCKeyValueTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_ReleaseQueryUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredTagGroup)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddExcludedTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnOnlyIDs)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnLongDescription)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnMetadata)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnChildren)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnAdditionalPreviews)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnTotalOnly)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetReturnPlaytimeStats)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetLanguage)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowCachedResponse)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetCloudFileNameFilter)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetMatchAnyTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetSearchText)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetRankedByTrendDays)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddRequiredKeyValueTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RequestUGCDetails)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_CreateItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartItemUpdate)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTitle)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemDescription)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemUpdateLanguage)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemMetadata)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemVisibility)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemContent)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetItemPreview)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetAllowLegacyUpload)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAllItemKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemKeyValueTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewFile)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemPreviewVideo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewFile)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UpdateItemPreviewVideo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemPreview)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubmitItemUpdate)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemUpdateProgress)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SetUserItemVote)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetUserItemVote)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddItemToFavorites)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveItemFromFavorites)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SubscribeItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_UnsubscribeItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetNumSubscribedItems)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetSubscribedItems)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemState)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemInstallInfo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetItemDownloadInfo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_DownloadItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_BInitWorkshopForGameServer)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_SuspendDownloads)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StartPlaytimeTracking)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTracking)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_StopPlaytimeTrackingForAllItems)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_AddAppDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_RemoveAppDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_GetAppDependencies)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION014_DeleteItem)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION014(void *linux_side)
+{
+    winISteamUGC_STEAMUGC_INTERFACE_VERSION014 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamUGC_STEAMUGC_INTERFACE_VERSION014));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamUGC_STEAMUGC_INTERFACE_VERSION014_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamUGC_STEAMUGC_INTERFACE_VERSION013.h"
 
 typedef struct __winISteamUGC_STEAMUGC_INTERFACE_VERSION013 {

lsteamclient/winISteamUserStats.c

@@ -233,7 +233,7 @@ SteamAPICall_t __thiscall winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry, 28)
-bool __thiscall winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry(winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011 *_this, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_146 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
+bool __thiscall winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry(winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011 *_this, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_147 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
 {
     TRACE("%p\n", _this);
     return cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011_GetDownloadedLeaderboardEntry(_this->linux_side, hSteamLeaderboardEntries, index, pLeaderboardEntry, pDetails, cDetailsMax);

lsteamclient/winISteamUtils.c

@@ -255,6 +255,13 @@ int __thiscall winISteamUtils_SteamUtils009_FilterText(winISteamUtils_SteamUtils
     return cppISteamUtils_SteamUtils009_FilterText(_this->linux_side, pchOutFilteredText, nByteSizeOutFilteredText, pchInputMessage, bLegalOnly);
 }
 
+DEFINE_THISCALL_WRAPPER(winISteamUtils_SteamUtils009_GetIPv6ConnectivityState, 8)
+ESteamIPv6ConnectivityState __thiscall winISteamUtils_SteamUtils009_GetIPv6ConnectivityState(winISteamUtils_SteamUtils009 *_this, ESteamIPv6ConnectivityProtocol eProtocol)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUtils_SteamUtils009_GetIPv6ConnectivityState(_this->linux_side, eProtocol);
+}
+
 extern vtable_ptr winISteamUtils_SteamUtils009_vtable;
 
 #ifndef __GNUC__
@@ -294,6 +301,7 @@ void __asm_dummy_vtables(void) {
         VTABLE_ADD_FUNC(winISteamUtils_SteamUtils009_IsSteamChinaLauncher)
         VTABLE_ADD_FUNC(winISteamUtils_SteamUtils009_InitFilterText)
         VTABLE_ADD_FUNC(winISteamUtils_SteamUtils009_FilterText)
+        VTABLE_ADD_FUNC(winISteamUtils_SteamUtils009_GetIPv6ConnectivityState)
     );
 #ifndef __GNUC__
 }

lsteamclient/win_constructors.h

@@ -1,4 +1,4 @@
-extern void *create_winISteamClient_SteamClient019(void *);
+extern void *create_winISteamClient_SteamClient020(void *);
 extern void *create_winISteamUser_SteamUser020(void *);
 extern void *create_winISteamFriends_SteamFriends017(void *);
 extern void *create_winISteamUtils_SteamUtils009(void *);
@@ -9,24 +9,30 @@ extern void *create_winISteamParties_SteamParties002(void *);
 extern void *create_winISteamRemoteStorage_STEAMREMOTESTORAGE_INTERFACE_VERSION014(void *);
 extern void *create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011(void *);
 extern void *create_winISteamApps_STEAMAPPS_INTERFACE_VERSION008(void *);
-extern void *create_winISteamNetworking_SteamNetworking005(void *);
+extern void *create_winISteamNetworking_SteamNetworking006(void *);
 extern void *create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003(void *);
 extern void *create_winISteamMusic_STEAMMUSIC_INTERFACE_VERSION001(void *);
 extern void *create_winISteamMusicRemote_STEAMMUSICREMOTE_INTERFACE_VERSION001(void *);
 extern void *create_winISteamHTTP_STEAMHTTP_INTERFACE_VERSION003(void *);
 extern void *create_winISteamInput_SteamInput001(void *);
 extern void *create_winISteamController_SteamController007(void *);
-extern void *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION013(void *);
+extern void *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION014(void *);
 extern void *create_winISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001(void *);
 extern void *create_winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_005(void *);
 extern void *create_winISteamInventory_STEAMINVENTORY_INTERFACE_V003(void *);
 extern void *create_winISteamVideo_STEAMVIDEO_INTERFACE_V002(void *);
 extern void *create_winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001(void *);
 extern void *create_winISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001(void *);
-extern void *create_winISteamGameServer_SteamGameServer012(void *);
+extern void *create_winISteamGameServer_SteamGameServer013(void *);
 extern void *create_winISteamGameServerStats_SteamGameServerStats001(void *);
 extern void *create_winISteamGameCoordinator_SteamGameCoordinator001(void *);
 extern void *create_winISteamParentalSettings_STEAMPARENTALSETTINGS_INTERFACE_VERSION001(void *);
+extern void *create_winISteamNetworkingSockets_SteamNetworkingSockets006(void *);
+extern void *create_winISteamNetworkingUtils_SteamNetworkingUtils003(void *);
+extern void *create_winISteamClient_SteamClient019(void *);
+extern void *create_winISteamNetworking_SteamNetworking005(void *);
+extern void *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION013(void *);
+extern void *create_winISteamGameServer_SteamGameServer012(void *);
 extern void *create_winISteamNetworkingSockets_SteamNetworkingSockets003(void *);
 extern void *create_winISteamNetworkingUtils_SteamNetworkingUtils002(void *);
 extern void *create_winISteamClient_SteamClient018(void *);

lsteamclient/win_constructors_table.dat

@@ -1,4 +1,4 @@
-    {"SteamClient019", &create_winISteamClient_SteamClient019},
+    {"SteamClient020", &create_winISteamClient_SteamClient020},
     {"SteamUser020", &create_winISteamUser_SteamUser020},
     {"SteamFriends017", &create_winISteamFriends_SteamFriends017},
     {"SteamUtils009", &create_winISteamUtils_SteamUtils009},
@@ -9,24 +9,30 @@
     {"STEAMREMOTESTORAGE_INTERFACE_VERSION014", &create_winISteamRemoteStorage_STEAMREMOTESTORAGE_INTERFACE_VERSION014},
     {"STEAMUSERSTATS_INTERFACE_VERSION011", &create_winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION011},
     {"STEAMAPPS_INTERFACE_VERSION008", &create_winISteamApps_STEAMAPPS_INTERFACE_VERSION008},
-    {"SteamNetworking005", &create_winISteamNetworking_SteamNetworking005},
+    {"SteamNetworking006", &create_winISteamNetworking_SteamNetworking006},
     {"STEAMSCREENSHOTS_INTERFACE_VERSION003", &create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003},
     {"STEAMMUSIC_INTERFACE_VERSION001", &create_winISteamMusic_STEAMMUSIC_INTERFACE_VERSION001},
     {"STEAMMUSICREMOTE_INTERFACE_VERSION001", &create_winISteamMusicRemote_STEAMMUSICREMOTE_INTERFACE_VERSION001},
     {"STEAMHTTP_INTERFACE_VERSION003", &create_winISteamHTTP_STEAMHTTP_INTERFACE_VERSION003},
     {"SteamInput001", &create_winISteamInput_SteamInput001},
     {"SteamController007", &create_winISteamController_SteamController007},
-    {"STEAMUGC_INTERFACE_VERSION013", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION013},
+    {"STEAMUGC_INTERFACE_VERSION014", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION014},
     {"STEAMAPPLIST_INTERFACE_VERSION001", &create_winISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001},
     {"STEAMHTMLSURFACE_INTERFACE_VERSION_005", &create_winISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_005},
     {"STEAMINVENTORY_INTERFACE_V003", &create_winISteamInventory_STEAMINVENTORY_INTERFACE_V003},
     {"STEAMVIDEO_INTERFACE_V002", &create_winISteamVideo_STEAMVIDEO_INTERFACE_V002},
     {"STEAMREMOTEPLAY_INTERFACE_VERSION001", &create_winISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001},
     {"STEAMAPPTICKET_INTERFACE_VERSION001", &create_winISteamAppTicket_STEAMAPPTICKET_INTERFACE_VERSION001},
-    {"SteamGameServer012", &create_winISteamGameServer_SteamGameServer012},
+    {"SteamGameServer013", &create_winISteamGameServer_SteamGameServer013},
     {"SteamGameServerStats001", &create_winISteamGameServerStats_SteamGameServerStats001},
     {"SteamGameCoordinator001", &create_winISteamGameCoordinator_SteamGameCoordinator001},
     {"STEAMPARENTALSETTINGS_INTERFACE_VERSION001", &create_winISteamParentalSettings_STEAMPARENTALSETTINGS_INTERFACE_VERSION001},
+    {"SteamNetworkingSockets006", &create_winISteamNetworkingSockets_SteamNetworkingSockets006},
+    {"SteamNetworkingUtils003", &create_winISteamNetworkingUtils_SteamNetworkingUtils003},
+    {"SteamClient019", &create_winISteamClient_SteamClient019},
+    {"SteamNetworking005", &create_winISteamNetworking_SteamNetworking005},
+    {"STEAMUGC_INTERFACE_VERSION013", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION013},
+    {"SteamGameServer012", &create_winISteamGameServer_SteamGameServer012},
     {"SteamNetworkingSockets003", &create_winISteamNetworkingSockets_SteamNetworkingSockets003},
     {"SteamNetworkingUtils002", &create_winISteamNetworkingUtils_SteamNetworkingUtils002},
     {"SteamClient018", &create_winISteamClient_SteamClient018},