lsteamclient: generate 1.51 support

lsteamclient/cb_converters.dat

@@ -127,8 +127,9 @@ case 0x000811ad: win_msg->m_cubParam = 8; win_msg->m_pubParam = HeapAlloc(GetPro
 case 0x000c11ad: win_msg->m_cubParam = 16; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_HTML_UpdateToolTip_t_16((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;
 #endif
 case 0x00141260: win_msg->m_cubParam = 24; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_SteamInventoryStartPurchaseResult_t_24((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;
-case 0x02c004c5: win_msg->m_cubParam = 712; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_SteamNetConnectionStatusChangedCallback_t_712((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;
+case 0x024004c5: win_msg->m_cubParam = 584; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_SteamNetConnectionStatusChangedCallback_t_584((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;
 case 0x002000d1: win_msg->m_cubParam = 40; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_GSReputation_t_40((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;
+case 0x02c004c5: win_msg->m_cubParam = 712; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_SteamNetConnectionStatusChangedCallback_t_712((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;
 case 0x00140835: win_msg->m_cubParam = 24; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_HTTPRequestCompleted_t_24((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;
 #ifdef __i386__
 case 0x001011a5: win_msg->m_cubParam = 16; win_msg->m_pubParam = HeapAlloc(GetProcessHeap(), 0, win_msg->m_cubParam); cb_HTML_ComboNeedsPaint_t_16((void*)lin_msg.m_pubParam, (void*)win_msg->m_pubParam); break;

lsteamclient/cb_converters.h

@@ -319,13 +319,17 @@ struct winSteamInventoryStartPurchaseResult_t_24;
 extern void cb_SteamInventoryStartPurchaseResult_t_24(const struct SteamInventoryStartPurchaseResult_t *l, struct winSteamInventoryStartPurchaseResult_t_24 *w);
 
 struct SteamNetConnectionStatusChangedCallback_t;
-struct winSteamNetConnectionStatusChangedCallback_t_712;
-extern void cb_SteamNetConnectionStatusChangedCallback_t_712(const struct SteamNetConnectionStatusChangedCallback_t *l, struct winSteamNetConnectionStatusChangedCallback_t_712 *w);
+struct winSteamNetConnectionStatusChangedCallback_t_584;
+extern void cb_SteamNetConnectionStatusChangedCallback_t_584(const struct SteamNetConnectionStatusChangedCallback_t *l, struct winSteamNetConnectionStatusChangedCallback_t_584 *w);
 
 struct GSReputation_t;
 struct winGSReputation_t_40;
 extern void cb_GSReputation_t_40(const struct GSReputation_t *l, struct winGSReputation_t_40 *w);
 
+struct SteamNetConnectionStatusChangedCallback_t;
+struct winSteamNetConnectionStatusChangedCallback_t_712;
+extern void cb_SteamNetConnectionStatusChangedCallback_t_712(const struct SteamNetConnectionStatusChangedCallback_t *l, struct winSteamNetConnectionStatusChangedCallback_t_712 *w);
+
 struct HTTPRequestCompleted_t;
 struct winHTTPRequestCompleted_t_24;
 extern void cb_HTTPRequestCompleted_t_24(const struct HTTPRequestCompleted_t *l, struct winHTTPRequestCompleted_t_24 *w);

lsteamclient/cb_getapi_sizes.dat

@@ -13,8 +13,8 @@ case 1111: /* LeaderboardUGCSet_t_16 */
     return 12;
 case 1112: /* PS3TrophiesInstalled_t_24 */
     return 20;
-case 1221: /* SteamNetConnectionStatusChangedCallback_t_712 */
-    return 704;
+case 1221: /* SteamNetConnectionStatusChangedCallback_t_584 */
+    return 576;
 case 1303: /* RemoteStorageAppSyncProgress_t_288 */
     return 280;
 case 1307: /* RemoteStorageFileShareResult_t_280 */
@@ -143,8 +143,8 @@ case 1111: /* LeaderboardUGCSet_t_16 */
     return 12;
 case 1112: /* PS3TrophiesInstalled_t_24 */
     return 20;
-case 1221: /* SteamNetConnectionStatusChangedCallback_t_712 */
-    return 704;
+case 1221: /* SteamNetConnectionStatusChangedCallback_t_584 */
+    return 576;
 case 1303: /* RemoteStorageAppSyncProgress_t_288 */
     return 280;
 case 1307: /* RemoteStorageFileShareResult_t_280 */

lsteamclient/cb_getapi_table.dat

@@ -44,6 +44,7 @@ case 1112:
 case 1221:
     switch(callback_len){
     default:
+    case 584: cb_SteamNetConnectionStatusChangedCallback_t_584(lin_callback, callback); break;
     case 712: cb_SteamNetConnectionStatusChangedCallback_t_712(lin_callback, callback); break;
     }
     break;
@@ -440,6 +441,7 @@ case 1112:
 case 1221:
     switch(callback_len){
     default:
+    case 584: cb_SteamNetConnectionStatusChangedCallback_t_584(lin_callback, callback); break;
     case 712: cb_SteamNetConnectionStatusChangedCallback_t_712(lin_callback, callback); break;
     }
     break;

lsteamclient/cppISteamAppList_STEAMAPPLIST_INTERFACE_VERSION001.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamappticket.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamappticket.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamApps_STEAMAPPS_INTERFACE_VERSION008.h"
 bool cppISteamApps_STEAMAPPS_INTERFACE_VERSION008_BIsSubscribed(void *linux_side)

lsteamclient/cppISteamClient_SteamClient020.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamClient_SteamClient020.h"
 HSteamPipe cppISteamClient_SteamClient020_CreateSteamPipe(void *linux_side)

lsteamclient/cppISteamController_SteamController008.cpp

@@ -0,0 +1,186 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_151
+#include "struct_converters.h"
+#include "cppISteamController_SteamController008.h"
+bool cppISteamController_SteamController008_Init(void *linux_side)
+{
+    return ((ISteamController*)linux_side)->Init();
+}
+
+bool cppISteamController_SteamController008_Shutdown(void *linux_side)
+{
+    return ((ISteamController*)linux_side)->Shutdown();
+}
+
+void cppISteamController_SteamController008_RunFrame(void *linux_side)
+{
+    ((ISteamController*)linux_side)->RunFrame();
+}
+
+int cppISteamController_SteamController008_GetConnectedControllers(void *linux_side, ControllerHandle_t * handlesOut)
+{
+    return ((ISteamController*)linux_side)->GetConnectedControllers((ControllerHandle_t *)handlesOut);
+}
+
+ControllerActionSetHandle_t cppISteamController_SteamController008_GetActionSetHandle(void *linux_side, const char * pszActionSetName)
+{
+    return ((ISteamController*)linux_side)->GetActionSetHandle((const char *)pszActionSetName);
+}
+
+void cppISteamController_SteamController008_ActivateActionSet(void *linux_side, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle)
+{
+    ((ISteamController*)linux_side)->ActivateActionSet((ControllerHandle_t)controllerHandle, (ControllerActionSetHandle_t)actionSetHandle);
+}
+
+ControllerActionSetHandle_t cppISteamController_SteamController008_GetCurrentActionSet(void *linux_side, ControllerHandle_t controllerHandle)
+{
+    return ((ISteamController*)linux_side)->GetCurrentActionSet((ControllerHandle_t)controllerHandle);
+}
+
+void cppISteamController_SteamController008_ActivateActionSetLayer(void *linux_side, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
+{
+    ((ISteamController*)linux_side)->ActivateActionSetLayer((ControllerHandle_t)controllerHandle, (ControllerActionSetHandle_t)actionSetLayerHandle);
+}
+
+void cppISteamController_SteamController008_DeactivateActionSetLayer(void *linux_side, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
+{
+    ((ISteamController*)linux_side)->DeactivateActionSetLayer((ControllerHandle_t)controllerHandle, (ControllerActionSetHandle_t)actionSetLayerHandle);
+}
+
+void cppISteamController_SteamController008_DeactivateAllActionSetLayers(void *linux_side, ControllerHandle_t controllerHandle)
+{
+    ((ISteamController*)linux_side)->DeactivateAllActionSetLayers((ControllerHandle_t)controllerHandle);
+}
+
+int cppISteamController_SteamController008_GetActiveActionSetLayers(void *linux_side, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t * handlesOut)
+{
+    return ((ISteamController*)linux_side)->GetActiveActionSetLayers((ControllerHandle_t)controllerHandle, (ControllerActionSetHandle_t *)handlesOut);
+}
+
+ControllerDigitalActionHandle_t cppISteamController_SteamController008_GetDigitalActionHandle(void *linux_side, const char * pszActionName)
+{
+    return ((ISteamController*)linux_side)->GetDigitalActionHandle((const char *)pszActionName);
+}
+
+InputDigitalActionData_t cppISteamController_SteamController008_GetDigitalActionData(void *linux_side, ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle)
+{
+    return ((ISteamController*)linux_side)->GetDigitalActionData((ControllerHandle_t)controllerHandle, (ControllerDigitalActionHandle_t)digitalActionHandle);
+}
+
+int cppISteamController_SteamController008_GetDigitalActionOrigins(void *linux_side, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, EControllerActionOrigin * originsOut)
+{
+    return ((ISteamController*)linux_side)->GetDigitalActionOrigins((ControllerHandle_t)controllerHandle, (ControllerActionSetHandle_t)actionSetHandle, (ControllerDigitalActionHandle_t)digitalActionHandle, (EControllerActionOrigin *)originsOut);
+}
+
+ControllerAnalogActionHandle_t cppISteamController_SteamController008_GetAnalogActionHandle(void *linux_side, const char * pszActionName)
+{
+    return ((ISteamController*)linux_side)->GetAnalogActionHandle((const char *)pszActionName);
+}
+
+InputAnalogActionData_t cppISteamController_SteamController008_GetAnalogActionData(void *linux_side, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle)
+{
+    return ((ISteamController*)linux_side)->GetAnalogActionData((ControllerHandle_t)controllerHandle, (ControllerAnalogActionHandle_t)analogActionHandle);
+}
+
+int cppISteamController_SteamController008_GetAnalogActionOrigins(void *linux_side, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, EControllerActionOrigin * originsOut)
+{
+    return ((ISteamController*)linux_side)->GetAnalogActionOrigins((ControllerHandle_t)controllerHandle, (ControllerActionSetHandle_t)actionSetHandle, (ControllerAnalogActionHandle_t)analogActionHandle, (EControllerActionOrigin *)originsOut);
+}
+
+const char * cppISteamController_SteamController008_GetGlyphForActionOrigin(void *linux_side, EControllerActionOrigin eOrigin)
+{
+    return ((ISteamController*)linux_side)->GetGlyphForActionOrigin((EControllerActionOrigin)eOrigin);
+}
+
+const char * cppISteamController_SteamController008_GetStringForActionOrigin(void *linux_side, EControllerActionOrigin eOrigin)
+{
+    return ((ISteamController*)linux_side)->GetStringForActionOrigin((EControllerActionOrigin)eOrigin);
+}
+
+void cppISteamController_SteamController008_StopAnalogActionMomentum(void *linux_side, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction)
+{
+    ((ISteamController*)linux_side)->StopAnalogActionMomentum((ControllerHandle_t)controllerHandle, (ControllerAnalogActionHandle_t)eAction);
+}
+
+InputMotionData_t cppISteamController_SteamController008_GetMotionData(void *linux_side, ControllerHandle_t controllerHandle)
+{
+    return ((ISteamController*)linux_side)->GetMotionData((ControllerHandle_t)controllerHandle);
+}
+
+void cppISteamController_SteamController008_TriggerHapticPulse(void *linux_side, ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec)
+{
+    ((ISteamController*)linux_side)->TriggerHapticPulse((ControllerHandle_t)controllerHandle, (ESteamControllerPad)eTargetPad, (unsigned short)usDurationMicroSec);
+}
+
+void cppISteamController_SteamController008_TriggerRepeatedHapticPulse(void *linux_side, ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags)
+{
+    ((ISteamController*)linux_side)->TriggerRepeatedHapticPulse((ControllerHandle_t)controllerHandle, (ESteamControllerPad)eTargetPad, (unsigned short)usDurationMicroSec, (unsigned short)usOffMicroSec, (unsigned short)unRepeat, (unsigned int)nFlags);
+}
+
+void cppISteamController_SteamController008_TriggerVibration(void *linux_side, ControllerHandle_t controllerHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed)
+{
+    ((ISteamController*)linux_side)->TriggerVibration((ControllerHandle_t)controllerHandle, (unsigned short)usLeftSpeed, (unsigned short)usRightSpeed);
+}
+
+void cppISteamController_SteamController008_SetLEDColor(void *linux_side, ControllerHandle_t controllerHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags)
+{
+    ((ISteamController*)linux_side)->SetLEDColor((ControllerHandle_t)controllerHandle, (uint8)nColorR, (uint8)nColorG, (uint8)nColorB, (unsigned int)nFlags);
+}
+
+bool cppISteamController_SteamController008_ShowBindingPanel(void *linux_side, ControllerHandle_t controllerHandle)
+{
+    return ((ISteamController*)linux_side)->ShowBindingPanel((ControllerHandle_t)controllerHandle);
+}
+
+ESteamInputType cppISteamController_SteamController008_GetInputTypeForHandle(void *linux_side, ControllerHandle_t controllerHandle)
+{
+    return ((ISteamController*)linux_side)->GetInputTypeForHandle((ControllerHandle_t)controllerHandle);
+}
+
+ControllerHandle_t cppISteamController_SteamController008_GetControllerForGamepadIndex(void *linux_side, int nIndex)
+{
+    return ((ISteamController*)linux_side)->GetControllerForGamepadIndex((int)nIndex);
+}
+
+int cppISteamController_SteamController008_GetGamepadIndexForController(void *linux_side, ControllerHandle_t ulControllerHandle)
+{
+    return ((ISteamController*)linux_side)->GetGamepadIndexForController((ControllerHandle_t)ulControllerHandle);
+}
+
+const char * cppISteamController_SteamController008_GetStringForXboxOrigin(void *linux_side, EXboxOrigin eOrigin)
+{
+    return ((ISteamController*)linux_side)->GetStringForXboxOrigin((EXboxOrigin)eOrigin);
+}
+
+const char * cppISteamController_SteamController008_GetGlyphForXboxOrigin(void *linux_side, EXboxOrigin eOrigin)
+{
+    return ((ISteamController*)linux_side)->GetGlyphForXboxOrigin((EXboxOrigin)eOrigin);
+}
+
+EControllerActionOrigin cppISteamController_SteamController008_GetActionOriginFromXboxOrigin(void *linux_side, ControllerHandle_t controllerHandle, EXboxOrigin eOrigin)
+{
+    return ((ISteamController*)linux_side)->GetActionOriginFromXboxOrigin((ControllerHandle_t)controllerHandle, (EXboxOrigin)eOrigin);
+}
+
+EControllerActionOrigin cppISteamController_SteamController008_TranslateActionOrigin(void *linux_side, ESteamInputType eDestinationInputType, EControllerActionOrigin eSourceOrigin)
+{
+    return ((ISteamController*)linux_side)->TranslateActionOrigin((ESteamInputType)eDestinationInputType, (EControllerActionOrigin)eSourceOrigin);
+}
+
+bool cppISteamController_SteamController008_GetControllerBindingRevision(void *linux_side, ControllerHandle_t controllerHandle, int * pMajor, int * pMinor)
+{
+    return ((ISteamController*)linux_side)->GetControllerBindingRevision((ControllerHandle_t)controllerHandle, (int *)pMajor, (int *)pMinor);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamController_SteamController008.h

@@ -0,0 +1,34 @@
+extern bool cppISteamController_SteamController008_Init(void *);
+extern bool cppISteamController_SteamController008_Shutdown(void *);
+extern void cppISteamController_SteamController008_RunFrame(void *);
+extern int cppISteamController_SteamController008_GetConnectedControllers(void *, ControllerHandle_t *);
+extern ControllerActionSetHandle_t cppISteamController_SteamController008_GetActionSetHandle(void *, const char *);
+extern void cppISteamController_SteamController008_ActivateActionSet(void *, ControllerHandle_t, ControllerActionSetHandle_t);
+extern ControllerActionSetHandle_t cppISteamController_SteamController008_GetCurrentActionSet(void *, ControllerHandle_t);
+extern void cppISteamController_SteamController008_ActivateActionSetLayer(void *, ControllerHandle_t, ControllerActionSetHandle_t);
+extern void cppISteamController_SteamController008_DeactivateActionSetLayer(void *, ControllerHandle_t, ControllerActionSetHandle_t);
+extern void cppISteamController_SteamController008_DeactivateAllActionSetLayers(void *, ControllerHandle_t);
+extern int cppISteamController_SteamController008_GetActiveActionSetLayers(void *, ControllerHandle_t, ControllerActionSetHandle_t *);
+extern ControllerDigitalActionHandle_t cppISteamController_SteamController008_GetDigitalActionHandle(void *, const char *);
+extern InputDigitalActionData_t cppISteamController_SteamController008_GetDigitalActionData(void *, ControllerHandle_t, ControllerDigitalActionHandle_t);
+extern int cppISteamController_SteamController008_GetDigitalActionOrigins(void *, ControllerHandle_t, ControllerActionSetHandle_t, ControllerDigitalActionHandle_t, EControllerActionOrigin *);
+extern ControllerAnalogActionHandle_t cppISteamController_SteamController008_GetAnalogActionHandle(void *, const char *);
+extern InputAnalogActionData_t cppISteamController_SteamController008_GetAnalogActionData(void *, ControllerHandle_t, ControllerAnalogActionHandle_t);
+extern int cppISteamController_SteamController008_GetAnalogActionOrigins(void *, ControllerHandle_t, ControllerActionSetHandle_t, ControllerAnalogActionHandle_t, EControllerActionOrigin *);
+extern const char * cppISteamController_SteamController008_GetGlyphForActionOrigin(void *, EControllerActionOrigin);
+extern const char * cppISteamController_SteamController008_GetStringForActionOrigin(void *, EControllerActionOrigin);
+extern void cppISteamController_SteamController008_StopAnalogActionMomentum(void *, ControllerHandle_t, ControllerAnalogActionHandle_t);
+extern InputMotionData_t cppISteamController_SteamController008_GetMotionData(void *, ControllerHandle_t);
+extern void cppISteamController_SteamController008_TriggerHapticPulse(void *, ControllerHandle_t, ESteamControllerPad, unsigned short);
+extern void cppISteamController_SteamController008_TriggerRepeatedHapticPulse(void *, ControllerHandle_t, ESteamControllerPad, unsigned short, unsigned short, unsigned short, unsigned int);
+extern void cppISteamController_SteamController008_TriggerVibration(void *, ControllerHandle_t, unsigned short, unsigned short);
+extern void cppISteamController_SteamController008_SetLEDColor(void *, ControllerHandle_t, uint8, uint8, uint8, unsigned int);
+extern bool cppISteamController_SteamController008_ShowBindingPanel(void *, ControllerHandle_t);
+extern ESteamInputType cppISteamController_SteamController008_GetInputTypeForHandle(void *, ControllerHandle_t);
+extern ControllerHandle_t cppISteamController_SteamController008_GetControllerForGamepadIndex(void *, int);
+extern int cppISteamController_SteamController008_GetGamepadIndexForController(void *, ControllerHandle_t);
+extern const char * cppISteamController_SteamController008_GetStringForXboxOrigin(void *, EXboxOrigin);
+extern const char * cppISteamController_SteamController008_GetGlyphForXboxOrigin(void *, EXboxOrigin);
+extern EControllerActionOrigin cppISteamController_SteamController008_GetActionOriginFromXboxOrigin(void *, ControllerHandle_t, EXboxOrigin);
+extern EControllerActionOrigin cppISteamController_SteamController008_TranslateActionOrigin(void *, ESteamInputType, EControllerActionOrigin);
+extern bool cppISteamController_SteamController008_GetControllerBindingRevision(void *, ControllerHandle_t, int *, int *);

lsteamclient/cppISteamFriends_SteamFriends017.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamFriends_SteamFriends017.h"
 const char * cppISteamFriends_SteamFriends017_GetPersonaName(void *linux_side)
@@ -386,6 +386,11 @@ bool cppISteamFriends_SteamFriends017_RegisterProtocolInOverlayBrowser(void *lin
     return ((ISteamFriends*)linux_side)->RegisterProtocolInOverlayBrowser((const char *)pchProtocol);
 }
 
+void cppISteamFriends_SteamFriends017_ActivateGameOverlayInviteDialogConnectString(void *linux_side, const char * pchConnectString)
+{
+    ((ISteamFriends*)linux_side)->ActivateGameOverlayInviteDialogConnectString((const char *)pchConnectString);
+}
+
 #ifdef __cplusplus
 }
 #endif

lsteamclient/cppISteamFriends_SteamFriends017.h

@@ -73,3 +73,4 @@ extern bool cppISteamFriends_SteamFriends017_IsClanOfficialGameGroup(void *, CSt
 extern int cppISteamFriends_SteamFriends017_GetNumChatsWithUnreadPriorityMessages(void *);
 extern void cppISteamFriends_SteamFriends017_ActivateGameOverlayRemotePlayTogetherInviteDialog(void *, CSteamID);
 extern bool cppISteamFriends_SteamFriends017_RegisterProtocolInOverlayBrowser(void *, const char *);
+extern void cppISteamFriends_SteamFriends017_ActivateGameOverlayInviteDialogConnectString(void *, const char *);

lsteamclient/cppISteamGameCoordinator_SteamGameCoordinator001.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamgamecoordinator.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamgamecoordinator.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamgameserverstats.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamgameserverstats.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamGameServerStats_SteamGameServerStats001.h"
 SteamAPICall_t cppISteamGameServerStats_SteamGameServerStats001_RequestUserStats(void *linux_side, CSteamID steamIDUser)

lsteamclient/cppISteamGameServer_SteamGameServer013.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamgameserver.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamgameserver.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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)

lsteamclient/cppISteamHTMLSurface_STEAMHTMLSURFACE_INTERFACE_VERSION_005.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_SteamInput002.cpp

@@ -0,0 +1,191 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_151
+#include "struct_converters.h"
+#include "cppISteamInput_SteamInput002.h"
+bool cppISteamInput_SteamInput002_Init(void *linux_side)
+{
+    return ((ISteamInput*)linux_side)->Init();
+}
+
+bool cppISteamInput_SteamInput002_Shutdown(void *linux_side)
+{
+    return ((ISteamInput*)linux_side)->Shutdown();
+}
+
+void cppISteamInput_SteamInput002_RunFrame(void *linux_side)
+{
+    ((ISteamInput*)linux_side)->RunFrame();
+}
+
+int cppISteamInput_SteamInput002_GetConnectedControllers(void *linux_side, InputHandle_t * handlesOut)
+{
+    return ((ISteamInput*)linux_side)->GetConnectedControllers((InputHandle_t *)handlesOut);
+}
+
+InputActionSetHandle_t cppISteamInput_SteamInput002_GetActionSetHandle(void *linux_side, const char * pszActionSetName)
+{
+    return ((ISteamInput*)linux_side)->GetActionSetHandle((const char *)pszActionSetName);
+}
+
+void cppISteamInput_SteamInput002_ActivateActionSet(void *linux_side, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle)
+{
+    ((ISteamInput*)linux_side)->ActivateActionSet((InputHandle_t)inputHandle, (InputActionSetHandle_t)actionSetHandle);
+}
+
+InputActionSetHandle_t cppISteamInput_SteamInput002_GetCurrentActionSet(void *linux_side, InputHandle_t inputHandle)
+{
+    return ((ISteamInput*)linux_side)->GetCurrentActionSet((InputHandle_t)inputHandle);
+}
+
+void cppISteamInput_SteamInput002_ActivateActionSetLayer(void *linux_side, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle)
+{
+    ((ISteamInput*)linux_side)->ActivateActionSetLayer((InputHandle_t)inputHandle, (InputActionSetHandle_t)actionSetLayerHandle);
+}
+
+void cppISteamInput_SteamInput002_DeactivateActionSetLayer(void *linux_side, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle)
+{
+    ((ISteamInput*)linux_side)->DeactivateActionSetLayer((InputHandle_t)inputHandle, (InputActionSetHandle_t)actionSetLayerHandle);
+}
+
+void cppISteamInput_SteamInput002_DeactivateAllActionSetLayers(void *linux_side, InputHandle_t inputHandle)
+{
+    ((ISteamInput*)linux_side)->DeactivateAllActionSetLayers((InputHandle_t)inputHandle);
+}
+
+int cppISteamInput_SteamInput002_GetActiveActionSetLayers(void *linux_side, InputHandle_t inputHandle, InputActionSetHandle_t * handlesOut)
+{
+    return ((ISteamInput*)linux_side)->GetActiveActionSetLayers((InputHandle_t)inputHandle, (InputActionSetHandle_t *)handlesOut);
+}
+
+InputDigitalActionHandle_t cppISteamInput_SteamInput002_GetDigitalActionHandle(void *linux_side, const char * pszActionName)
+{
+    return ((ISteamInput*)linux_side)->GetDigitalActionHandle((const char *)pszActionName);
+}
+
+InputDigitalActionData_t cppISteamInput_SteamInput002_GetDigitalActionData(void *linux_side, InputHandle_t inputHandle, InputDigitalActionHandle_t digitalActionHandle)
+{
+    return ((ISteamInput*)linux_side)->GetDigitalActionData((InputHandle_t)inputHandle, (InputDigitalActionHandle_t)digitalActionHandle);
+}
+
+int cppISteamInput_SteamInput002_GetDigitalActionOrigins(void *linux_side, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, EInputActionOrigin * originsOut)
+{
+    return ((ISteamInput*)linux_side)->GetDigitalActionOrigins((InputHandle_t)inputHandle, (InputActionSetHandle_t)actionSetHandle, (InputDigitalActionHandle_t)digitalActionHandle, (EInputActionOrigin *)originsOut);
+}
+
+InputAnalogActionHandle_t cppISteamInput_SteamInput002_GetAnalogActionHandle(void *linux_side, const char * pszActionName)
+{
+    return ((ISteamInput*)linux_side)->GetAnalogActionHandle((const char *)pszActionName);
+}
+
+InputAnalogActionData_t cppISteamInput_SteamInput002_GetAnalogActionData(void *linux_side, InputHandle_t inputHandle, InputAnalogActionHandle_t analogActionHandle)
+{
+    return ((ISteamInput*)linux_side)->GetAnalogActionData((InputHandle_t)inputHandle, (InputAnalogActionHandle_t)analogActionHandle);
+}
+
+int cppISteamInput_SteamInput002_GetAnalogActionOrigins(void *linux_side, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, EInputActionOrigin * originsOut)
+{
+    return ((ISteamInput*)linux_side)->GetAnalogActionOrigins((InputHandle_t)inputHandle, (InputActionSetHandle_t)actionSetHandle, (InputAnalogActionHandle_t)analogActionHandle, (EInputActionOrigin *)originsOut);
+}
+
+const char * cppISteamInput_SteamInput002_GetGlyphForActionOrigin(void *linux_side, EInputActionOrigin eOrigin)
+{
+    return ((ISteamInput*)linux_side)->GetGlyphForActionOrigin((EInputActionOrigin)eOrigin);
+}
+
+const char * cppISteamInput_SteamInput002_GetStringForActionOrigin(void *linux_side, EInputActionOrigin eOrigin)
+{
+    return ((ISteamInput*)linux_side)->GetStringForActionOrigin((EInputActionOrigin)eOrigin);
+}
+
+void cppISteamInput_SteamInput002_StopAnalogActionMomentum(void *linux_side, InputHandle_t inputHandle, InputAnalogActionHandle_t eAction)
+{
+    ((ISteamInput*)linux_side)->StopAnalogActionMomentum((InputHandle_t)inputHandle, (InputAnalogActionHandle_t)eAction);
+}
+
+InputMotionData_t cppISteamInput_SteamInput002_GetMotionData(void *linux_side, InputHandle_t inputHandle)
+{
+    return ((ISteamInput*)linux_side)->GetMotionData((InputHandle_t)inputHandle);
+}
+
+void cppISteamInput_SteamInput002_TriggerVibration(void *linux_side, InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed)
+{
+    ((ISteamInput*)linux_side)->TriggerVibration((InputHandle_t)inputHandle, (unsigned short)usLeftSpeed, (unsigned short)usRightSpeed);
+}
+
+void cppISteamInput_SteamInput002_SetLEDColor(void *linux_side, InputHandle_t inputHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags)
+{
+    ((ISteamInput*)linux_side)->SetLEDColor((InputHandle_t)inputHandle, (uint8)nColorR, (uint8)nColorG, (uint8)nColorB, (unsigned int)nFlags);
+}
+
+void cppISteamInput_SteamInput002_TriggerHapticPulse(void *linux_side, InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec)
+{
+    ((ISteamInput*)linux_side)->TriggerHapticPulse((InputHandle_t)inputHandle, (ESteamControllerPad)eTargetPad, (unsigned short)usDurationMicroSec);
+}
+
+void cppISteamInput_SteamInput002_TriggerRepeatedHapticPulse(void *linux_side, InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags)
+{
+    ((ISteamInput*)linux_side)->TriggerRepeatedHapticPulse((InputHandle_t)inputHandle, (ESteamControllerPad)eTargetPad, (unsigned short)usDurationMicroSec, (unsigned short)usOffMicroSec, (unsigned short)unRepeat, (unsigned int)nFlags);
+}
+
+bool cppISteamInput_SteamInput002_ShowBindingPanel(void *linux_side, InputHandle_t inputHandle)
+{
+    return ((ISteamInput*)linux_side)->ShowBindingPanel((InputHandle_t)inputHandle);
+}
+
+ESteamInputType cppISteamInput_SteamInput002_GetInputTypeForHandle(void *linux_side, InputHandle_t inputHandle)
+{
+    return ((ISteamInput*)linux_side)->GetInputTypeForHandle((InputHandle_t)inputHandle);
+}
+
+InputHandle_t cppISteamInput_SteamInput002_GetControllerForGamepadIndex(void *linux_side, int nIndex)
+{
+    return ((ISteamInput*)linux_side)->GetControllerForGamepadIndex((int)nIndex);
+}
+
+int cppISteamInput_SteamInput002_GetGamepadIndexForController(void *linux_side, InputHandle_t ulinputHandle)
+{
+    return ((ISteamInput*)linux_side)->GetGamepadIndexForController((InputHandle_t)ulinputHandle);
+}
+
+const char * cppISteamInput_SteamInput002_GetStringForXboxOrigin(void *linux_side, EXboxOrigin eOrigin)
+{
+    return ((ISteamInput*)linux_side)->GetStringForXboxOrigin((EXboxOrigin)eOrigin);
+}
+
+const char * cppISteamInput_SteamInput002_GetGlyphForXboxOrigin(void *linux_side, EXboxOrigin eOrigin)
+{
+    return ((ISteamInput*)linux_side)->GetGlyphForXboxOrigin((EXboxOrigin)eOrigin);
+}
+
+EInputActionOrigin cppISteamInput_SteamInput002_GetActionOriginFromXboxOrigin(void *linux_side, InputHandle_t inputHandle, EXboxOrigin eOrigin)
+{
+    return ((ISteamInput*)linux_side)->GetActionOriginFromXboxOrigin((InputHandle_t)inputHandle, (EXboxOrigin)eOrigin);
+}
+
+EInputActionOrigin cppISteamInput_SteamInput002_TranslateActionOrigin(void *linux_side, ESteamInputType eDestinationInputType, EInputActionOrigin eSourceOrigin)
+{
+    return ((ISteamInput*)linux_side)->TranslateActionOrigin((ESteamInputType)eDestinationInputType, (EInputActionOrigin)eSourceOrigin);
+}
+
+bool cppISteamInput_SteamInput002_GetDeviceBindingRevision(void *linux_side, InputHandle_t inputHandle, int * pMajor, int * pMinor)
+{
+    return ((ISteamInput*)linux_side)->GetDeviceBindingRevision((InputHandle_t)inputHandle, (int *)pMajor, (int *)pMinor);
+}
+
+uint32 cppISteamInput_SteamInput002_GetRemotePlaySessionID(void *linux_side, InputHandle_t inputHandle)
+{
+    return ((ISteamInput*)linux_side)->GetRemotePlaySessionID((InputHandle_t)inputHandle);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamInput_SteamInput002.h

@@ -0,0 +1,35 @@
+extern bool cppISteamInput_SteamInput002_Init(void *);
+extern bool cppISteamInput_SteamInput002_Shutdown(void *);
+extern void cppISteamInput_SteamInput002_RunFrame(void *);
+extern int cppISteamInput_SteamInput002_GetConnectedControllers(void *, InputHandle_t *);
+extern InputActionSetHandle_t cppISteamInput_SteamInput002_GetActionSetHandle(void *, const char *);
+extern void cppISteamInput_SteamInput002_ActivateActionSet(void *, InputHandle_t, InputActionSetHandle_t);
+extern InputActionSetHandle_t cppISteamInput_SteamInput002_GetCurrentActionSet(void *, InputHandle_t);
+extern void cppISteamInput_SteamInput002_ActivateActionSetLayer(void *, InputHandle_t, InputActionSetHandle_t);
+extern void cppISteamInput_SteamInput002_DeactivateActionSetLayer(void *, InputHandle_t, InputActionSetHandle_t);
+extern void cppISteamInput_SteamInput002_DeactivateAllActionSetLayers(void *, InputHandle_t);
+extern int cppISteamInput_SteamInput002_GetActiveActionSetLayers(void *, InputHandle_t, InputActionSetHandle_t *);
+extern InputDigitalActionHandle_t cppISteamInput_SteamInput002_GetDigitalActionHandle(void *, const char *);
+extern InputDigitalActionData_t cppISteamInput_SteamInput002_GetDigitalActionData(void *, InputHandle_t, InputDigitalActionHandle_t);
+extern int cppISteamInput_SteamInput002_GetDigitalActionOrigins(void *, InputHandle_t, InputActionSetHandle_t, InputDigitalActionHandle_t, EInputActionOrigin *);
+extern InputAnalogActionHandle_t cppISteamInput_SteamInput002_GetAnalogActionHandle(void *, const char *);
+extern InputAnalogActionData_t cppISteamInput_SteamInput002_GetAnalogActionData(void *, InputHandle_t, InputAnalogActionHandle_t);
+extern int cppISteamInput_SteamInput002_GetAnalogActionOrigins(void *, InputHandle_t, InputActionSetHandle_t, InputAnalogActionHandle_t, EInputActionOrigin *);
+extern const char * cppISteamInput_SteamInput002_GetGlyphForActionOrigin(void *, EInputActionOrigin);
+extern const char * cppISteamInput_SteamInput002_GetStringForActionOrigin(void *, EInputActionOrigin);
+extern void cppISteamInput_SteamInput002_StopAnalogActionMomentum(void *, InputHandle_t, InputAnalogActionHandle_t);
+extern InputMotionData_t cppISteamInput_SteamInput002_GetMotionData(void *, InputHandle_t);
+extern void cppISteamInput_SteamInput002_TriggerVibration(void *, InputHandle_t, unsigned short, unsigned short);
+extern void cppISteamInput_SteamInput002_SetLEDColor(void *, InputHandle_t, uint8, uint8, uint8, unsigned int);
+extern void cppISteamInput_SteamInput002_TriggerHapticPulse(void *, InputHandle_t, ESteamControllerPad, unsigned short);
+extern void cppISteamInput_SteamInput002_TriggerRepeatedHapticPulse(void *, InputHandle_t, ESteamControllerPad, unsigned short, unsigned short, unsigned short, unsigned int);
+extern bool cppISteamInput_SteamInput002_ShowBindingPanel(void *, InputHandle_t);
+extern ESteamInputType cppISteamInput_SteamInput002_GetInputTypeForHandle(void *, InputHandle_t);
+extern InputHandle_t cppISteamInput_SteamInput002_GetControllerForGamepadIndex(void *, int);
+extern int cppISteamInput_SteamInput002_GetGamepadIndexForController(void *, InputHandle_t);
+extern const char * cppISteamInput_SteamInput002_GetStringForXboxOrigin(void *, EXboxOrigin);
+extern const char * cppISteamInput_SteamInput002_GetGlyphForXboxOrigin(void *, EXboxOrigin);
+extern EInputActionOrigin cppISteamInput_SteamInput002_GetActionOriginFromXboxOrigin(void *, InputHandle_t, EXboxOrigin);
+extern EInputActionOrigin cppISteamInput_SteamInput002_TranslateActionOrigin(void *, ESteamInputType, EInputActionOrigin);
+extern bool cppISteamInput_SteamInput002_GetDeviceBindingRevision(void *, InputHandle_t, int *, int *);
+extern uint32 cppISteamInput_SteamInput002_GetRemotePlaySessionID(void *, InputHandle_t);

lsteamclient/cppISteamInventory_STEAMINVENTORY_INTERFACE_V003.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamMusic_STEAMMUSIC_INTERFACE_VERSION001.h"
 bool cppISteamMusic_STEAMMUSIC_INTERFACE_VERSION001_BIsEnabled(void *linux_side)

lsteamclient/cppISteamNetworkingMessages_SteamNetworkingMessages002.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamnetworkingmessages.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamnetworkingmessages.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamNetworkingMessages_SteamNetworkingMessages002.h"
 EResult cppISteamNetworkingMessages_SteamNetworkingMessages002_SendMessageToUser(void *linux_side, const SteamNetworkingIdentity * identityRemote, const void * pubData, uint32 cubData, int nSendFlags, int nRemoteChannel)

lsteamclient/cppISteamNetworkingMessages_SteamNetworkingMessages002.h

@@ -1,5 +1,5 @@
 extern EResult cppISteamNetworkingMessages_SteamNetworkingMessages002_SendMessageToUser(void *, const SteamNetworkingIdentity *, const void *, uint32, int, int);
-extern int cppISteamNetworkingMessages_SteamNetworkingMessages002_ReceiveMessagesOnChannel(void *, int, winSteamNetworkingMessage_t_150 **, int);
+extern int cppISteamNetworkingMessages_SteamNetworkingMessages002_ReceiveMessagesOnChannel(void *, int, winSteamNetworkingMessage_t_151 **, int);
 extern bool cppISteamNetworkingMessages_SteamNetworkingMessages002_AcceptSessionWithUser(void *, const SteamNetworkingIdentity *);
 extern bool cppISteamNetworkingMessages_SteamNetworkingMessages002_CloseSessionWithUser(void *, const SteamNetworkingIdentity *);
 extern bool cppISteamNetworkingMessages_SteamNetworkingMessages002_CloseChannelWithUser(void *, const SteamNetworkingIdentity *, int);

lsteamclient/cppISteamNetworkingSockets_SteamNetworkingSockets009.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamnetworkingsockets.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamnetworkingsockets.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamNetworkingSockets_SteamNetworkingSockets009.h"
 HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets009_CreateListenSocketIP(void *linux_side, const SteamNetworkingIPAddr * localAddress, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
@@ -172,14 +172,14 @@ EResult cppISteamNetworkingSockets_SteamNetworkingSockets009_GetGameCoordinatorS
     return ((ISteamNetworkingSockets*)linux_side)->GetGameCoordinatorServerLogin((SteamDatagramGameCoordinatorServerLogin *)pLoginInfo, (int *)pcbSignedBlob, (void *)pBlob);
 }
 
-HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling(void *linux_side, ISteamNetworkingConnectionCustomSignaling * pSignaling, const SteamNetworkingIdentity * pPeerIdentity, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling(void *linux_side, ISteamNetworkingConnectionSignaling * pSignaling, const SteamNetworkingIdentity * pPeerIdentity, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
 {
-    return ((ISteamNetworkingSockets*)linux_side)->ConnectP2PCustomSignaling((ISteamNetworkingConnectionCustomSignaling *)pSignaling, (const SteamNetworkingIdentity *)pPeerIdentity, (int)nRemoteVirtualPort, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
+    return ((ISteamNetworkingSockets*)linux_side)->ConnectP2PCustomSignaling((ISteamNetworkingConnectionSignaling *)pSignaling, (const SteamNetworkingIdentity *)pPeerIdentity, (int)nRemoteVirtualPort, (int)nOptions, (const SteamNetworkingConfigValue_t *)pOptions);
 }
 
-bool cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal(void *linux_side, const void * pMsg, int cbMsg, ISteamNetworkingCustomSignalingRecvContext * pContext)
+bool cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal(void *linux_side, const void * pMsg, int cbMsg, ISteamNetworkingSignalingRecvContext * pContext)
 {
-    return ((ISteamNetworkingSockets*)linux_side)->ReceivedP2PCustomSignal((const void *)pMsg, (int)cbMsg, (ISteamNetworkingCustomSignalingRecvContext *)pContext);
+    return ((ISteamNetworkingSockets*)linux_side)->ReceivedP2PCustomSignal((const void *)pMsg, (int)cbMsg, (ISteamNetworkingSignalingRecvContext *)pContext);
 }
 
 bool cppISteamNetworkingSockets_SteamNetworkingSockets009_GetCertificateRequest(void *linux_side, int * pcbBlob, void * pBlob, SteamNetworkingErrMsg * errMsg)

lsteamclient/cppISteamNetworkingSockets_SteamNetworkingSockets009.h

@@ -10,9 +10,9 @@ extern int64 cppISteamNetworkingSockets_SteamNetworkingSockets009_GetConnectionU
 extern void cppISteamNetworkingSockets_SteamNetworkingSockets009_SetConnectionName(void *, HSteamNetConnection, const char *);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_GetConnectionName(void *, HSteamNetConnection, char *, int);
 extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets009_SendMessageToConnection(void *, HSteamNetConnection, const void *, uint32, int, int64 *);
-extern void cppISteamNetworkingSockets_SteamNetworkingSockets009_SendMessages(void *, int, winSteamNetworkingMessage_t_150 *const *, int64 *);
+extern void cppISteamNetworkingSockets_SteamNetworkingSockets009_SendMessages(void *, int, winSteamNetworkingMessage_t_151 *const *, int64 *);
 extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets009_FlushMessagesOnConnection(void *, HSteamNetConnection);
-extern int cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnConnection(void *, HSteamNetConnection, winSteamNetworkingMessage_t_150 **, int);
+extern int cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnConnection(void *, HSteamNetConnection, winSteamNetworkingMessage_t_151 **, int);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_GetConnectionInfo(void *, HSteamNetConnection, SteamNetConnectionInfo_t *);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_GetQuickConnectionStatus(void *, HSteamNetConnection, SteamNetworkingQuickConnectionStatus *);
 extern int cppISteamNetworkingSockets_SteamNetworkingSockets009_GetDetailedConnectionStatus(void *, HSteamNetConnection, char *, int);
@@ -24,7 +24,7 @@ extern ESteamNetworkingAvailability cppISteamNetworkingSockets_SteamNetworkingSo
 extern HSteamNetPollGroup cppISteamNetworkingSockets_SteamNetworkingSockets009_CreatePollGroup(void *);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_DestroyPollGroup(void *, HSteamNetPollGroup);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_SetConnectionPollGroup(void *, HSteamNetConnection, HSteamNetPollGroup);
-extern int cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnPollGroup(void *, HSteamNetPollGroup, winSteamNetworkingMessage_t_150 **, int);
+extern int cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnPollGroup(void *, HSteamNetPollGroup, winSteamNetworkingMessage_t_151 **, int);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedRelayAuthTicket(void *, const void *, int, SteamDatagramRelayAuthTicket *);
 extern int cppISteamNetworkingSockets_SteamNetworkingSockets009_FindRelayAuthTicketForServer(void *, const SteamNetworkingIdentity *, int, SteamDatagramRelayAuthTicket *);
 extern HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets009_ConnectToHostedDedicatedServer(void *, const SteamNetworkingIdentity *, int, int, const SteamNetworkingConfigValue_t *);
@@ -33,8 +33,8 @@ extern SteamNetworkingPOPID cppISteamNetworkingSockets_SteamNetworkingSockets009
 extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets009_GetHostedDedicatedServerAddress(void *, SteamDatagramHostedAddress *);
 extern HSteamListenSocket cppISteamNetworkingSockets_SteamNetworkingSockets009_CreateHostedDedicatedServerListenSocket(void *, int, int, const SteamNetworkingConfigValue_t *);
 extern EResult cppISteamNetworkingSockets_SteamNetworkingSockets009_GetGameCoordinatorServerLogin(void *, SteamDatagramGameCoordinatorServerLogin *, int *, void *);
-extern HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling(void *, ISteamNetworkingConnectionCustomSignaling *, const SteamNetworkingIdentity *, int, int, const SteamNetworkingConfigValue_t *);
-extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal(void *, const void *, int, ISteamNetworkingCustomSignalingRecvContext *);
+extern HSteamNetConnection cppISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling(void *, ISteamNetworkingConnectionSignaling *, const SteamNetworkingIdentity *, int, int, const SteamNetworkingConfigValue_t *);
+extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal(void *, const void *, int, ISteamNetworkingSignalingRecvContext *);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_GetCertificateRequest(void *, int *, void *, SteamNetworkingErrMsg *);
 extern bool cppISteamNetworkingSockets_SteamNetworkingSockets009_SetCertificate(void *, const void *, int, SteamNetworkingErrMsg *);
 extern void cppISteamNetworkingSockets_SteamNetworkingSockets009_RunCallbacks(void *);

lsteamclient/cppISteamNetworkingUtils_SteamNetworkingUtils003.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamnetworkingutils.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamnetworkingutils.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamNetworkingUtils_SteamNetworkingUtils003.h"
 ESteamNetworkingAvailability cppISteamNetworkingUtils_SteamNetworkingUtils003_GetRelayNetworkStatus(void *linux_side, SteamRelayNetworkStatus_t * pDetails)

lsteamclient/cppISteamNetworking_SteamNetworking006.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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)

lsteamclient/cppISteamParentalSettings_STEAMPARENTALSETTINGS_INTERFACE_VERSION001.cpp

@@ -1,15 +1,15 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
-#include "steamworks_sdk_150/isteamparentalsettings.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/isteamparentalsettings.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150 * pLocation, char * pchMetadata, int cchMetadata)
+bool cppISteamParties_SteamParties002_GetBeaconDetails(void *linux_side, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, winSteamPartyBeaconLocation_t_151 * pLocation, char * pchMetadata, int cchMetadata)
 {
     SteamPartyBeaconLocation_t lin_pLocation;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_150(pLocation, &lin_pLocation);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_151(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_150(&lin_pLocation, pLocation);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_151(&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_150 * pLocationList, uint32 uMaxNumLocations)
+bool cppISteamParties_SteamParties002_GetAvailableBeaconLocations(void *linux_side, winSteamPartyBeaconLocation_t_151 * pLocationList, uint32 uMaxNumLocations)
 {
     SteamPartyBeaconLocation_t lin_pLocationList;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_150(pLocationList, &lin_pLocationList);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_151(pLocationList, &lin_pLocationList);
     bool retval = ((ISteamParties*)linux_side)->GetAvailableBeaconLocations(&lin_pLocationList, (uint32)uMaxNumLocations);
-    lin_to_win_struct_SteamPartyBeaconLocation_t_150(&lin_pLocationList, pLocationList);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_151(&lin_pLocationList, pLocationList);
     return retval;
 }
 
-SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *linux_side, uint32 unOpenSlots, winSteamPartyBeaconLocation_t_150 * pBeaconLocation, const char * pchConnectString, const char * pchMetadata)
+SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *linux_side, uint32 unOpenSlots, winSteamPartyBeaconLocation_t_151 * pBeaconLocation, const char * pchConnectString, const char * pchMetadata)
 {
     SteamPartyBeaconLocation_t lin_pBeaconLocation;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_150(pBeaconLocation, &lin_pBeaconLocation);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_151(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_150(&lin_pBeaconLocation, pBeaconLocation);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_151(&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_150 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
+bool cppISteamParties_SteamParties002_GetBeaconLocationData(void *linux_side, winSteamPartyBeaconLocation_t_151 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
 {
     SteamPartyBeaconLocation_t lin_BeaconLocation;
-    win_to_lin_struct_SteamPartyBeaconLocation_t_150(&BeaconLocation, &lin_BeaconLocation);
+    win_to_lin_struct_SteamPartyBeaconLocation_t_151(&BeaconLocation, &lin_BeaconLocation);
     bool retval = ((ISteamParties*)linux_side)->GetBeaconLocationData(lin_BeaconLocation, (ESteamPartyBeaconLocationData)eData, (char *)pchDataStringOut, (int)cchDataStringOut);
-    lin_to_win_struct_SteamPartyBeaconLocation_t_150(&lin_BeaconLocation, &BeaconLocation);
+    lin_to_win_struct_SteamPartyBeaconLocation_t_151(&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_150 *, char *, int);
+extern bool cppISteamParties_SteamParties002_GetBeaconDetails(void *, PartyBeaconID_t, CSteamID *, winSteamPartyBeaconLocation_t_151 *, 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_150 *, uint32);
-extern SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *, uint32, winSteamPartyBeaconLocation_t_150 *, const char *, const char *);
+extern bool cppISteamParties_SteamParties002_GetAvailableBeaconLocations(void *, winSteamPartyBeaconLocation_t_151 *, uint32);
+extern SteamAPICall_t cppISteamParties_SteamParties002_CreateBeacon(void *, uint32, winSteamPartyBeaconLocation_t_151 *, 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_150, ESteamPartyBeaconLocationData, char *, int);
+extern bool cppISteamParties_SteamParties002_GetBeaconLocationData(void *, winSteamPartyBeaconLocation_t_151, 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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001.h"
 uint32 cppISteamRemotePlay_STEAMREMOTEPLAY_INTERFACE_VERSION001_GetSessionCount(void *linux_side)

lsteamclient/cppISteamRemoteStorage_STEAMREMOTESTORAGE_INTERFACE_VERSION014.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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_VERSION015.cpp

@@ -0,0 +1,430 @@
+#include "steam_defs.h"
+#pragma push_macro("__cdecl")
+#undef __cdecl
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
+#pragma pop_macro("__cdecl")
+#include "steamclient_private.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define SDKVER_151
+#include "struct_converters.h"
+#include "cppISteamUGC_STEAMUGC_INTERFACE_VERSION015.h"
+UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_CreateQueryUGCDetailsRequest(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    return ((ISteamUGC*)linux_side)->CreateQueryUGCDetailsRequest((PublishedFileId_t *)pvecPublishedFileID, (uint32)unNumPublishedFileIDs);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SendQueryUGCRequest(void *linux_side, UGCQueryHandle_t handle)
+{
+    return ((ISteamUGC*)linux_side)->SendQueryUGCRequest((UGCQueryHandle_t)handle);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCResult(void *linux_side, UGCQueryHandle_t handle, uint32 index, winSteamUGCDetails_t_151 * pDetails)
+{
+    SteamUGCDetails_t lin_pDetails;
+    win_to_lin_struct_SteamUGCDetails_t_151(pDetails, &lin_pDetails);
+    bool retval = ((ISteamUGC*)linux_side)->GetQueryUGCResult((UGCQueryHandle_t)handle, (uint32)index, &lin_pDetails);
+    lin_to_win_struct_SteamUGCDetails_t_151(&lin_pDetails, pDetails);
+    return retval;
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumTags(void *linux_side, UGCQueryHandle_t handle, uint32 index)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCNumTags((UGCQueryHandle_t)handle, (uint32)index);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTag(void *linux_side, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCTag((UGCQueryHandle_t)handle, (uint32)index, (uint32)indexTag, (char *)pchValue, (uint32)cchValueSize);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTagDisplayName(void *linux_side, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCTagDisplayName((UGCQueryHandle_t)handle, (uint32)index, (uint32)indexTag, (char *)pchValue, (uint32)cchValueSize);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_GetQueryUGCNumAdditionalPreviews(void *linux_side, UGCQueryHandle_t handle, uint32 index)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCNumAdditionalPreviews((UGCQueryHandle_t)handle, (uint32)index);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_GetQueryUGCNumKeyValueTags(void *linux_side, UGCQueryHandle_t handle, uint32 index)
+{
+    return ((ISteamUGC*)linux_side)->GetQueryUGCNumKeyValueTags((UGCQueryHandle_t)handle, (uint32)index);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_ReleaseQueryUGCRequest(void *linux_side, UGCQueryHandle_t handle)
+{
+    return ((ISteamUGC*)linux_side)->ReleaseQueryUGCRequest((UGCQueryHandle_t)handle);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_SetReturnOnlyIDs(void *linux_side, UGCQueryHandle_t handle, bool bReturnOnlyIDs)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnOnlyIDs((UGCQueryHandle_t)handle, (bool)bReturnOnlyIDs);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnKeyValueTags(void *linux_side, UGCQueryHandle_t handle, bool bReturnKeyValueTags)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnKeyValueTags((UGCQueryHandle_t)handle, (bool)bReturnKeyValueTags);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnLongDescription(void *linux_side, UGCQueryHandle_t handle, bool bReturnLongDescription)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnLongDescription((UGCQueryHandle_t)handle, (bool)bReturnLongDescription);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnMetadata(void *linux_side, UGCQueryHandle_t handle, bool bReturnMetadata)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnMetadata((UGCQueryHandle_t)handle, (bool)bReturnMetadata);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnChildren(void *linux_side, UGCQueryHandle_t handle, bool bReturnChildren)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnChildren((UGCQueryHandle_t)handle, (bool)bReturnChildren);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnAdditionalPreviews(void *linux_side, UGCQueryHandle_t handle, bool bReturnAdditionalPreviews)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnAdditionalPreviews((UGCQueryHandle_t)handle, (bool)bReturnAdditionalPreviews);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnTotalOnly(void *linux_side, UGCQueryHandle_t handle, bool bReturnTotalOnly)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnTotalOnly((UGCQueryHandle_t)handle, (bool)bReturnTotalOnly);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnPlaytimeStats(void *linux_side, UGCQueryHandle_t handle, uint32 unDays)
+{
+    return ((ISteamUGC*)linux_side)->SetReturnPlaytimeStats((UGCQueryHandle_t)handle, (uint32)unDays);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_SetAllowCachedResponse(void *linux_side, UGCQueryHandle_t handle, uint32 unMaxAgeSeconds)
+{
+    return ((ISteamUGC*)linux_side)->SetAllowCachedResponse((UGCQueryHandle_t)handle, (uint32)unMaxAgeSeconds);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_SetMatchAnyTag(void *linux_side, UGCQueryHandle_t handle, bool bMatchAnyTag)
+{
+    return ((ISteamUGC*)linux_side)->SetMatchAnyTag((UGCQueryHandle_t)handle, (bool)bMatchAnyTag);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_SetRankedByTrendDays(void *linux_side, UGCQueryHandle_t handle, uint32 unDays)
+{
+    return ((ISteamUGC*)linux_side)->SetRankedByTrendDays((UGCQueryHandle_t)handle, (uint32)unDays);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_RequestUGCDetails(void *linux_side, PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds)
+{
+    return ((ISteamUGC*)linux_side)->RequestUGCDetails((PublishedFileId_t)nPublishedFileID, (uint32)unMaxAgeSeconds);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateItem(void *linux_side, AppId_t nConsumerAppId, EWorkshopFileType eFileType)
+{
+    return ((ISteamUGC*)linux_side)->CreateItem((AppId_t)nConsumerAppId, (EWorkshopFileType)eFileType);
+}
+
+UGCUpdateHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_SetItemVisibility(void *linux_side, UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility)
+{
+    return ((ISteamUGC*)linux_side)->SetItemVisibility((UGCUpdateHandle_t)handle, (ERemoteStoragePublishedFileVisibility)eVisibility);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_SetAllowLegacyUpload(void *linux_side, UGCUpdateHandle_t handle, bool bAllowLegacyUpload)
+{
+    return ((ISteamUGC*)linux_side)->SetAllowLegacyUpload((UGCUpdateHandle_t)handle, (bool)bAllowLegacyUpload);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAllItemKeyValueTags(void *linux_side, UGCUpdateHandle_t handle)
+{
+    return ((ISteamUGC*)linux_side)->RemoveAllItemKeyValueTags((UGCUpdateHandle_t)handle);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_RemoveItemPreview(void *linux_side, UGCUpdateHandle_t handle, uint32 index)
+{
+    return ((ISteamUGC*)linux_side)->RemoveItemPreview((UGCUpdateHandle_t)handle, (uint32)index);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_SetUserItemVote(void *linux_side, PublishedFileId_t nPublishedFileID, bool bVoteUp)
+{
+    return ((ISteamUGC*)linux_side)->SetUserItemVote((PublishedFileId_t)nPublishedFileID, (bool)bVoteUp);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetUserItemVote(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->GetUserItemVote((PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_SubscribeItem(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->SubscribeItem((PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_UnsubscribeItem(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->UnsubscribeItem((PublishedFileId_t)nPublishedFileID);
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetNumSubscribedItems(void *linux_side)
+{
+    return ((ISteamUGC*)linux_side)->GetNumSubscribedItems();
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetSubscribedItems(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries)
+{
+    return ((ISteamUGC*)linux_side)->GetSubscribedItems((PublishedFileId_t *)pvecPublishedFileID, (uint32)cMaxEntries);
+}
+
+uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemState(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->GetItemState((PublishedFileId_t)nPublishedFileID);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_DownloadItem(void *linux_side, PublishedFileId_t nPublishedFileID, bool bHighPriority)
+{
+    return ((ISteamUGC*)linux_side)->DownloadItem((PublishedFileId_t)nPublishedFileID, (bool)bHighPriority);
+}
+
+bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_SuspendDownloads(void *linux_side, bool bSuspend)
+{
+    ((ISteamUGC*)linux_side)->SuspendDownloads((bool)bSuspend);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartPlaytimeTracking(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    return ((ISteamUGC*)linux_side)->StartPlaytimeTracking((PublishedFileId_t *)pvecPublishedFileID, (uint32)unNumPublishedFileIDs);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTracking(void *linux_side, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    return ((ISteamUGC*)linux_side)->StopPlaytimeTracking((PublishedFileId_t *)pvecPublishedFileID, (uint32)unNumPublishedFileIDs);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTrackingForAllItems(void *linux_side)
+{
+    return ((ISteamUGC*)linux_side)->StopPlaytimeTrackingForAllItems();
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_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_VERSION015_GetAppDependencies(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->GetAppDependencies((PublishedFileId_t)nPublishedFileID);
+}
+
+SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_DeleteItem(void *linux_side, PublishedFileId_t nPublishedFileID)
+{
+    return ((ISteamUGC*)linux_side)->DeleteItem((PublishedFileId_t)nPublishedFileID);
+}
+
+#ifdef __cplusplus
+}
+#endif

lsteamclient/cppISteamUGC_STEAMUGC_INTERFACE_VERSION015.h

@@ -0,0 +1,82 @@
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUserUGCRequest(void *, AccountID_t, EUserUGCList, EUGCMatchingUGCType, EUserUGCListSortOrder, AppId_t, AppId_t, uint32);
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest(void *, EUGCQuery, EUGCMatchingUGCType, AppId_t, AppId_t, uint32);
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest_2(void *, EUGCQuery, EUGCMatchingUGCType, AppId_t, AppId_t, const char *);
+extern UGCQueryHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUGCDetailsRequest(void *, PublishedFileId_t *, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SendQueryUGCRequest(void *, UGCQueryHandle_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCResult(void *, UGCQueryHandle_t, uint32, winSteamUGCDetails_t_151 *);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumTags(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTag(void *, UGCQueryHandle_t, uint32, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTagDisplayName(void *, UGCQueryHandle_t, uint32, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCPreviewURL(void *, UGCQueryHandle_t, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCMetadata(void *, UGCQueryHandle_t, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCChildren(void *, UGCQueryHandle_t, uint32, PublishedFileId_t *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCStatistic(void *, UGCQueryHandle_t, uint32, EItemStatistic, uint64 *);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumAdditionalPreviews(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCAdditionalPreview(void *, UGCQueryHandle_t, uint32, uint32, char *, uint32, char *, uint32, EItemPreviewType *);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumKeyValueTags(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag(void *, UGCQueryHandle_t, uint32, uint32, char *, uint32, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag_2(void *, UGCQueryHandle_t, uint32, const char *, char *, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_ReleaseQueryUGCRequest(void *, UGCQueryHandle_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTag(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTagGroup(void *, UGCQueryHandle_t, const SteamParamStringArray_t *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddExcludedTag(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnOnlyIDs(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnKeyValueTags(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnLongDescription(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnMetadata(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnChildren(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnAdditionalPreviews(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnTotalOnly(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnPlaytimeStats(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetLanguage(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowCachedResponse(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetCloudFileNameFilter(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetMatchAnyTag(void *, UGCQueryHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetSearchText(void *, UGCQueryHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetRankedByTrendDays(void *, UGCQueryHandle_t, uint32);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredKeyValueTag(void *, UGCQueryHandle_t, const char *, const char *);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RequestUGCDetails(void *, PublishedFileId_t, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateItem(void *, AppId_t, EWorkshopFileType);
+extern UGCUpdateHandle_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartItemUpdate(void *, AppId_t, PublishedFileId_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTitle(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemDescription(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemUpdateLanguage(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemMetadata(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemVisibility(void *, UGCUpdateHandle_t, ERemoteStoragePublishedFileVisibility);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTags(void *, UGCUpdateHandle_t, const SteamParamStringArray_t *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemContent(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemPreview(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowLegacyUpload(void *, UGCUpdateHandle_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAllItemKeyValueTags(void *, UGCUpdateHandle_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemKeyValueTags(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemKeyValueTag(void *, UGCUpdateHandle_t, const char *, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewFile(void *, UGCUpdateHandle_t, const char *, EItemPreviewType);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewVideo(void *, UGCUpdateHandle_t, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewFile(void *, UGCUpdateHandle_t, uint32, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewVideo(void *, UGCUpdateHandle_t, uint32, const char *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemPreview(void *, UGCUpdateHandle_t, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubmitItemUpdate(void *, UGCUpdateHandle_t, const char *);
+extern EItemUpdateStatus cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemUpdateProgress(void *, UGCUpdateHandle_t, uint64 *, uint64 *);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetUserItemVote(void *, PublishedFileId_t, bool);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetUserItemVote(void *, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemToFavorites(void *, AppId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemFromFavorites(void *, AppId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubscribeItem(void *, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_UnsubscribeItem(void *, PublishedFileId_t);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetNumSubscribedItems(void *);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetSubscribedItems(void *, PublishedFileId_t *, uint32);
+extern uint32 cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemState(void *, PublishedFileId_t);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemInstallInfo(void *, PublishedFileId_t, uint64 *, char *, uint32, uint32 *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemDownloadInfo(void *, PublishedFileId_t, uint64 *, uint64 *);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_DownloadItem(void *, PublishedFileId_t, bool);
+extern bool cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_BInitWorkshopForGameServer(void *, DepotId_t, const char *);
+extern void cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SuspendDownloads(void *, bool);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartPlaytimeTracking(void *, PublishedFileId_t *, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTracking(void *, PublishedFileId_t *, uint32);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTrackingForAllItems(void *);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddDependency(void *, PublishedFileId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveDependency(void *, PublishedFileId_t, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddAppDependency(void *, PublishedFileId_t, AppId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAppDependency(void *, PublishedFileId_t, AppId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetAppDependencies(void *, PublishedFileId_t);
+extern SteamAPICall_t cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_DeleteItem(void *, PublishedFileId_t);

lsteamclient/cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012.h"
 bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_RequestCurrentStats(void *linux_side)
@@ -161,12 +161,12 @@ SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_DownloadLe
     return ((ISteamUserStats*)linux_side)->DownloadLeaderboardEntriesForUsers((SteamLeaderboard_t)hSteamLeaderboard, (CSteamID *)prgUsers, (int)cUsers);
 }
 
-bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry(void *linux_side, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_150 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
+bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry(void *linux_side, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_151 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
 {
     LeaderboardEntry_t lin_pLeaderboardEntry;
-    win_to_lin_struct_LeaderboardEntry_t_150(pLeaderboardEntry, &lin_pLeaderboardEntry);
+    win_to_lin_struct_LeaderboardEntry_t_151(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_150(&lin_pLeaderboardEntry, pLeaderboardEntry);
+    lin_to_win_struct_LeaderboardEntry_t_151(&lin_pLeaderboardEntry, pLeaderboardEntry);
     return retval;
 }
 

lsteamclient/cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012.h

@@ -28,7 +28,7 @@ extern ELeaderboardSortMethod cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSIO
 extern ELeaderboardDisplayType cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetLeaderboardDisplayType(void *, SteamLeaderboard_t);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_DownloadLeaderboardEntries(void *, SteamLeaderboard_t, ELeaderboardDataRequest, int, int);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_DownloadLeaderboardEntriesForUsers(void *, SteamLeaderboard_t, CSteamID *, int);
-extern bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry(void *, SteamLeaderboardEntries_t, int, winLeaderboardEntry_t_150 *, int32 *, int);
+extern bool cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry(void *, SteamLeaderboardEntries_t, int, winLeaderboardEntry_t_151 *, int32 *, int);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_UploadLeaderboardScore(void *, SteamLeaderboard_t, ELeaderboardUploadScoreMethod, int32, const int32 *, int);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_AttachLeaderboardUGC(void *, SteamLeaderboard_t, UGCHandle_t);
 extern SteamAPICall_t cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetNumberOfCurrentPlayers(void *);

lsteamclient/cppISteamUser_SteamUser021.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamUser_SteamUser021.h"
 HSteamUser cppISteamUser_SteamUser021_GetHSteamUser(void *linux_side)

lsteamclient/cppISteamUtils_SteamUtils010.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #include "struct_converters.h"
 #include "cppISteamUtils_SteamUtils010.h"
 uint32 cppISteamUtils_SteamUtils010_GetSecondsSinceAppActive(void *linux_side)

lsteamclient/cppISteamVideo_STEAMVIDEO_INTERFACE_V002.cpp

@@ -1,14 +1,14 @@
 #include "steam_defs.h"
 #pragma push_macro("__cdecl")
 #undef __cdecl
-#include "steamworks_sdk_150/steam_api.h"
-#include "steamworks_sdk_150/steamnetworkingtypes.h"
+#include "steamworks_sdk_151/steam_api.h"
+#include "steamworks_sdk_151/steamnetworkingtypes.h"
 #pragma pop_macro("__cdecl")
 #include "steamclient_private.h"
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define SDKVER_150
+#define SDKVER_151
 #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/10.0.1'
+CLANG_PATH='/usr/lib/clang/11.1.0'
 
 import pprint
 import sys
@@ -15,6 +15,7 @@ import re
 import math
 
 sdk_versions = [
+    "151",
     "150",
     "149",
     "148a",
@@ -866,14 +867,15 @@ def handle_method(cfile, classname, winclassname, cppname, method, cpp, cpp_h, e
 
 def get_iface_version(classname):
     # ISteamClient -> STEAMCLIENT_INTERFACE_VERSION
-    if "SteamNetworkingMessages" in classname:
-        defname = "%s_VERSION" % classname[1:].upper()
-    else:
-        defname = "%s_INTERFACE_VERSION" % classname[1:].upper()
+    defname = "%s_INTERFACE_VERSION" % classname[1:].upper()
     if defname in iface_versions.keys():
         ver = iface_versions[defname]
     else:
-        ver = "UNVERSIONED"
+        defname = "%s_VERSION" % classname[1:].upper()
+        if defname in iface_versions.keys():
+            ver = iface_versions[defname]
+        else:
+            ver = "UNVERSIONED"
     if classname in class_versions.keys() and ver in class_versions[classname]:
         return (ver, True)
     if not classname in class_versions.keys():

lsteamclient/steam_defs.h

@@ -105,6 +105,8 @@ typedef uint32_t EUserUGCList,
 /* XXX NO */
 typedef struct ISteamNetworkingCustomSignalingRecvContext ISteamNetworkingCustomSignalingRecvContext;
 typedef struct ISteamNetworkingConnectionCustomSignaling ISteamNetworkingConnectionCustomSignaling;
+typedef struct ISteamNetworkingSignalingRecvContext ISteamNetworkingSignalingRecvContext;
+typedef struct ISteamNetworkingConnectionSignaling ISteamNetworkingConnectionSignaling;
 
 /* structs below are PODs with identical size & layout across platforms */
 

lsteamclient/steamworks_sdk_151/isteamappticket.h

@@ -8,7 +8,7 @@
 
 #ifndef ISTEAMAPPTICKET_H
 #define ISTEAMAPPTICKET_H
-#pragma once
+#include "steamtypes.h"
 
 //-----------------------------------------------------------------------------
 // Purpose: hand out a reasonable "future proof" view of an app ownership ticket

lsteamclient/steamworks_sdk_151/isteamclient.h

@@ -56,7 +56,7 @@ public:
 
 	// set the local IP and Port to bind to
 	// this must be set before CreateLocalUser()
-	virtual void SetLocalIPBinding( const SteamIPAddress_t &unIP, uint16 usPort ) = 0; 
+	virtual void SetLocalIPBinding( const SteamIPAddress_t *unIP, uint16 usPort ) = 0; 
 
 	// returns the ISteamFriends interface
 	virtual ISteamFriends *GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;

lsteamclient/steamworks_sdk_151/isteamnetworkingmessages.h

@@ -2,7 +2,6 @@
 
 #ifndef ISTEAMNETWORKINGMESSAGES
 #define ISTEAMNETWORKINGMESSAGES
-#pragma once
 
 #include "steamnetworkingtypes.h"
 #include "steam_api_common.h"
@@ -78,7 +77,7 @@ public:
 	///   GetSessionConnectionInfo to get the details.)  In order to acknowledge the broken session
 	///   and start a new one, you must call CloseSessionWithUser
 	/// - See ISteamNetworkingSockets::SendMessageToConnection for more possible return values
-	virtual EResult SendMessageToUser( const SteamNetworkingIdentity &identityRemote, const void *pubData, uint32 cubData, int nSendFlags, int nRemoteChannel ) = 0;
+	virtual EResult SendMessageToUser( const SteamNetworkingIdentity *identityRemote, const void *pubData, uint32 cubData, int nSendFlags, int nRemoteChannel ) = 0;
 
 	/// Reads the next message that has been sent from another user via SendMessageToUser() on the given channel.
 	/// Returns number of messages returned into your list.  (0 if no message are available on that channel.)
@@ -96,20 +95,20 @@ public:
 	/// existing active session, this function will return true, even if it is not pending.
 	///
 	/// Calling SendMessageToUser() will implicitly accepts any pending session request to that user.
-	virtual bool AcceptSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0;
+	virtual bool AcceptSessionWithUser( const SteamNetworkingIdentity *identityRemote ) = 0;
 
 	/// Call this when you're done talking to a user to immediately free up resources under-the-hood.
 	/// If the remote user tries to send data to you again, another SteamNetworkingMessagesSessionRequest_t
 	/// callback will be posted.
 	///
 	/// Note that sessions that go unused for a few minutes are automatically timed out.
-	virtual bool CloseSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0;
+	virtual bool CloseSessionWithUser( const SteamNetworkingIdentity *identityRemote ) = 0;
 
 	/// Call this  when you're done talking to a user on a specific channel.  Once all
 	/// open channels to a user have been closed, the open session to the user will be
 	/// closed, and any new data from this user will trigger a
 	/// SteamSteamNetworkingMessagesSessionRequest_t callback
-	virtual bool CloseChannelWithUser( const SteamNetworkingIdentity &identityRemote, int nLocalChannel ) = 0;
+	virtual bool CloseChannelWithUser( const SteamNetworkingIdentity *identityRemote, int nLocalChannel ) = 0;
 
 	/// Returns information about the latest state of a connection, if any, with the given peer.
 	/// Primarily intended for debugging purposes, but can also be used to get more detailed
@@ -120,7 +119,7 @@ public:
 	/// you do not need the corresponding details.  Note that sessions time out after a while,
 	/// so if a connection fails, or SendMessageToUser returns k_EResultNoConnection, you cannot wait
 	/// indefinitely to obtain the reason for failure.
-	virtual ESteamNetworkingConnectionState GetSessionConnectionInfo( const SteamNetworkingIdentity &identityRemote, SteamNetConnectionInfo_t *pConnectionInfo, SteamNetworkingQuickConnectionStatus *pQuickStatus ) = 0;
+	virtual ESteamNetworkingConnectionState GetSessionConnectionInfo( const SteamNetworkingIdentity *identityRemote, SteamNetConnectionInfo_t *pConnectionInfo, SteamNetworkingQuickConnectionStatus *pQuickStatus ) = 0;
 };
 #define STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "SteamNetworkingMessages002"
 

lsteamclient/steamworks_sdk_151/isteamnetworkingsockets.h

@@ -2,7 +2,6 @@
 
 #ifndef ISTEAMNETWORKINGSOCKETS
 #define ISTEAMNETWORKINGSOCKETS
-#pragma once
 
 #include "steamnetworkingtypes.h"
 #include "steam_api_common.h"
@@ -57,7 +56,7 @@ public:
 	///
 	/// When a client attempts to connect, a SteamNetConnectionStatusChangedCallback_t
 	/// will be posted.  The connection will be in the connecting state.
-	virtual HSteamListenSocket CreateListenSocketIP( const SteamNetworkingIPAddr &localAddress, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
+	virtual HSteamListenSocket CreateListenSocketIP( const SteamNetworkingIPAddr *localAddress, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
 
 	/// Creates a connection and begins talking to a "server" over UDP at the
 	/// given IPv4 or IPv6 address.  The remote host must be listening with a
@@ -81,7 +80,7 @@ public:
 	/// If you need to set any initial config options, pass them here.  See
 	/// SteamNetworkingConfigValue_t for more about why this is preferable to
 	/// setting the options "immediately" after creation.
-	virtual HSteamNetConnection ConnectByIPAddress( const SteamNetworkingIPAddr &address, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
+	virtual HSteamNetConnection ConnectByIPAddress( const SteamNetworkingIPAddr *address, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
 
 	/// Like CreateListenSocketIP, but clients will connect using ConnectP2P.
 	///
@@ -119,7 +118,7 @@ public:
 	/// To use your own signaling service, see:
 	/// - ConnectP2PCustomSignaling
 	/// - k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling
-	virtual HSteamNetConnection ConnectP2P( const SteamNetworkingIdentity &identityRemote, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
+	virtual HSteamNetConnection ConnectP2P( const SteamNetworkingIdentity *identityRemote, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
 
 	/// Accept an incoming connection that has been received on a listen socket.
 	///
@@ -468,7 +467,7 @@ public:
 	///
 	/// Typically this is useful just to confirm that you have a ticket, before you
 	/// call ConnectToHostedDedicatedServer to connect to the server.
-	virtual int FindRelayAuthTicketForServer( const SteamNetworkingIdentity &identityGameServer, int nRemoteVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket ) = 0;
+	virtual int FindRelayAuthTicketForServer( const SteamNetworkingIdentity *identityGameServer, int nRemoteVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket ) = 0;
 
 	/// Client call to connect to a server hosted in a Valve data center, on the specified virtual
 	/// port.  You must have placed a ticket for this server into the cache, or else this connect
@@ -486,7 +485,7 @@ public:
 	/// If you need to set any initial config options, pass them here.  See
 	/// SteamNetworkingConfigValue_t for more about why this is preferable to
 	/// setting the options "immediately" after creation.
-	virtual HSteamNetConnection ConnectToHostedDedicatedServer( const SteamNetworkingIdentity &identityTarget, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
+	virtual HSteamNetConnection ConnectToHostedDedicatedServer( const SteamNetworkingIdentity *identityTarget, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
 
 	//
 	// Servers hosted in data centers known to the Valve relay network
@@ -665,11 +664,11 @@ public:
 	/// size.  (256 bytes is a very conservative estimate.)
 	///
 	/// Pass this blob to your game coordinator and call SteamDatagram_CreateCert.
-	virtual bool GetCertificateRequest( int *pcbBlob, void *pBlob, SteamNetworkingErrMsg &errMsg ) = 0;
+	virtual bool GetCertificateRequest( int *pcbBlob, void *pBlob, SteamNetworkingErrMsg *errMsg ) = 0;
 
 	/// Set the certificate.  The certificate blob should be the output of
 	/// SteamDatagram_CreateCert.
-	virtual bool SetCertificate( const void *pCertificate, int cbCertificate, SteamNetworkingErrMsg &errMsg ) = 0;
+	virtual bool SetCertificate( const void *pCertificate, int cbCertificate, SteamNetworkingErrMsg *errMsg ) = 0;
 
 	/// Invoke all callback functions queued for this interface.
 	/// See k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged, etc

lsteamclient/steamworks_sdk_151/isteamnetworkingutils.h

@@ -6,7 +6,6 @@
 
 #ifndef ISTEAMNETWORKINGUTILS
 #define ISTEAMNETWORKINGUTILS
-#pragma once
 
 #include "steamnetworkingtypes.h"
 #include "steam_api_common.h"
@@ -107,7 +106,7 @@ public:
 	///
 	/// This always return the most up-to-date information we have available
 	/// right now, even if we are in the middle of re-calculating ping times.
-	virtual float GetLocalPingLocation( SteamNetworkPingLocation_t &result ) = 0;
+	virtual float GetLocalPingLocation( SteamNetworkPingLocation_t *result ) = 0;
 
 	/// Estimate the round-trip latency between two arbitrary locations, in
 	/// milliseconds.  This is a conservative estimate, based on routing through
@@ -131,7 +130,7 @@ public:
 	///
 	/// Do you need to be able to do this from a backend/matchmaking server?
 	/// You are looking for the "ticketgen" library.
-	virtual int EstimatePingTimeBetweenTwoLocations( const SteamNetworkPingLocation_t &location1, const SteamNetworkPingLocation_t &location2 ) = 0;
+	virtual int EstimatePingTimeBetweenTwoLocations( const SteamNetworkPingLocation_t *location1, const SteamNetworkPingLocation_t *location2 ) = 0;
 
 	/// Same as EstimatePingTime, but assumes that one location is the local host.
 	/// This is a bit faster, especially if you need to calculate a bunch of
@@ -141,17 +140,17 @@ public:
 	/// GetLocalPingLocation with EstimatePingTimeBetweenTwoLocations.  That's because
 	/// this function uses a slightly more complete set of information about what
 	/// route would be taken.
-	virtual int EstimatePingTimeFromLocalHost( const SteamNetworkPingLocation_t &remoteLocation ) = 0;
+	virtual int EstimatePingTimeFromLocalHost( const SteamNetworkPingLocation_t *remoteLocation ) = 0;
 
 	/// Convert a ping location into a text format suitable for sending over the wire.
 	/// The format is a compact and human readable.  However, it is subject to change
 	/// so please do not parse it yourself.  Your buffer must be at least
 	/// k_cchMaxSteamNetworkingPingLocationString bytes.
-	virtual void ConvertPingLocationToString( const SteamNetworkPingLocation_t &location, char *pszBuf, int cchBufSize ) = 0;
+	virtual void ConvertPingLocationToString( const SteamNetworkPingLocation_t *location, char *pszBuf, int cchBufSize ) = 0;
 
 	/// Parse back SteamNetworkPingLocation_t string.  Returns false if we couldn't understand
 	/// the string.
-	virtual bool ParsePingLocationString( const char *pszString, SteamNetworkPingLocation_t &result ) = 0;
+	virtual bool ParsePingLocationString( const char *pszString, SteamNetworkPingLocation_t *result ) = 0;
 
 	/// Check if the ping data of sufficient recency is available, and if
 	/// it's too old, start refreshing it.
@@ -283,7 +282,7 @@ public:
 	/// (This is just a convenience shortcut; see below for the implementation and
 	/// a little insight into how SteamNetworkingConfigValue_t is used when
 	/// setting config options during listen socket and connection creation.)
-	bool SetConfigValueStruct( const SteamNetworkingConfigValue_t &opt, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj );
+	bool SetConfigValueStruct( const SteamNetworkingConfigValue_t *opt, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj );
 
 	/// Get a configuration value.
 	/// - eValue: which value to fetch
@@ -309,9 +308,9 @@ public:
 
 	// String conversions.  You'll usually access these using the respective
 	// inline methods.
-	virtual void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr &addr, char *buf, size_t cbBuf, bool bWithPort ) = 0;
+	virtual void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr *addr, char *buf, size_t cbBuf, bool bWithPort ) = 0;
 	virtual bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr ) = 0;
-	virtual void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity &identity, char *buf, size_t cbBuf ) = 0;
+	virtual void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity *identity, char *buf, size_t cbBuf ) = 0;
 	virtual bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, const char *pszStr ) = 0;
 
 protected:
@@ -385,6 +384,7 @@ struct SteamRelayNetworkStatus_t
 	char m_debugMsg[ 256 ];
 };
 
+#if 0
 /// Utility class for printing a SteamNetworkingIdentity.
 /// E.g. printf( "Identity is '%s'\n", SteamNetworkingIdentityRender( identity ).c_str() );
 struct SteamNetworkingIdentityRender
@@ -431,6 +431,7 @@ inline bool ISteamNetworkingUtils::SetConfigValueStruct( const SteamNetworkingCo
 	const void *pVal = ( opt.m_eDataType == k_ESteamNetworkingConfig_String ) ? (const void *)opt.m_val.m_string : (const void *)&opt.m_val;
 	return SetConfigValue( opt.m_eValue, eScopeType, scopeObj, opt.m_eDataType, pVal );
 }
+#endif
 
 // How to get helper functions.
 #if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) || defined( STEAMNETWORKINGSOCKETS_STANDALONELIB )
@@ -447,10 +448,12 @@ inline bool ISteamNetworkingUtils::SetConfigValueStruct( const SteamNetworkingCo
 
 #elif defined( STEAMNETWORKINGSOCKETS_STEAMAPI )
 	// Using steamworks SDK - go through SteamNetworkingUtils()
+#if 0
 	inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingUtils()->SteamNetworkingIPAddr_ToString( *this, buf, cbBuf, bWithPort ); }
 	inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIPAddr_ParseString( this, pszStr ); }
 	inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingUtils()->SteamNetworkingIdentity_ToString( *this, buf, cbBuf ); }
 	inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIdentity_ParseString( this, pszStr ); }
+#endif
 #else
 	#error "Invalid config"
 #endif

lsteamclient/steamworks_sdk_151/steamnetworkingtypes.h

@@ -6,7 +6,6 @@
 
 #ifndef STEAMNETWORKINGTYPES
 #define STEAMNETWORKINGTYPES
-#pragma once
 
 #include <string.h>
 #include <stdint.h>
@@ -221,7 +220,7 @@ struct SteamNetworkingIPAddr
 	{
 		uint8 m_ipv6[ 16 ];
 		IPv4MappedAddress m_ipv4;
-	};
+	} data;
 	uint16 m_port; // Host byte order
 
 	/// See if two addresses are identical
@@ -296,7 +295,7 @@ struct SteamNetworkingIdentity
 	// set.  (Use the accessors!)  This is important to enable old code to work
 	// with new identity types.
 	int m_cbSize;
-	union {
+	union data {
 		uint64 m_steamID64;
 		char m_szGenericString[ k_cchMaxGenericString ];
 		uint8 m_genericBytes[ k_cbMaxGenericBytes ];
@@ -1593,6 +1592,7 @@ private:
 typedef SteamNetworkingMessage_t ISteamNetworkingMessage;
 typedef SteamNetworkingErrMsg SteamDatagramErrMsg;
 
+#if 0
 inline void SteamNetworkingIPAddr::Clear() { memset( this, 0, sizeof(*this) ); }
 inline bool SteamNetworkingIPAddr::IsIPv6AllZeros() const { const uint64 *q = (const uint64 *)m_ipv6; return q[0] == 0 && q[1] == 0; }
 inline void SteamNetworkingIPAddr::SetIPv6( const uint8 *ipv6, uint16 nPort ) { memcpy( m_ipv6, ipv6, 16 ); m_port = nPort; }
@@ -1622,6 +1622,7 @@ inline const uint8 *SteamNetworkingIdentity::GetGenericBytes( int &cbLen ) const
 	cbLen = m_cbSize; return m_genericBytes; }
 inline bool SteamNetworkingIdentity::operator==(const SteamNetworkingIdentity &x ) const { return m_eType == x.m_eType && m_cbSize == x.m_cbSize && memcmp( m_genericBytes, x.m_genericBytes, m_cbSize ) == 0; }
 inline void SteamNetworkingMessage_t::Release() { (*m_pfnRelease)( this ); }
+#endif
 
 #endif // #ifndef API_GEN
 

lsteamclient/steamworks_sdk_151/steamtypes.h

@@ -194,7 +194,7 @@ enum ESteamIPType
 
 struct SteamIPAddress_t
 {
-	union {
+	union x {
 
 		uint32			m_unIPv4;		// Host order
 		uint8			m_rgubIPv6[16];		// Network order! Same as inaddr_in6.  (0011:2233:4455:6677:8899:aabb:ccdd:eeff)
@@ -207,53 +207,27 @@ struct SteamIPAddress_t
 
 	bool IsSet() const 
 	{ 
-		if ( k_ESteamIPTypeIPv4 == m_eType )
-		{
-			return m_unIPv4 != 0;
-		}
-		else 
-		{
-			return m_ipv6Qword[0] !=0 || m_ipv6Qword[1] != 0; 
-		}
+            return true;
 	}
 
 	static SteamIPAddress_t IPv4Any()
 	{
-		SteamIPAddress_t ipOut;
-		ipOut.m_eType = k_ESteamIPTypeIPv4;
-		ipOut.m_unIPv4 = 0;
-
-		return ipOut;
+            return {};
 	}
 
 	static SteamIPAddress_t IPv6Any()
 	{
-		SteamIPAddress_t ipOut;
-		ipOut.m_eType = k_ESteamIPTypeIPv6;
-		ipOut.m_ipv6Qword[0] = 0;
-		ipOut.m_ipv6Qword[1] = 0;
-
-		return ipOut;
+            return {};
 	}
 
 	static SteamIPAddress_t IPv4Loopback()
 	{
-		SteamIPAddress_t ipOut;
-		ipOut.m_eType = k_ESteamIPTypeIPv4;
-		ipOut.m_unIPv4 = 0x7f000001;
-
-		return ipOut;
+            return {};
 	}
 
 	static SteamIPAddress_t IPv6Loopback()
 	{
-		SteamIPAddress_t ipOut;
-		ipOut.m_eType = k_ESteamIPTypeIPv6;
-		ipOut.m_ipv6Qword[0] = 0;
-		ipOut.m_ipv6Qword[1] = 0;
-		ipOut.m_rgubIPv6[15] = 1;
-
-		return ipOut;
+            return {};
 	}
 };
 

lsteamclient/struct_converters.h

@@ -1,3 +1,90 @@
+#if defined(SDKVER_151) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winSteamPartyBeaconLocation_t_151 {
+    ESteamPartyBeaconLocationType m_eType;
+    uint64 m_ulLocationID;
+}  __attribute__ ((ms_struct));
+#pragma pack( pop )
+typedef struct winSteamPartyBeaconLocation_t_151 winSteamPartyBeaconLocation_t_151;
+struct SteamPartyBeaconLocation_t;
+extern void win_to_lin_struct_SteamPartyBeaconLocation_t_151(const struct winSteamPartyBeaconLocation_t_151 *w, struct SteamPartyBeaconLocation_t *l);
+extern void lin_to_win_struct_SteamPartyBeaconLocation_t_151(const struct SteamPartyBeaconLocation_t *l, struct winSteamPartyBeaconLocation_t_151 *w);
+#endif
+
+#if defined(SDKVER_151) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winLeaderboardEntry_t_151 {
+    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_151 winLeaderboardEntry_t_151;
+struct LeaderboardEntry_t;
+extern void win_to_lin_struct_LeaderboardEntry_t_151(const struct winLeaderboardEntry_t_151 *w, struct LeaderboardEntry_t *l);
+extern void lin_to_win_struct_LeaderboardEntry_t_151(const struct LeaderboardEntry_t *l, struct winLeaderboardEntry_t_151 *w);
+#endif
+
+#if defined(SDKVER_151) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winSteamUGCDetails_t_151 {
+    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_151 winSteamUGCDetails_t_151;
+struct SteamUGCDetails_t;
+extern void win_to_lin_struct_SteamUGCDetails_t_151(const struct winSteamUGCDetails_t_151 *w, struct SteamUGCDetails_t *l);
+extern void lin_to_win_struct_SteamUGCDetails_t_151(const struct SteamUGCDetails_t *l, struct winSteamUGCDetails_t_151 *w);
+#endif
+
+#if defined(SDKVER_151) || !defined(__cplusplus)
+#pragma pack( push, 8 )
+struct winSteamNetworkingMessage_t_151 {
+    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_151 winSteamNetworkingMessage_t_151;
+struct SteamNetworkingMessage_t;
+#endif
+
 #if defined(SDKVER_150) || !defined(__cplusplus)
 #pragma pack( push, 8 )
 struct winSteamPartyBeaconLocation_t_150 {

lsteamclient/winISteamController.c

@@ -15,6 +15,311 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamController_SteamController008.h"
+
+typedef struct __winISteamController_SteamController008 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamController_SteamController008;
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_Init, 4)
+bool __thiscall winISteamController_SteamController008_Init(winISteamController_SteamController008 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_Init(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_Shutdown, 4)
+bool __thiscall winISteamController_SteamController008_Shutdown(winISteamController_SteamController008 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_Shutdown(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_RunFrame, 4)
+void __thiscall winISteamController_SteamController008_RunFrame(winISteamController_SteamController008 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_RunFrame(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetConnectedControllers, 8)
+int __thiscall winISteamController_SteamController008_GetConnectedControllers(winISteamController_SteamController008 *_this, ControllerHandle_t * handlesOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetConnectedControllers(_this->linux_side, handlesOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetActionSetHandle, 8)
+ControllerActionSetHandle_t __thiscall winISteamController_SteamController008_GetActionSetHandle(winISteamController_SteamController008 *_this, const char * pszActionSetName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetActionSetHandle(_this->linux_side, pszActionSetName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_ActivateActionSet, 20)
+void __thiscall winISteamController_SteamController008_ActivateActionSet(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_ActivateActionSet(_this->linux_side, controllerHandle, actionSetHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetCurrentActionSet, 12)
+ControllerActionSetHandle_t __thiscall winISteamController_SteamController008_GetCurrentActionSet(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetCurrentActionSet(_this->linux_side, controllerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_ActivateActionSetLayer, 20)
+void __thiscall winISteamController_SteamController008_ActivateActionSetLayer(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_ActivateActionSetLayer(_this->linux_side, controllerHandle, actionSetLayerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_DeactivateActionSetLayer, 20)
+void __thiscall winISteamController_SteamController008_DeactivateActionSetLayer(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_DeactivateActionSetLayer(_this->linux_side, controllerHandle, actionSetLayerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_DeactivateAllActionSetLayers, 12)
+void __thiscall winISteamController_SteamController008_DeactivateAllActionSetLayers(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_DeactivateAllActionSetLayers(_this->linux_side, controllerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetActiveActionSetLayers, 16)
+int __thiscall winISteamController_SteamController008_GetActiveActionSetLayers(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t * handlesOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetActiveActionSetLayers(_this->linux_side, controllerHandle, handlesOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetDigitalActionHandle, 8)
+ControllerDigitalActionHandle_t __thiscall winISteamController_SteamController008_GetDigitalActionHandle(winISteamController_SteamController008 *_this, const char * pszActionName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetDigitalActionHandle(_this->linux_side, pszActionName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetDigitalActionData, 24)
+InputDigitalActionData_t *__thiscall winISteamController_SteamController008_GetDigitalActionData(winISteamController_SteamController008 *_this, InputDigitalActionData_t *_r, ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamController_SteamController008_GetDigitalActionData(_this->linux_side, controllerHandle, digitalActionHandle);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetDigitalActionOrigins, 32)
+int __thiscall winISteamController_SteamController008_GetDigitalActionOrigins(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, EControllerActionOrigin * originsOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetDigitalActionOrigins(_this->linux_side, controllerHandle, actionSetHandle, digitalActionHandle, originsOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetAnalogActionHandle, 8)
+ControllerAnalogActionHandle_t __thiscall winISteamController_SteamController008_GetAnalogActionHandle(winISteamController_SteamController008 *_this, const char * pszActionName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetAnalogActionHandle(_this->linux_side, pszActionName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetAnalogActionData, 24)
+InputAnalogActionData_t *__thiscall winISteamController_SteamController008_GetAnalogActionData(winISteamController_SteamController008 *_this, InputAnalogActionData_t *_r, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamController_SteamController008_GetAnalogActionData(_this->linux_side, controllerHandle, analogActionHandle);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetAnalogActionOrigins, 32)
+int __thiscall winISteamController_SteamController008_GetAnalogActionOrigins(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, EControllerActionOrigin * originsOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetAnalogActionOrigins(_this->linux_side, controllerHandle, actionSetHandle, analogActionHandle, originsOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetGlyphForActionOrigin, 8)
+const char * __thiscall winISteamController_SteamController008_GetGlyphForActionOrigin(winISteamController_SteamController008 *_this, EControllerActionOrigin eOrigin)
+{
+    const char *path_result;
+    TRACE("%p\n", _this);
+    path_result = cppISteamController_SteamController008_GetGlyphForActionOrigin(_this->linux_side, eOrigin);
+    path_result = steamclient_isteamcontroller_getglyph(eOrigin, path_result);
+    return path_result;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetStringForActionOrigin, 8)
+const char * __thiscall winISteamController_SteamController008_GetStringForActionOrigin(winISteamController_SteamController008 *_this, EControllerActionOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetStringForActionOrigin(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_StopAnalogActionMomentum, 20)
+void __thiscall winISteamController_SteamController008_StopAnalogActionMomentum(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_StopAnalogActionMomentum(_this->linux_side, controllerHandle, eAction);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetMotionData, 16)
+InputMotionData_t *__thiscall winISteamController_SteamController008_GetMotionData(winISteamController_SteamController008 *_this, InputMotionData_t *_r, ControllerHandle_t controllerHandle)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamController_SteamController008_GetMotionData(_this->linux_side, controllerHandle);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_TriggerHapticPulse, 20)
+void __thiscall winISteamController_SteamController008_TriggerHapticPulse(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_TriggerHapticPulse(_this->linux_side, controllerHandle, eTargetPad, usDurationMicroSec);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_TriggerRepeatedHapticPulse, 32)
+void __thiscall winISteamController_SteamController008_TriggerRepeatedHapticPulse(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_TriggerRepeatedHapticPulse(_this->linux_side, controllerHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_TriggerVibration, 20)
+void __thiscall winISteamController_SteamController008_TriggerVibration(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_TriggerVibration(_this->linux_side, controllerHandle, usLeftSpeed, usRightSpeed);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_SetLEDColor, 28)
+void __thiscall winISteamController_SteamController008_SetLEDColor(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags)
+{
+    TRACE("%p\n", _this);
+    cppISteamController_SteamController008_SetLEDColor(_this->linux_side, controllerHandle, nColorR, nColorG, nColorB, nFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_ShowBindingPanel, 12)
+bool __thiscall winISteamController_SteamController008_ShowBindingPanel(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_ShowBindingPanel(_this->linux_side, controllerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetInputTypeForHandle, 12)
+ESteamInputType __thiscall winISteamController_SteamController008_GetInputTypeForHandle(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetInputTypeForHandle(_this->linux_side, controllerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetControllerForGamepadIndex, 8)
+ControllerHandle_t __thiscall winISteamController_SteamController008_GetControllerForGamepadIndex(winISteamController_SteamController008 *_this, int nIndex)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetControllerForGamepadIndex(_this->linux_side, nIndex);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetGamepadIndexForController, 12)
+int __thiscall winISteamController_SteamController008_GetGamepadIndexForController(winISteamController_SteamController008 *_this, ControllerHandle_t ulControllerHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetGamepadIndexForController(_this->linux_side, ulControllerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetStringForXboxOrigin, 8)
+const char * __thiscall winISteamController_SteamController008_GetStringForXboxOrigin(winISteamController_SteamController008 *_this, EXboxOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetStringForXboxOrigin(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetGlyphForXboxOrigin, 8)
+const char * __thiscall winISteamController_SteamController008_GetGlyphForXboxOrigin(winISteamController_SteamController008 *_this, EXboxOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetGlyphForXboxOrigin(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetActionOriginFromXboxOrigin, 16)
+EControllerActionOrigin __thiscall winISteamController_SteamController008_GetActionOriginFromXboxOrigin(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, EXboxOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetActionOriginFromXboxOrigin(_this->linux_side, controllerHandle, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_TranslateActionOrigin, 12)
+EControllerActionOrigin __thiscall winISteamController_SteamController008_TranslateActionOrigin(winISteamController_SteamController008 *_this, ESteamInputType eDestinationInputType, EControllerActionOrigin eSourceOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_TranslateActionOrigin(_this->linux_side, eDestinationInputType, eSourceOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamController_SteamController008_GetControllerBindingRevision, 20)
+bool __thiscall winISteamController_SteamController008_GetControllerBindingRevision(winISteamController_SteamController008 *_this, ControllerHandle_t controllerHandle, int * pMajor, int * pMinor)
+{
+    TRACE("%p\n", _this);
+    return cppISteamController_SteamController008_GetControllerBindingRevision(_this->linux_side, controllerHandle, pMajor, pMinor);
+}
+
+extern vtable_ptr winISteamController_SteamController008_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamController_SteamController008,
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_Init)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_Shutdown)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_RunFrame)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetConnectedControllers)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetActionSetHandle)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_ActivateActionSet)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetCurrentActionSet)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_ActivateActionSetLayer)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_DeactivateActionSetLayer)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_DeactivateAllActionSetLayers)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetActiveActionSetLayers)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetDigitalActionHandle)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetDigitalActionData)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetDigitalActionOrigins)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetAnalogActionHandle)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetAnalogActionData)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetAnalogActionOrigins)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetGlyphForActionOrigin)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetStringForActionOrigin)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_StopAnalogActionMomentum)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetMotionData)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_TriggerHapticPulse)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_TriggerRepeatedHapticPulse)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_TriggerVibration)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_SetLEDColor)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_ShowBindingPanel)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetInputTypeForHandle)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetControllerForGamepadIndex)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetGamepadIndexForController)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetStringForXboxOrigin)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetGlyphForXboxOrigin)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetActionOriginFromXboxOrigin)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_TranslateActionOrigin)
+        VTABLE_ADD_FUNC(winISteamController_SteamController008_GetControllerBindingRevision)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamController_SteamController008 *create_winISteamController_SteamController008(void *linux_side)
+{
+    winISteamController_SteamController008 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamController_SteamController008));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamController_SteamController008_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamController_SteamController007.h"
 
 typedef struct __winISteamController_SteamController007 {

lsteamclient/winISteamFriends.c

@@ -554,6 +554,13 @@ bool __thiscall winISteamFriends_SteamFriends017_RegisterProtocolInOverlayBrowse
     return cppISteamFriends_SteamFriends017_RegisterProtocolInOverlayBrowser(_this->linux_side, pchProtocol);
 }
 
+DEFINE_THISCALL_WRAPPER(winISteamFriends_SteamFriends017_ActivateGameOverlayInviteDialogConnectString, 8)
+void __thiscall winISteamFriends_SteamFriends017_ActivateGameOverlayInviteDialogConnectString(winISteamFriends_SteamFriends017 *_this, const char * pchConnectString)
+{
+    TRACE("%p\n", _this);
+    cppISteamFriends_SteamFriends017_ActivateGameOverlayInviteDialogConnectString(_this->linux_side, pchConnectString);
+}
+
 extern vtable_ptr winISteamFriends_SteamFriends017_vtable;
 
 #ifndef __GNUC__
@@ -635,6 +642,7 @@ void __asm_dummy_vtables(void) {
         VTABLE_ADD_FUNC(winISteamFriends_SteamFriends017_GetNumChatsWithUnreadPriorityMessages)
         VTABLE_ADD_FUNC(winISteamFriends_SteamFriends017_ActivateGameOverlayRemotePlayTogetherInviteDialog)
         VTABLE_ADD_FUNC(winISteamFriends_SteamFriends017_RegisterProtocolInOverlayBrowser)
+        VTABLE_ADD_FUNC(winISteamFriends_SteamFriends017_ActivateGameOverlayInviteDialogConnectString)
     );
 #ifndef __GNUC__
 }

lsteamclient/winISteamInput.c

@@ -15,6 +15,319 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamInput_SteamInput002.h"
+
+typedef struct __winISteamInput_SteamInput002 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamInput_SteamInput002;
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_Init, 4)
+bool __thiscall winISteamInput_SteamInput002_Init(winISteamInput_SteamInput002 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_Init(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_Shutdown, 4)
+bool __thiscall winISteamInput_SteamInput002_Shutdown(winISteamInput_SteamInput002 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_Shutdown(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_RunFrame, 4)
+void __thiscall winISteamInput_SteamInput002_RunFrame(winISteamInput_SteamInput002 *_this)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_RunFrame(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetConnectedControllers, 8)
+int __thiscall winISteamInput_SteamInput002_GetConnectedControllers(winISteamInput_SteamInput002 *_this, InputHandle_t * handlesOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetConnectedControllers(_this->linux_side, handlesOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetActionSetHandle, 8)
+InputActionSetHandle_t __thiscall winISteamInput_SteamInput002_GetActionSetHandle(winISteamInput_SteamInput002 *_this, const char * pszActionSetName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetActionSetHandle(_this->linux_side, pszActionSetName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_ActivateActionSet, 20)
+void __thiscall winISteamInput_SteamInput002_ActivateActionSet(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_ActivateActionSet(_this->linux_side, inputHandle, actionSetHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetCurrentActionSet, 12)
+InputActionSetHandle_t __thiscall winISteamInput_SteamInput002_GetCurrentActionSet(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetCurrentActionSet(_this->linux_side, inputHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_ActivateActionSetLayer, 20)
+void __thiscall winISteamInput_SteamInput002_ActivateActionSetLayer(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_ActivateActionSetLayer(_this->linux_side, inputHandle, actionSetLayerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_DeactivateActionSetLayer, 20)
+void __thiscall winISteamInput_SteamInput002_DeactivateActionSetLayer(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_DeactivateActionSetLayer(_this->linux_side, inputHandle, actionSetLayerHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_DeactivateAllActionSetLayers, 12)
+void __thiscall winISteamInput_SteamInput002_DeactivateAllActionSetLayers(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_DeactivateAllActionSetLayers(_this->linux_side, inputHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetActiveActionSetLayers, 16)
+int __thiscall winISteamInput_SteamInput002_GetActiveActionSetLayers(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, InputActionSetHandle_t * handlesOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetActiveActionSetLayers(_this->linux_side, inputHandle, handlesOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetDigitalActionHandle, 8)
+InputDigitalActionHandle_t __thiscall winISteamInput_SteamInput002_GetDigitalActionHandle(winISteamInput_SteamInput002 *_this, const char * pszActionName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetDigitalActionHandle(_this->linux_side, pszActionName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetDigitalActionData, 24)
+InputDigitalActionData_t *__thiscall winISteamInput_SteamInput002_GetDigitalActionData(winISteamInput_SteamInput002 *_this, InputDigitalActionData_t *_r, InputHandle_t inputHandle, InputDigitalActionHandle_t digitalActionHandle)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamInput_SteamInput002_GetDigitalActionData(_this->linux_side, inputHandle, digitalActionHandle);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetDigitalActionOrigins, 32)
+int __thiscall winISteamInput_SteamInput002_GetDigitalActionOrigins(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, EInputActionOrigin * originsOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetDigitalActionOrigins(_this->linux_side, inputHandle, actionSetHandle, digitalActionHandle, originsOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetAnalogActionHandle, 8)
+InputAnalogActionHandle_t __thiscall winISteamInput_SteamInput002_GetAnalogActionHandle(winISteamInput_SteamInput002 *_this, const char * pszActionName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetAnalogActionHandle(_this->linux_side, pszActionName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetAnalogActionData, 24)
+InputAnalogActionData_t *__thiscall winISteamInput_SteamInput002_GetAnalogActionData(winISteamInput_SteamInput002 *_this, InputAnalogActionData_t *_r, InputHandle_t inputHandle, InputAnalogActionHandle_t analogActionHandle)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamInput_SteamInput002_GetAnalogActionData(_this->linux_side, inputHandle, analogActionHandle);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetAnalogActionOrigins, 32)
+int __thiscall winISteamInput_SteamInput002_GetAnalogActionOrigins(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, EInputActionOrigin * originsOut)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetAnalogActionOrigins(_this->linux_side, inputHandle, actionSetHandle, analogActionHandle, originsOut);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetGlyphForActionOrigin, 8)
+const char * __thiscall winISteamInput_SteamInput002_GetGlyphForActionOrigin(winISteamInput_SteamInput002 *_this, EInputActionOrigin eOrigin)
+{
+    const char *path_result;
+    TRACE("%p\n", _this);
+    path_result = cppISteamInput_SteamInput002_GetGlyphForActionOrigin(_this->linux_side, eOrigin);
+    path_result = steamclient_isteamcontroller_getglyph(eOrigin, path_result);
+    return path_result;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetStringForActionOrigin, 8)
+const char * __thiscall winISteamInput_SteamInput002_GetStringForActionOrigin(winISteamInput_SteamInput002 *_this, EInputActionOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetStringForActionOrigin(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_StopAnalogActionMomentum, 20)
+void __thiscall winISteamInput_SteamInput002_StopAnalogActionMomentum(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, InputAnalogActionHandle_t eAction)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_StopAnalogActionMomentum(_this->linux_side, inputHandle, eAction);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetMotionData, 16)
+InputMotionData_t *__thiscall winISteamInput_SteamInput002_GetMotionData(winISteamInput_SteamInput002 *_this, InputMotionData_t *_r, InputHandle_t inputHandle)
+{
+    TRACE("%p\n", _this);
+    *_r = cppISteamInput_SteamInput002_GetMotionData(_this->linux_side, inputHandle);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_TriggerVibration, 20)
+void __thiscall winISteamInput_SteamInput002_TriggerVibration(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_TriggerVibration(_this->linux_side, inputHandle, usLeftSpeed, usRightSpeed);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_SetLEDColor, 28)
+void __thiscall winISteamInput_SteamInput002_SetLEDColor(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_SetLEDColor(_this->linux_side, inputHandle, nColorR, nColorG, nColorB, nFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_TriggerHapticPulse, 20)
+void __thiscall winISteamInput_SteamInput002_TriggerHapticPulse(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_TriggerHapticPulse(_this->linux_side, inputHandle, eTargetPad, usDurationMicroSec);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_TriggerRepeatedHapticPulse, 32)
+void __thiscall winISteamInput_SteamInput002_TriggerRepeatedHapticPulse(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags)
+{
+    TRACE("%p\n", _this);
+    cppISteamInput_SteamInput002_TriggerRepeatedHapticPulse(_this->linux_side, inputHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_ShowBindingPanel, 12)
+bool __thiscall winISteamInput_SteamInput002_ShowBindingPanel(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_ShowBindingPanel(_this->linux_side, inputHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetInputTypeForHandle, 12)
+ESteamInputType __thiscall winISteamInput_SteamInput002_GetInputTypeForHandle(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetInputTypeForHandle(_this->linux_side, inputHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetControllerForGamepadIndex, 8)
+InputHandle_t __thiscall winISteamInput_SteamInput002_GetControllerForGamepadIndex(winISteamInput_SteamInput002 *_this, int nIndex)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetControllerForGamepadIndex(_this->linux_side, nIndex);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetGamepadIndexForController, 12)
+int __thiscall winISteamInput_SteamInput002_GetGamepadIndexForController(winISteamInput_SteamInput002 *_this, InputHandle_t ulinputHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetGamepadIndexForController(_this->linux_side, ulinputHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetStringForXboxOrigin, 8)
+const char * __thiscall winISteamInput_SteamInput002_GetStringForXboxOrigin(winISteamInput_SteamInput002 *_this, EXboxOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetStringForXboxOrigin(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetGlyphForXboxOrigin, 8)
+const char * __thiscall winISteamInput_SteamInput002_GetGlyphForXboxOrigin(winISteamInput_SteamInput002 *_this, EXboxOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetGlyphForXboxOrigin(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetActionOriginFromXboxOrigin, 16)
+EInputActionOrigin __thiscall winISteamInput_SteamInput002_GetActionOriginFromXboxOrigin(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, EXboxOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetActionOriginFromXboxOrigin(_this->linux_side, inputHandle, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_TranslateActionOrigin, 12)
+EInputActionOrigin __thiscall winISteamInput_SteamInput002_TranslateActionOrigin(winISteamInput_SteamInput002 *_this, ESteamInputType eDestinationInputType, EInputActionOrigin eSourceOrigin)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_TranslateActionOrigin(_this->linux_side, eDestinationInputType, eSourceOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetDeviceBindingRevision, 20)
+bool __thiscall winISteamInput_SteamInput002_GetDeviceBindingRevision(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle, int * pMajor, int * pMinor)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetDeviceBindingRevision(_this->linux_side, inputHandle, pMajor, pMinor);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamInput_SteamInput002_GetRemotePlaySessionID, 12)
+uint32 __thiscall winISteamInput_SteamInput002_GetRemotePlaySessionID(winISteamInput_SteamInput002 *_this, InputHandle_t inputHandle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamInput_SteamInput002_GetRemotePlaySessionID(_this->linux_side, inputHandle);
+}
+
+extern vtable_ptr winISteamInput_SteamInput002_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamInput_SteamInput002,
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_Init)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_Shutdown)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_RunFrame)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetConnectedControllers)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetActionSetHandle)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_ActivateActionSet)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetCurrentActionSet)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_ActivateActionSetLayer)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_DeactivateActionSetLayer)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_DeactivateAllActionSetLayers)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetActiveActionSetLayers)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetDigitalActionHandle)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetDigitalActionData)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetDigitalActionOrigins)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetAnalogActionHandle)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetAnalogActionData)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetAnalogActionOrigins)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetGlyphForActionOrigin)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetStringForActionOrigin)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_StopAnalogActionMomentum)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetMotionData)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_TriggerVibration)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_SetLEDColor)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_TriggerHapticPulse)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_TriggerRepeatedHapticPulse)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_ShowBindingPanel)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetInputTypeForHandle)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetControllerForGamepadIndex)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetGamepadIndexForController)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetStringForXboxOrigin)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetGlyphForXboxOrigin)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetActionOriginFromXboxOrigin)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_TranslateActionOrigin)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetDeviceBindingRevision)
+        VTABLE_ADD_FUNC(winISteamInput_SteamInput002_GetRemotePlaySessionID)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamInput_SteamInput002 *create_winISteamInput_SteamInput002(void *linux_side)
+{
+    winISteamInput_SteamInput002 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamInput_SteamInput002));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamInput_SteamInput002_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamInput_SteamInput001.h"
 
 typedef struct __winISteamInput_SteamInput001 {

lsteamclient/winISteamNetworkingMessages.c

@@ -30,7 +30,7 @@ EResult __thiscall winISteamNetworkingMessages_SteamNetworkingMessages002_SendMe
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamNetworkingMessages_SteamNetworkingMessages002_ReceiveMessagesOnChannel, 16)
-int __thiscall winISteamNetworkingMessages_SteamNetworkingMessages002_ReceiveMessagesOnChannel(winISteamNetworkingMessages_SteamNetworkingMessages002 *_this, int nLocalChannel, winSteamNetworkingMessage_t_150 ** ppOutMessages, int nMaxMessages)
+int __thiscall winISteamNetworkingMessages_SteamNetworkingMessages002_ReceiveMessagesOnChannel(winISteamNetworkingMessages_SteamNetworkingMessages002 *_this, int nLocalChannel, winSteamNetworkingMessage_t_151 ** ppOutMessages, int nMaxMessages)
 {
     TRACE("%p\n", _this);
     return cppISteamNetworkingMessages_SteamNetworkingMessages002_ReceiveMessagesOnChannel(_this->linux_side, nLocalChannel, ppOutMessages, nMaxMessages);

lsteamclient/winISteamNetworkingSockets.c

@@ -107,7 +107,7 @@ EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_SendMess
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets009_SendMessages, 16)
-void __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_SendMessages(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, int nMessages, winSteamNetworkingMessage_t_150 *const * pMessages, int64 * pOutMessageNumberOrResult)
+void __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_SendMessages(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, int nMessages, winSteamNetworkingMessage_t_151 *const * pMessages, int64 * pOutMessageNumberOrResult)
 {
     TRACE("%p\n", _this);
     cppISteamNetworkingSockets_SteamNetworkingSockets009_SendMessages(_this->linux_side, nMessages, pMessages, pOutMessageNumberOrResult);
@@ -121,7 +121,7 @@ EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_FlushMes
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnConnection, 16)
-int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnConnection(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, HSteamNetConnection hConn, winSteamNetworkingMessage_t_150 ** ppOutMessages, int nMaxMessages)
+int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnConnection(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, HSteamNetConnection hConn, winSteamNetworkingMessage_t_151 ** ppOutMessages, int nMaxMessages)
 {
     TRACE("%p\n", _this);
     return cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnConnection(_this->linux_side, hConn, ppOutMessages, nMaxMessages);
@@ -205,7 +205,7 @@ bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_SetConnecti
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnPollGroup, 16)
-int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnPollGroup(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, HSteamNetPollGroup hPollGroup, winSteamNetworkingMessage_t_150 ** ppOutMessages, int nMaxMessages)
+int __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnPollGroup(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, HSteamNetPollGroup hPollGroup, winSteamNetworkingMessage_t_151 ** ppOutMessages, int nMaxMessages)
 {
     TRACE("%p\n", _this);
     return cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceiveMessagesOnPollGroup(_this->linux_side, hPollGroup, ppOutMessages, nMaxMessages);
@@ -268,14 +268,14 @@ EResult __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_GetGameC
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling, 24)
-HSteamNetConnection __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, ISteamNetworkingConnectionCustomSignaling * pSignaling, const SteamNetworkingIdentity * pPeerIdentity, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
+HSteamNetConnection __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, ISteamNetworkingConnectionSignaling * pSignaling, const SteamNetworkingIdentity * pPeerIdentity, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t * pOptions)
 {
     TRACE("%p\n", _this);
     return cppISteamNetworkingSockets_SteamNetworkingSockets009_ConnectP2PCustomSignaling(_this->linux_side, pSignaling, pPeerIdentity, nRemoteVirtualPort, nOptions, pOptions);
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal, 16)
-bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, const void * pMsg, int cbMsg, ISteamNetworkingCustomSignalingRecvContext * pContext)
+bool __thiscall winISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal(winISteamNetworkingSockets_SteamNetworkingSockets009 *_this, const void * pMsg, int cbMsg, ISteamNetworkingSignalingRecvContext * pContext)
 {
     TRACE("%p\n", _this);
     return cppISteamNetworkingSockets_SteamNetworkingSockets009_ReceivedP2PCustomSignal(_this->linux_side, pMsg, cbMsg, pContext);

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_150 * pLocation, char * pchMetadata, int cchMetadata)
+bool __thiscall winISteamParties_SteamParties002_GetBeaconDetails(winISteamParties_SteamParties002 *_this, PartyBeaconID_t ulBeaconID, CSteamID * pSteamIDBeaconOwner, winSteamPartyBeaconLocation_t_151 * 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_150 * pLocationList, uint32 uMaxNumLocations)
+bool __thiscall winISteamParties_SteamParties002_GetAvailableBeaconLocations(winISteamParties_SteamParties002 *_this, winSteamPartyBeaconLocation_t_151 * 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_150 * pBeaconLocation, const char * pchConnectString, const char * pchMetadata)
+SteamAPICall_t __thiscall winISteamParties_SteamParties002_CreateBeacon(winISteamParties_SteamParties002 *_this, uint32 unOpenSlots, winSteamPartyBeaconLocation_t_151 * 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_150 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
+bool __thiscall winISteamParties_SteamParties002_GetBeaconLocationData(winISteamParties_SteamParties002 *_this, winSteamPartyBeaconLocation_t_151 BeaconLocation, ESteamPartyBeaconLocationData eData, char * pchDataStringOut, int cchDataStringOut)
 {
     TRACE("%p\n", _this);
     return cppISteamParties_SteamParties002_GetBeaconLocationData(_this->linux_side, BeaconLocation, eData, pchDataStringOut, cchDataStringOut);

lsteamclient/winISteamUGC.c

@@ -15,6 +15,705 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(steamclient);
 
+#include "cppISteamUGC_STEAMUGC_INTERFACE_VERSION015.h"
+
+typedef struct __winISteamUGC_STEAMUGC_INTERFACE_VERSION015 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winISteamUGC_STEAMUGC_INTERFACE_VERSION015;
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUserUGCRequest, 32)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUserUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_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_VERSION015_CreateQueryUserUGCRequest(_this->linux_side, unAccountID, eListType, eMatchingUGCType, eSortOrder, nCreatorAppID, nConsumerAppID, unPage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest, 24)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest(_this->linux_side, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, unPage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest_2, 24)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest_2(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest_2(_this->linux_side, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUGCDetailsRequest, 12)
+UGCQueryHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUGCDetailsRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUGCDetailsRequest(_this->linux_side, pvecPublishedFileID, unNumPublishedFileIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SendQueryUGCRequest, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SendQueryUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SendQueryUGCRequest(_this->linux_side, handle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCResult, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCResult(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, winSteamUGCDetails_t_151 * pDetails)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCResult(_this->linux_side, handle, index, pDetails);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumTags, 16)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumTags(_this->linux_side, handle, index);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTag, 28)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTag(_this->linux_side, handle, index, indexTag, pchValue, cchValueSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTagDisplayName, 28)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTagDisplayName(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTagDisplayName(_this->linux_side, handle, index, indexTag, pchValue, cchValueSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCPreviewURL, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCPreviewURL(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, char * pchURL, uint32 cchURLSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCPreviewURL(_this->linux_side, handle, index, pchURL, cchURLSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCMetadata, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCMetadata(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, char * pchMetadata, uint32 cchMetadatasize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCMetadata(_this->linux_side, handle, index, pchMetadata, cchMetadatasize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCChildren, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCChildren(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCChildren(_this->linux_side, handle, index, pvecPublishedFileID, cMaxEntries);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCStatistic, 24)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCStatistic(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 * pStatValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCStatistic(_this->linux_side, handle, index, eStatType, pStatValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumAdditionalPreviews, 16)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumAdditionalPreviews(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumAdditionalPreviews(_this->linux_side, handle, index);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCAdditionalPreview, 40)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCAdditionalPreview(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_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_VERSION015_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_VERSION015_GetQueryUGCNumKeyValueTags, 16)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumKeyValueTags(_this->linux_side, handle, index);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag, 36)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char * pchKey, uint32 cchKeySize, char * pchValue, uint32 cchValueSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag(_this->linux_side, handle, index, keyValueTagIndex, pchKey, cchKeySize, pchValue, cchValueSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag_2, 28)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag_2(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 index, const char * pchKey, char * pchValue, uint32 cchValueSize)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag_2(_this->linux_side, handle, index, pchKey, pchValue, cchValueSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_ReleaseQueryUGCRequest, 12)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_ReleaseQueryUGCRequest(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_ReleaseQueryUGCRequest(_this->linux_side, handle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTag, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, const char * pTagName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTag(_this->linux_side, handle, pTagName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTagGroup, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTagGroup(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, const SteamParamStringArray_t * pTagGroups)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTagGroup(_this->linux_side, handle, pTagGroups);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddExcludedTag, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddExcludedTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, const char * pTagName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddExcludedTag(_this->linux_side, handle, pTagName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnOnlyIDs, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnOnlyIDs(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bReturnOnlyIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnOnlyIDs(_this->linux_side, handle, bReturnOnlyIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnKeyValueTags, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bReturnKeyValueTags)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnKeyValueTags(_this->linux_side, handle, bReturnKeyValueTags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnLongDescription, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnLongDescription(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bReturnLongDescription)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnLongDescription(_this->linux_side, handle, bReturnLongDescription);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnMetadata, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnMetadata(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bReturnMetadata)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnMetadata(_this->linux_side, handle, bReturnMetadata);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnChildren, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnChildren(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bReturnChildren)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnChildren(_this->linux_side, handle, bReturnChildren);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnAdditionalPreviews, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnAdditionalPreviews(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bReturnAdditionalPreviews)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnAdditionalPreviews(_this->linux_side, handle, bReturnAdditionalPreviews);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnTotalOnly, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnTotalOnly(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bReturnTotalOnly)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnTotalOnly(_this->linux_side, handle, bReturnTotalOnly);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnPlaytimeStats, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnPlaytimeStats(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 unDays)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnPlaytimeStats(_this->linux_side, handle, unDays);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetLanguage, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetLanguage(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, const char * pchLanguage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetLanguage(_this->linux_side, handle, pchLanguage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowCachedResponse, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowCachedResponse(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 unMaxAgeSeconds)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowCachedResponse(_this->linux_side, handle, unMaxAgeSeconds);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetCloudFileNameFilter, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetCloudFileNameFilter(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, const char * pMatchCloudFileName)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetCloudFileNameFilter(_this->linux_side, handle, pMatchCloudFileName);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetMatchAnyTag, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetMatchAnyTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, bool bMatchAnyTag)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetMatchAnyTag(_this->linux_side, handle, bMatchAnyTag);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetSearchText, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetSearchText(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, const char * pSearchText)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetSearchText(_this->linux_side, handle, pSearchText);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetRankedByTrendDays, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetRankedByTrendDays(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, uint32 unDays)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetRankedByTrendDays(_this->linux_side, handle, unDays);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredKeyValueTag, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredKeyValueTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCQueryHandle_t handle, const char * pKey, const char * pValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredKeyValueTag(_this->linux_side, handle, pKey, pValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RequestUGCDetails, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RequestUGCDetails(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RequestUGCDetails(_this->linux_side, nPublishedFileID, unMaxAgeSeconds);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, AppId_t nConsumerAppId, EWorkshopFileType eFileType)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateItem(_this->linux_side, nConsumerAppId, eFileType);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartItemUpdate, 16)
+UGCUpdateHandle_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartItemUpdate(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartItemUpdate(_this->linux_side, nConsumerAppId, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTitle, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTitle(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pchTitle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTitle(_this->linux_side, handle, pchTitle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemDescription, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemDescription(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pchDescription)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemDescription(_this->linux_side, handle, pchDescription);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemUpdateLanguage, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemUpdateLanguage(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pchLanguage)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemUpdateLanguage(_this->linux_side, handle, pchLanguage);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemMetadata, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemMetadata(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pchMetaData)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemMetadata(_this->linux_side, handle, pchMetaData);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemVisibility, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemVisibility(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemVisibility(_this->linux_side, handle, eVisibility);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTags, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t * pTags)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTags(_this->linux_side, updateHandle, pTags);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemContent, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemContent(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_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_VERSION015_SetItemContent(_this->linux_side, handle, pszContentFolder ? lin_pszContentFolder : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemPreview, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemPreview(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_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_VERSION015_SetItemPreview(_this->linux_side, handle, pszPreviewFile ? lin_pszPreviewFile : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowLegacyUpload, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowLegacyUpload(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, bool bAllowLegacyUpload)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowLegacyUpload(_this->linux_side, handle, bAllowLegacyUpload);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAllItemKeyValueTags, 12)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAllItemKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAllItemKeyValueTags(_this->linux_side, handle);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemKeyValueTags, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemKeyValueTags(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pchKey)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemKeyValueTags(_this->linux_side, handle, pchKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemKeyValueTag, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemKeyValueTag(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pchKey, const char * pchValue)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemKeyValueTag(_this->linux_side, handle, pchKey, pchValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewFile, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewFile(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_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_VERSION015_AddItemPreviewFile(_this->linux_side, handle, pszPreviewFile ? lin_pszPreviewFile : NULL, type);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewVideo, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewVideo(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pszVideoID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewVideo(_this->linux_side, handle, pszVideoID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewFile, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewFile(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_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_VERSION015_UpdateItemPreviewFile(_this->linux_side, handle, index, pszPreviewFile ? lin_pszPreviewFile : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewVideo, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewVideo(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, uint32 index, const char * pszVideoID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewVideo(_this->linux_side, handle, index, pszVideoID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemPreview, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemPreview(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, uint32 index)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemPreview(_this->linux_side, handle, index);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubmitItemUpdate, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubmitItemUpdate(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, const char * pchChangeNote)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubmitItemUpdate(_this->linux_side, handle, pchChangeNote);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemUpdateProgress, 20)
+EItemUpdateStatus __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemUpdateProgress(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, UGCUpdateHandle_t handle, uint64 * punBytesProcessed, uint64 * punBytesTotal)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemUpdateProgress(_this->linux_side, handle, punBytesProcessed, punBytesTotal);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetUserItemVote, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetUserItemVote(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID, bool bVoteUp)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetUserItemVote(_this->linux_side, nPublishedFileID, bVoteUp);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetUserItemVote, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetUserItemVote(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetUserItemVote(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemToFavorites, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemToFavorites(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, AppId_t nAppId, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemToFavorites(_this->linux_side, nAppId, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemFromFavorites, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemFromFavorites(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, AppId_t nAppId, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemFromFavorites(_this->linux_side, nAppId, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubscribeItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubscribeItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubscribeItem(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UnsubscribeItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UnsubscribeItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_UnsubscribeItem(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetNumSubscribedItems, 4)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetNumSubscribedItems(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetNumSubscribedItems(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetSubscribedItems, 12)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetSubscribedItems(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetSubscribedItems(_this->linux_side, pvecPublishedFileID, cMaxEntries);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemState, 12)
+uint32 __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemState(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemState(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemInstallInfo, 28)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemInstallInfo(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID, uint64 * punSizeOnDisk, char * pchFolder, uint32 cchFolderSize, uint32 * punTimeStamp)
+{
+    bool path_result;
+    TRACE("%p\n", _this);
+    path_result = cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_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_VERSION015_GetItemDownloadInfo, 20)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemDownloadInfo(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID, uint64 * punBytesDownloaded, uint64 * punBytesTotal)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemDownloadInfo(_this->linux_side, nPublishedFileID, punBytesDownloaded, punBytesTotal);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_DownloadItem, 16)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_DownloadItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID, bool bHighPriority)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_DownloadItem(_this->linux_side, nPublishedFileID, bHighPriority);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_BInitWorkshopForGameServer, 12)
+bool __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_BInitWorkshopForGameServer(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_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_VERSION015_BInitWorkshopForGameServer(_this->linux_side, unWorkshopDepotID, pszFolder ? lin_pszFolder : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SuspendDownloads, 8)
+void __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SuspendDownloads(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, bool bSuspend)
+{
+    TRACE("%p\n", _this);
+    cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_SuspendDownloads(_this->linux_side, bSuspend);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartPlaytimeTracking, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartPlaytimeTracking(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartPlaytimeTracking(_this->linux_side, pvecPublishedFileID, unNumPublishedFileIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTracking, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTracking(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTracking(_this->linux_side, pvecPublishedFileID, unNumPublishedFileIDs);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTrackingForAllItems, 4)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTrackingForAllItems(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTrackingForAllItems(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddDependency, 20)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddDependency(_this->linux_side, nParentPublishedFileID, nChildPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveDependency, 20)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveDependency(_this->linux_side, nParentPublishedFileID, nChildPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddAppDependency, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddAppDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID, AppId_t nAppID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddAppDependency(_this->linux_side, nPublishedFileID, nAppID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAppDependency, 16)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAppDependency(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID, AppId_t nAppID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAppDependency(_this->linux_side, nPublishedFileID, nAppID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetAppDependencies, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetAppDependencies(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetAppDependencies(_this->linux_side, nPublishedFileID);
+}
+
+DEFINE_THISCALL_WRAPPER(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_DeleteItem, 12)
+SteamAPICall_t __thiscall winISteamUGC_STEAMUGC_INTERFACE_VERSION015_DeleteItem(winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *_this, PublishedFileId_t nPublishedFileID)
+{
+    TRACE("%p\n", _this);
+    return cppISteamUGC_STEAMUGC_INTERFACE_VERSION015_DeleteItem(_this->linux_side, nPublishedFileID);
+}
+
+extern vtable_ptr winISteamUGC_STEAMUGC_INTERFACE_VERSION015_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winISteamUGC_STEAMUGC_INTERFACE_VERSION015,
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUserUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest_2)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryAllUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateQueryUGCDetailsRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SendQueryUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCResult)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCTagDisplayName)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCPreviewURL)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCMetadata)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCChildren)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCStatistic)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumAdditionalPreviews)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCAdditionalPreview)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCNumKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag_2)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetQueryUGCKeyValueTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_ReleaseQueryUGCRequest)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredTagGroup)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddExcludedTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnOnlyIDs)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnLongDescription)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnMetadata)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnChildren)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnAdditionalPreviews)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnTotalOnly)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetReturnPlaytimeStats)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetLanguage)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowCachedResponse)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetCloudFileNameFilter)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetMatchAnyTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetSearchText)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetRankedByTrendDays)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddRequiredKeyValueTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RequestUGCDetails)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_CreateItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartItemUpdate)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTitle)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemDescription)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemUpdateLanguage)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemMetadata)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemVisibility)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemContent)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetItemPreview)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetAllowLegacyUpload)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAllItemKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemKeyValueTags)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemKeyValueTag)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewFile)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemPreviewVideo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewFile)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UpdateItemPreviewVideo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemPreview)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubmitItemUpdate)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemUpdateProgress)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SetUserItemVote)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetUserItemVote)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddItemToFavorites)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveItemFromFavorites)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SubscribeItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_UnsubscribeItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetNumSubscribedItems)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetSubscribedItems)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemState)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemInstallInfo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetItemDownloadInfo)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_DownloadItem)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_BInitWorkshopForGameServer)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_SuspendDownloads)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StartPlaytimeTracking)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTracking)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_StopPlaytimeTrackingForAllItems)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_AddAppDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_RemoveAppDependency)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_GetAppDependencies)
+        VTABLE_ADD_FUNC(winISteamUGC_STEAMUGC_INTERFACE_VERSION015_DeleteItem)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION015(void *linux_side)
+{
+    winISteamUGC_STEAMUGC_INTERFACE_VERSION015 *r = HeapAlloc(GetProcessHeap(), 0, sizeof(winISteamUGC_STEAMUGC_INTERFACE_VERSION015));
+    TRACE("-> %p\n", r);
+    r->vtable = &winISteamUGC_STEAMUGC_INTERFACE_VERSION015_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
 #include "cppISteamUGC_STEAMUGC_INTERFACE_VERSION014.h"
 
 typedef struct __winISteamUGC_STEAMUGC_INTERFACE_VERSION014 {

lsteamclient/winISteamUserStats.c

@@ -233,7 +233,7 @@ SteamAPICall_t __thiscall winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012
 }
 
 DEFINE_THISCALL_WRAPPER(winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry, 28)
-bool __thiscall winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry(winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012 *_this, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_150 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
+bool __thiscall winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry(winISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012 *_this, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, winLeaderboardEntry_t_151 * pLeaderboardEntry, int32 * pDetails, int cDetailsMax)
 {
     TRACE("%p\n", _this);
     return cppISteamUserStats_STEAMUSERSTATS_INTERFACE_VERSION012_GetDownloadedLeaderboardEntry(_this->linux_side, hSteamLeaderboardEntries, index, pLeaderboardEntry, pDetails, cDetailsMax);

lsteamclient/win_constructors.h

@@ -14,9 +14,9 @@ extern void *create_winISteamScreenshots_STEAMSCREENSHOTS_INTERFACE_VERSION003(v
 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_VERSION014(void *);
+extern void *create_winISteamInput_SteamInput002(void *);
+extern void *create_winISteamController_SteamController008(void *);
+extern void *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION015(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 *);
@@ -30,6 +30,9 @@ extern void *create_winISteamParentalSettings_STEAMPARENTALSETTINGS_INTERFACE_VE
 extern void *create_winISteamNetworkingMessages_SteamNetworkingMessages002(void *);
 extern void *create_winISteamNetworkingSockets_SteamNetworkingSockets009(void *);
 extern void *create_winISteamNetworkingUtils_SteamNetworkingUtils003(void *);
+extern void *create_winISteamInput_SteamInput001(void *);
+extern void *create_winISteamController_SteamController007(void *);
+extern void *create_winISteamUGC_STEAMUGC_INTERFACE_VERSION014(void *);
 extern void *create_winISteamUtils_SteamUtils009(void *);
 extern void *create_winISteamNetworkingSockets_SteamNetworkingSockets008(void *);
 extern void *create_winISteamUser_SteamUser020(void *);

lsteamclient/win_constructors_table.dat

@@ -14,9 +14,9 @@
     {"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_VERSION014", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION014},
+    {"SteamInput002", &create_winISteamInput_SteamInput002},
+    {"SteamController008", &create_winISteamController_SteamController008},
+    {"STEAMUGC_INTERFACE_VERSION015", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION015},
     {"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},
@@ -30,6 +30,9 @@
     {"SteamNetworkingMessages002", &create_winISteamNetworkingMessages_SteamNetworkingMessages002},
     {"SteamNetworkingSockets009", &create_winISteamNetworkingSockets_SteamNetworkingSockets009},
     {"SteamNetworkingUtils003", &create_winISteamNetworkingUtils_SteamNetworkingUtils003},
+    {"SteamInput001", &create_winISteamInput_SteamInput001},
+    {"SteamController007", &create_winISteamController_SteamController007},
+    {"STEAMUGC_INTERFACE_VERSION014", &create_winISteamUGC_STEAMUGC_INTERFACE_VERSION014},
     {"SteamUtils009", &create_winISteamUtils_SteamUtils009},
     {"SteamNetworkingSockets008", &create_winISteamNetworkingSockets_SteamNetworkingSockets008},
     {"SteamUser020", &create_winISteamUser_SteamUser020},