SDK 1.56 and 1.57

dll/flat.cpp

@@ -207,6 +207,16 @@ STEAMAPI_API ISteamRemotePlay * SteamAPI_ISteamClient_GetISteamRemotePlay( IStea
     return get_steam_client()->GetISteamRemotePlay(hSteamUser, hSteamPipe, pchVersion);
 }
 
+STEAMAPI_API ISteamUser *SteamAPI_SteamUser_v023()
+{
+    return get_steam_client()->GetISteamUser(flat_hsteamuser(), flat_hsteampipe(), "SteamUser023");
+}
+
+STEAMAPI_API ISteamUser *SteamAPI_SteamUser_v022()
+{
+    return get_steam_client()->GetISteamUser(flat_hsteamuser(), flat_hsteampipe(), "SteamUser022");
+}
+
 STEAMAPI_API ISteamUser *SteamAPI_SteamUser_v021()
 {
     return get_steam_client()->GetISteamUser(flat_hsteamuser(), flat_hsteampipe(), "SteamUser021");
@@ -292,11 +302,16 @@ STEAMAPI_API uint32 SteamAPI_ISteamUser_GetVoiceOptimalSampleRate( ISteamUser* s
     return (get_steam_client()->steam_user)->GetVoiceOptimalSampleRate();
 }
 
-STEAMAPI_API HAuthTicket SteamAPI_ISteamUser_GetAuthSessionTicket( ISteamUser* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket )
+STEAMAPI_API HAuthTicket SteamAPI_ISteamUser_GetAuthSessionTicket( ISteamUser* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket, const SteamNetworkingIdentity * pSteamNetworkingIdentity)
 {
     return (get_steam_client()->steam_user)->GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket);
 }
 
+STEAMAPI_API HAuthTicket SteamAPI_ISteamUser_GetAuthTicketForWebApi( ISteamUser* self, const char * pchIdentity )
+{
+    return (get_steam_client()->steam_user)->GetAuthTicketForWebApi(pchIdentity);
+}
+
 STEAMAPI_API EBeginAuthSessionResult SteamAPI_ISteamUser_BeginAuthSession( ISteamUser* self, const void * pAuthTicket, int cbAuthTicket, uint64_steamid steamID )
 {
     return (get_steam_client()->steam_user)->BeginAuthSession(pAuthTicket, cbAuthTicket, steamID);
@@ -3493,6 +3508,11 @@ STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v016()
     return get_steam_client()->GetISteamUGC(flat_hsteamuser(), flat_hsteampipe(), "STEAMUGC_INTERFACE_VERSION016");
 }
 
+STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v017()
+{
+    return get_steam_client()->GetISteamUGC(flat_hsteamuser(), flat_hsteampipe(), "STEAMUGC_INTERFACE_VERSION017");
+}
+
 STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v014()
 {
     return get_steam_client()->GetISteamUGC(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "STEAMUGC_INTERFACE_VERSION014");
@@ -3508,6 +3528,11 @@ STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v016()
     return get_steam_client()->GetISteamUGC(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "STEAMUGC_INTERFACE_VERSION016");
 }
 
+STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v017()
+{
+    return get_steam_client()->GetISteamUGC(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "STEAMUGC_INTERFACE_VERSION017");
+}
+
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest( ISteamUGC* self, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage )
 {
     long long test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
@@ -3760,6 +3785,18 @@ STEAMAPI_API steam_bool SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag( ISteamUG
     return (ptr)->GetQueryUGCKeyValueTag(handle, index, pchKey, pchValue, cchValueSize);
 }
 
+STEAMAPI_API uint32 SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID * pvecDescriptors, uint32 cMaxEntries )
+{
+    long long test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
+    long long test2 = ((char *)self - (char*)get_steam_client()->steam_gameserver_ugc);
+    auto ptr = get_steam_client()->steam_gameserver_ugc;
+    if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
+        ptr = get_steam_client()->steam_ugc;
+    }
+
+    return (ptr)->GetQueryUGCContentDescriptors(handle, index, pvecDescriptors, cMaxEntries);
+}
+
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_ReleaseQueryUGCRequest( ISteamUGC* self, UGCQueryHandle_t handle )
 {
     long long test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
@@ -4252,6 +4289,30 @@ STEAMAPI_API steam_bool SteamAPI_ISteamUGC_RemoveItemPreview( ISteamUGC* self, U
     return (ptr)->RemoveItemPreview(handle, index);
 }
 
+STEAMAPI_API steam_bool SteamAPI_ISteamUGC_AddContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid )
+{
+    long long test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
+    long long test2 = ((char *)self - (char*)get_steam_client()->steam_gameserver_ugc);
+    auto ptr = get_steam_client()->steam_gameserver_ugc;
+    if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
+        ptr = get_steam_client()->steam_ugc;
+    }
+
+    return (ptr)->AddContentDescriptor(handle, descid);
+}
+
+STEAMAPI_API steam_bool SteamAPI_ISteamUGC_RemoveContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid )
+{
+    long long test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
+    long long test2 = ((char *)self - (char*)get_steam_client()->steam_gameserver_ugc);
+    auto ptr = get_steam_client()->steam_gameserver_ugc;
+    if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
+        ptr = get_steam_client()->steam_ugc;
+    }
+
+    return (ptr)->RemoveContentDescriptor(handle, descid);
+}
+
 STEAMAPI_API SteamAPICall_t SteamAPI_ISteamUGC_SubmitItemUpdate( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchChangeNote )
 {
     long long test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
@@ -6393,6 +6454,11 @@ STEAMAPI_API ISteamGameServer *SteamAPI_SteamGameServer_v014()
     return get_steam_client()->GetISteamGameServer(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "SteamGameServer014");
 }
 
+STEAMAPI_API ISteamGameServer *SteamAPI_SteamGameServer_v015()
+{
+    return get_steam_client()->GetISteamGameServer(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "SteamGameServer015");
+}
+
 STEAMAPI_API steam_bool SteamAPI_ISteamGameServer_InitGameServer(intptr_t instancePtr, uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char * pchVersionString)
 {
     return ((ISteamGameServer *)instancePtr)->InitGameServer(unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString);
@@ -6548,7 +6614,7 @@ STEAMAPI_API void SteamAPI_ISteamGameServer_SetAdvertiseServerActive( ISteamGame
     return get_steam_client()->steam_gameserver->SetAdvertiseServerActive(bActive);
 }
 
-STEAMAPI_API HAuthTicket SteamAPI_ISteamGameServer_GetAuthSessionTicket( ISteamGameServer* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket )
+STEAMAPI_API HAuthTicket SteamAPI_ISteamGameServer_GetAuthSessionTicket( ISteamGameServer* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket, const SteamNetworkingIdentity * pSnid )
 {
     return get_steam_client()->steam_gameserver->GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket);
 }

dll/steam_client.cpp

@@ -334,6 +334,10 @@ ISteamUser *Steam_Client::GetISteamUser( HSteamUser hSteamUser, HSteamPipe hStea
         return (ISteamUser *)(void *)(ISteamUser019 *)steam_user;
     } else if (strcmp(pchVersion, "SteamUser020") == 0) {
         return (ISteamUser *)(void *)(ISteamUser020 *)steam_user;
+    } else if (strcmp(pchVersion, "SteamUser021") == 0) {
+        return (ISteamUser *)(void *)(ISteamUser021 *)steam_user;
+    } else if (strcmp(pchVersion, "SteamUser022") == 0) {
+        return (ISteamUser *)(void *)(ISteamUser022 *)steam_user;
     } else if (strcmp(pchVersion, STEAMUSER_INTERFACE_VERSION) == 0) {
         return (ISteamUser *)(void *)(ISteamUser *)steam_user;
     } else {
@@ -370,6 +374,9 @@ ISteamGameServer *Steam_Client::GetISteamGameServer( HSteamUser hSteamUser, HSte
     } else if (strcmp(pchVersion, "SteamGameServer013") == 0) {
         gameserver_has_ipv6_functions = true;
         return (ISteamGameServer *)(void *)(ISteamGameServer013 *)steam_gameserver;
+    } else if (strcmp(pchVersion, "SteamGameServer014") == 0) {
+        gameserver_has_ipv6_functions = true;
+        return (ISteamGameServer *)(void *)(ISteamGameServer014 *)steam_gameserver;
     } else if (strcmp(pchVersion, STEAMGAMESERVER_INTERFACE_VERSION) == 0) {
         gameserver_has_ipv6_functions = true;
         return (ISteamGameServer *)(void *)(ISteamGameServer *)steam_gameserver;
@@ -1020,6 +1027,8 @@ ISteamUGC *Steam_Client::GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamP
         return (ISteamUGC *)(void *)(ISteamUGC014 *)steam_ugc_temp;
     } else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION015") == 0) {
         return (ISteamUGC *)(void *)(ISteamUGC015 *)steam_ugc_temp;
+    } else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION016") == 0) {
+        return (ISteamUGC *)(void *)(ISteamUGC016 *)steam_ugc_temp;
     } else if (strcmp(pchVersion, STEAMUGC_INTERFACE_VERSION) == 0) {
         return (ISteamUGC *)(void *)(ISteamUGC *)steam_ugc_temp;
     } else {

dll/steam_gameserver.cpp

@@ -481,6 +481,13 @@ bool Steam_GameServer::BGetUserAchievementStatus( CSteamID steamID, const char *
 // Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). 
 // pcbTicket retrieves the length of the actual ticket.
 HAuthTicket Steam_GameServer::GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket )
+{
+    return GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket, NULL);
+}
+
+// SteamNetworkingIdentity is an optional parameter to hold the public IP address of the entity you are connecting to
+// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address
+HAuthTicket Steam_GameServer::GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSnid )
 {
     PRINT_DEBUG("Steam_GameServer::GetAuthSessionTicket\n");
     std::lock_guard<std::recursive_mutex> lock(global_mutex);

dll/steam_gameserver.h

@@ -37,6 +37,7 @@ public ISteamGameServer010,
 public ISteamGameServer011,
 public ISteamGameServer012,
 public ISteamGameServer013,
+public ISteamGameServer014,
 public ISteamGameServer
 {
     class Settings *settings;
@@ -253,6 +254,9 @@ public:
 	// Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). 
 	// pcbTicket retrieves the length of the actual ticket.
 	HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket );
+	// SteamNetworkingIdentity is an optional parameter to hold the public IP address of the entity you are connecting to
+	// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address
+	HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSnid );
 
 	// Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused
 	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )

dll/steam_ugc.h

@@ -40,6 +40,7 @@ public ISteamUGC012,
 public ISteamUGC013,
 public ISteamUGC014,
 public ISteamUGC015,
+public ISteamUGC016,
 public ISteamUGC
 {
     class Settings *settings;
@@ -273,6 +274,11 @@ bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, const char *
     return false;
 }
 
+uint32 GetQueryUGCContentDescriptors( UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID *pvecDescriptors, uint32 cMaxEntries )
+{
+    PRINT_DEBUG("Steam_UGC::GetQueryUGCContentDescriptors\n");
+    return 0;
+}
 
 // Release the request to free up memory, after retrieving results
 bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle )
@@ -592,6 +598,17 @@ bool RemoveItemPreview( UGCUpdateHandle_t handle, uint32 index )
 }
  // remove a preview by index starting at 0 (previews are sorted)
 
+bool AddContentDescriptor( UGCUpdateHandle_t handle, EUGCContentDescriptorID descid )
+{
+    PRINT_DEBUG("Steam_UGC::AddContentDescriptor %llu %u\n", handle, index);
+    return false;
+}
+
+bool RemoveContentDescriptor( UGCUpdateHandle_t handle, EUGCContentDescriptorID descid )
+{
+    PRINT_DEBUG("Steam_UGC::RemoveContentDescriptor %llu %u\n", handle, index);
+    return false;
+}
 
 STEAM_CALL_RESULT( SubmitItemUpdateResult_t )
 SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote )

dll/steam_user.h

@@ -32,6 +32,7 @@ public ISteamUser017,
 public ISteamUser018,
 public ISteamUser019,
 public ISteamUser020,
+public ISteamUser021,
 public ISteamUser
 {
     Settings *settings;
@@ -299,6 +300,13 @@ uint32 GetVoiceOptimalSampleRate()
 // Retrieve ticket to be sent to the entity who wishes to authenticate you. 
 // pcbTicket retrieves the length of the actual ticket.
 HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket )
+{
+    return GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket, NULL);
+}
+// SteamNetworkingIdentity is an optional input parameter to hold the public IP address or SteamID of the entity you are connecting to
+// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address
+// if a Steam ID is passed Steam will only allow the ticket to be used by that Steam ID
+HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSteamNetworkingIdentity )
 {
     PRINT_DEBUG("Steam_User::GetAuthSessionTicket %i\n", cbMaxTicket);
     std::lock_guard<std::recursive_mutex> lock(global_mutex);
@@ -306,6 +314,15 @@ HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTic
     return ticket_manager->getTicket(pTicket, cbMaxTicket, pcbTicket);
 }
 
+// Request a ticket which will be used for webapi "ISteamUserAuth\AuthenticateUserTicket"
+// pchIdentity is an optional input parameter to identify the service the ticket will be sent to
+// the ticket will be returned in callback GetTicketForWebApiResponse_t
+HAuthTicket GetAuthTicketForWebApi( const char *pchIdentity )
+{
+    PRINT_DEBUG("TODO: Steam_User::GetAuthTicketForWebApi %s\n", pchIdentity);
+    return 0;
+}
+
 // Authenticate ticket from entity steamID to be sure it is valid and isnt reused
 // Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
 EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID )

overlay_experimental/steam_overlay.cpp

@@ -1059,6 +1059,8 @@ void Steam_Overlay::RunCallbacks()
     {
         GameOverlayActivated_t data = { 0 };
         data.m_bActive = show_overlay;
+        data.m_bUserInitiated = true;
+        data.m_nAppID = settings->get_local_game_id().AppID();
         callbacks->addCBResult(data.k_iCallback, &data, sizeof(data));
 
         overlay_state_changed = false;

sdk_includes/isteamcontroller.h

@@ -21,9 +21,9 @@
 
 #define STEAM_CONTROLLER_MAX_COUNT 16
 
-#define STEAM_CONTROLLER_MAX_ANALOG_ACTIONS 16
+#define STEAM_CONTROLLER_MAX_ANALOG_ACTIONS 24
 
-#define STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS 128
+#define STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS 256
 
 #define STEAM_CONTROLLER_MAX_ORIGINS 8
 
@@ -491,6 +491,16 @@ enum EControllerActionOrigin
 	k_EControllerActionOrigin_SteamDeck_Reserved19,
 	k_EControllerActionOrigin_SteamDeck_Reserved20,
 
+	k_EControllerActionOrigin_Switch_JoyConButton_N, // With a Horizontal JoyCon this will be Y or what would be Dpad Right when vertical
+	k_EControllerActionOrigin_Switch_JoyConButton_E, // X
+	k_EControllerActionOrigin_Switch_JoyConButton_S, // A
+	k_EControllerActionOrigin_Switch_JoyConButton_W, // B
+
+	k_EControllerActionOrigin_PS5_LeftGrip,
+	k_EControllerActionOrigin_PS5_RightGrip,
+	k_EControllerActionOrigin_PS5_LeftFn,
+	k_EControllerActionOrigin_PS5_RightFn,
+
 	k_EControllerActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
 	k_EControllerActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
 };
@@ -572,6 +582,7 @@ typedef uint64 ControllerAnalogActionHandle_t;
 #define ControllerAnalogActionData_t InputAnalogActionData_t
 #define ControllerDigitalActionData_t InputDigitalActionData_t
 #define ControllerMotionData_t  InputMotionData_t
+#define ControllerMotionDataV2_t  InputMotionDataV2_t
 #else
 struct ControllerAnalogActionData_t
 {

sdk_includes/isteamfriends.h

@@ -528,6 +528,8 @@ struct GameOverlayActivated_t
 {
 	enum { k_iCallback = k_iSteamFriendsCallbacks + 31 };
 	uint8 m_bActive;		// true if it's just been activated, false otherwise
+	bool m_bUserInitiated;	// true if the user asked for the overlay to be activated/deactivated
+	AppId_t m_nAppID;		// the appID of the game (should always be the current game)
 };
 
 

sdk_includes/isteamgameserver.h

@@ -152,7 +152,9 @@ public:
 
 	// Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). 
 	// pcbTicket retrieves the length of the actual ticket.
-	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+	// SteamNetworkingIdentity is an optional parameter to hold the public IP address of the entity you are connecting to
+	// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address
+	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSnid ) = 0;
 
 	// Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused
 	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
@@ -266,7 +268,7 @@ public:
 	)
 };
 
-#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer014"
+#define STEAMGAMESERVER_INTERFACE_VERSION "SteamGameServer015"
 
 #ifndef STEAM_API_EXPORTS
 // Global accessor

sdk_includes/isteamgameserver014.h

@@ -0,0 +1,259 @@
+
+#ifndef ISTEAMGAMESERVER014_H
+#define ISTEAMGAMESERVER014_H
+#ifdef STEAM_WIN32
+#pragma once
+#endif
+
+class ISteamGameServer014
+{
+public:
+
+//
+// Basic server data.  These properties, if set, must be set before before calling LogOn.  They
+// may not be changed after logged in.
+//
+
+	/// This is called by SteamGameServer_Init, and you will usually not need to call it directly
+	STEAM_PRIVATE_API( virtual bool InitGameServer( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, uint32 unFlags, AppId_t nGameAppId, const char *pchVersionString ) = 0; )
+
+	/// Game product identifier.  This is currently used by the master server for version checking purposes.
+	/// It's a required field, but will eventually will go away, and the AppID will be used for this purpose.
+	virtual void SetProduct( const char *pszProduct ) = 0;
+
+	/// Description of the game.  This is a required field and is displayed in the steam server browser....for now.
+	/// This is a required field, but it will go away eventually, as the data should be determined from the AppID.
+	virtual void SetGameDescription( const char *pszGameDescription ) = 0;
+
+	/// If your game is a "mod," pass the string that identifies it.  The default is an empty string, meaning
+	/// this application is the original game, not a mod.
+	///
+	/// @see k_cbMaxGameServerGameDir
+	virtual void SetModDir( const char *pszModDir ) = 0;
+
+	/// Is this is a dedicated server?  The default value is false.
+	virtual void SetDedicatedServer( bool bDedicated ) = 0;
+
+//
+// Login
+//
+
+	/// Begin process to login to a persistent game server account
+	///
+	/// You need to register for callbacks to determine the result of this operation.
+	/// @see SteamServersConnected_t
+	/// @see SteamServerConnectFailure_t
+	/// @see SteamServersDisconnected_t
+	virtual void LogOn( const char *pszToken ) = 0;
+
+	/// Login to a generic, anonymous account.
+	///
+	/// Note: in previous versions of the SDK, this was automatically called within SteamGameServer_Init,
+	/// but this is no longer the case.
+	virtual void LogOnAnonymous() = 0;
+
+	/// Begin process of logging game server out of steam
+	virtual void LogOff() = 0;
+	
+	// status functions
+	virtual bool BLoggedOn() = 0;
+	virtual bool BSecure() = 0; 
+	virtual CSteamID GetSteamID() = 0;
+
+	/// Returns true if the master server has requested a restart.
+	/// Only returns true once per request.
+	virtual bool WasRestartRequested() = 0;
+
+//
+// Server state.  These properties may be changed at any time.
+//
+
+	/// Max player count that will be reported to server browser and client queries
+	virtual void SetMaxPlayerCount( int cPlayersMax ) = 0;
+
+	/// Number of bots.  Default value is zero
+	virtual void SetBotPlayerCount( int cBotplayers ) = 0;
+
+	/// Set the name of server as it will appear in the server browser
+	///
+	/// @see k_cbMaxGameServerName
+	virtual void SetServerName( const char *pszServerName ) = 0;
+
+	/// Set name of map to report in the server browser
+	///
+	/// @see k_cbMaxGameServerMapName
+	virtual void SetMapName( const char *pszMapName ) = 0;
+
+	/// Let people know if your server will require a password
+	virtual void SetPasswordProtected( bool bPasswordProtected ) = 0;
+
+	/// Spectator server port to advertise.  The default value is zero, meaning the
+	/// service is not used.  If your server receives any info requests on the LAN,
+	/// this is the value that will be placed into the reply for such local queries.
+	///
+	/// This is also the value that will be advertised by the master server.
+	/// The only exception is if your server is using a FakeIP.  Then then the second
+	/// fake port number (index 1) assigned to your server will be listed on the master
+	/// server as the spectator port, if you set this value to any nonzero value.
+	///
+	/// This function merely controls the values that are advertised -- it's up to you to
+	/// configure the server to actually listen on this port and handle any spectator traffic
+	virtual void SetSpectatorPort( uint16 unSpectatorPort ) = 0;
+
+	/// Name of the spectator server.  (Only used if spectator port is nonzero.)
+	///
+	/// @see k_cbMaxGameServerMapName
+	virtual void SetSpectatorServerName( const char *pszSpectatorServerName ) = 0;
+
+	/// Call this to clear the whole list of key/values that are sent in rules queries.
+	virtual void ClearAllKeyValues() = 0;
+	
+	/// Call this to add/update a key/value pair.
+	virtual void SetKeyValue( const char *pKey, const char *pValue ) = 0;
+
+	/// Sets a string defining the "gametags" for this server, this is optional, but if it is set
+	/// it allows users to filter in the matchmaking/server-browser interfaces based on the value
+	///
+	/// @see k_cbMaxGameServerTags
+	virtual void SetGameTags( const char *pchGameTags ) = 0;
+
+	/// Sets a string defining the "gamedata" for this server, this is optional, but if it is set
+	/// it allows users to filter in the matchmaking/server-browser interfaces based on the value
+	///
+	/// @see k_cbMaxGameServerGameData
+	virtual void SetGameData( const char *pchGameData ) = 0;
+
+	/// Region identifier.  This is an optional field, the default value is empty, meaning the "world" region
+	virtual void SetRegion( const char *pszRegion ) = 0;
+
+	/// Indicate whether you wish to be listed on the master server list
+	/// and/or respond to server browser / LAN discovery packets.
+	/// The server starts with this value set to false.  You should set all
+	/// relevant server parameters before enabling advertisement on the server.
+	///
+	/// (This function used to be named EnableHeartbeats, so if you are wondering
+	/// where that function went, it's right here.  It does the same thing as before,
+	/// the old name was just confusing.)
+	virtual void SetAdvertiseServerActive( bool bActive ) = 0;
+
+//
+// Player list management / authentication.
+//
+
+	// Retrieve ticket to be sent to the entity who wishes to authenticate you ( using BeginAuthSession API ). 
+	// pcbTicket retrieves the length of the actual ticket.
+	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+
+	// Authenticate ticket ( from GetAuthSessionTicket ) from entity steamID to be sure it is valid and isnt reused
+	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+	virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0;
+
+	// Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
+	virtual void EndAuthSession( CSteamID steamID ) = 0;
+
+	// Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
+	virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;
+
+	// After receiving a user's authentication data, and passing it to SendUserConnectAndAuthenticate, use this function
+	// to determine if the user owns downloadable content specified by the provided AppID.
+	virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0;
+
+	// Ask if a user in in the specified group, results returns async by GSUserGroupStatus_t
+	// returns false if we're not connected to the steam servers and thus cannot ask
+	virtual bool RequestUserGroupStatus( CSteamID steamIDUser, CSteamID steamIDGroup ) = 0;
+
+
+	// these two functions s are deprecated, and will not return results
+	// they will be removed in a future version of the SDK
+	virtual void GetGameplayStats( ) = 0;
+	STEAM_CALL_RESULT( GSReputation_t )
+	virtual SteamAPICall_t GetServerReputation() = 0;
+
+	// Returns the public IP of the server according to Steam, useful when the server is 
+	// behind NAT and you want to advertise its IP in a lobby for other clients to directly
+	// connect to
+	virtual SteamIPAddress_t GetPublicIP() = 0;
+
+// Server browser related query packet processing for shared socket mode.  These are used
+// when you pass STEAMGAMESERVER_QUERY_PORT_SHARED as the query port to SteamGameServer_Init.
+// IP address and port are in host order, i.e 127.0.0.1 == 0x7f000001
+
+	// These are used when you've elected to multiplex the game server's UDP socket
+	// rather than having the master server updater use its own sockets.
+	// 
+	// Source games use this to simplify the job of the server admins, so they 
+	// don't have to open up more ports on their firewalls.
+	
+	// Call this when a packet that starts with 0xFFFFFFFF comes in. That means
+	// it's for us.
+	virtual bool HandleIncomingPacket( const void *pData, int cbData, uint32 srcIP, uint16 srcPort ) = 0;
+
+	// AFTER calling HandleIncomingPacket for any packets that came in that frame, call this.
+	// This gets a packet that the master server updater needs to send out on UDP.
+	// It returns the length of the packet it wants to send, or 0 if there are no more packets to send.
+	// Call this each frame until it returns 0.
+	virtual int GetNextOutgoingPacket( void *pOut, int cbMaxOut, uint32 *pNetAdr, uint16 *pPort ) = 0;
+
+//
+// Server clan association
+//
+
+	// associate this game server with this clan for the purposes of computing player compat
+	STEAM_CALL_RESULT( AssociateWithClanResult_t )
+	virtual SteamAPICall_t AssociateWithClan( CSteamID steamIDClan ) = 0;
+	
+	// ask if any of the current players dont want to play with this new player - or vice versa
+	STEAM_CALL_RESULT( ComputeNewPlayerCompatibilityResult_t )
+	virtual SteamAPICall_t ComputeNewPlayerCompatibility( CSteamID steamIDNewPlayer ) = 0;
+
+
+
+
+	// Handles receiving a new connection from a Steam user.  This call will ask the Steam
+	// servers to validate the users identity, app ownership, and VAC status.  If the Steam servers 
+	// are off-line, then it will validate the cached ticket itself which will validate app ownership 
+	// and identity.  The AuthBlob here should be acquired on the game client using SteamUser()->InitiateGameConnection()
+	// and must then be sent up to the game server for authentication.
+	//
+	// Return Value: returns true if the users ticket passes basic checks. pSteamIDUser will contain the Steam ID of this user. pSteamIDUser must NOT be NULL
+	// If the call succeeds then you should expect a GSClientApprove_t or GSClientDeny_t callback which will tell you whether authentication
+	// for the user has succeeded or failed (the steamid in the callback will match the one returned by this call)
+	//
+	// DEPRECATED!  This function will be removed from the SDK in an upcoming version.
+	//              Please migrate to BeginAuthSession and related functions.
+	//virtual bool SendUserConnectAndAuthenticate_DEPRECATED( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0;
+	virtual bool SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) = 0;
+
+	// Creates a fake user (ie, a bot) which will be listed as playing on the server, but skips validation.  
+	// 
+	// Return Value: Returns a SteamID for the user to be tracked with, you should call EndAuthSession()
+	// when this user leaves the server just like you would for a real user.
+	virtual CSteamID CreateUnauthenticatedUserConnection() = 0;
+
+	// Should be called whenever a user leaves our game server, this lets Steam internally
+	// track which users are currently on which servers for the purposes of preventing a single
+	// account being logged into multiple servers, showing who is currently on a server, etc.
+	//
+	// DEPRECATED!  This function will be removed from the SDK in an upcoming version.
+	//              Please migrate to BeginAuthSession and related functions.
+	//virtual void SendUserDisconnect_DEPRECATED( CSteamID steamIDUser ) = 0;
+	virtual void SendUserDisconnect( CSteamID steamIDUser ) = 0;
+
+	// Update the data to be displayed in the server browser and matchmaking interfaces for a user
+	// currently connected to the server.  For regular users you must call this after you receive a
+	// GSUserValidationSuccess callback.
+	// 
+	// Return Value: true if successful, false if failure (ie, steamIDUser wasn't for an active player)
+	virtual bool BUpdateUserData( CSteamID steamIDUser, const char *pchPlayerName, uint32 uScore ) = 0;
+
+// Deprecated functions.  These will be removed in a future version of the SDK.
+// If you really need these, please contact us and help us understand what you are
+// using them for.
+
+	STEAM_PRIVATE_API(
+		virtual void SetMasterServerHeartbeatInterval_DEPRECATED( int iHeartbeatInterval ) = 0;
+		virtual void ForceMasterServerHeartbeat_DEPRECATED() = 0;
+	)
+};
+
+#endif // ISTEAMGAMESERVER014_H

sdk_includes/isteaminput.h

@@ -17,9 +17,9 @@
 
 #define STEAM_INPUT_MAX_COUNT 16
 
-#define STEAM_INPUT_MAX_ANALOG_ACTIONS 16
+#define STEAM_INPUT_MAX_ANALOG_ACTIONS 24
 
-#define STEAM_INPUT_MAX_DIGITAL_ACTIONS 128
+#define STEAM_INPUT_MAX_DIGITAL_ACTIONS 256
 
 #define STEAM_INPUT_MAX_ORIGINS 8
 
@@ -341,10 +341,10 @@ enum EInputActionOrigin
 	k_EInputActionOrigin_Switch_LeftGrip_Upper, // Left JoyCon SL Button
 	k_EInputActionOrigin_Switch_RightGrip_Lower,  // Right JoyCon SL Button
 	k_EInputActionOrigin_Switch_RightGrip_Upper,  // Right JoyCon SR Button
-	k_EInputActionOrigin_Switch_Reserved11,
+	k_EInputActionOrigin_Switch_JoyConButton_N, // With a Horizontal JoyCon this will be Y or what would be Dpad Right when vertical
-	k_EInputActionOrigin_Switch_Reserved12,
+	k_EInputActionOrigin_Switch_JoyConButton_E, // X
-	k_EInputActionOrigin_Switch_Reserved13,
+	k_EInputActionOrigin_Switch_JoyConButton_S, // A
-	k_EInputActionOrigin_Switch_Reserved14,
+	k_EInputActionOrigin_Switch_JoyConButton_W, // B
 	k_EInputActionOrigin_Switch_Reserved15,
 	k_EInputActionOrigin_Switch_Reserved16,
 	k_EInputActionOrigin_Switch_Reserved17,
@@ -408,10 +408,10 @@ enum EInputActionOrigin
 	k_EInputActionOrigin_PS5_Gyro_Yaw,
 	k_EInputActionOrigin_PS5_Gyro_Roll,
 	k_EInputActionOrigin_PS5_DPad_Move,
-	k_EInputActionOrigin_PS5_Reserved1,
+	k_EInputActionOrigin_PS5_LeftGrip,
-	k_EInputActionOrigin_PS5_Reserved2,
+	k_EInputActionOrigin_PS5_RightGrip,
-	k_EInputActionOrigin_PS5_Reserved3,
+	k_EInputActionOrigin_PS5_LeftFn,
-	k_EInputActionOrigin_PS5_Reserved4,
+	k_EInputActionOrigin_PS5_RightFn,
 	k_EInputActionOrigin_PS5_Reserved5,
 	k_EInputActionOrigin_PS5_Reserved6,
 	k_EInputActionOrigin_PS5_Reserved7,
@@ -665,7 +665,7 @@ struct InputDigitalActionData_t
 
 struct InputMotionData_t
 {
-	// Sensor-fused absolute rotation; will drift in heading
+	// Sensor-fused absolute rotation; will drift in heading toward average
 	float rotQuatX;
 	float rotQuatY;
 	float rotQuatZ;
@@ -682,6 +682,58 @@ struct InputMotionData_t
 	float rotVelZ;
 };
 
+
+struct InputMotionDataV2_t
+{
+	//
+	// Gyro post processing:
+	//
+
+	// Drift Corrected Quaternion is calculated after steam input controller calibration values have been applied.
+	// Rawest _useful_ version of a quaternion.
+	// Most camera implementations should use this by comparing last rotation against current rotation, and applying the difference to the in game camera (plus your own sensitivity tweaks)
+	// It is worth viewing 
+	float driftCorrectedQuatX;
+	float driftCorrectedQuatY;
+	float driftCorrectedQuatZ;
+	float driftCorrectedQuatW;
+
+	// Sensor fusion corrects using accelerometer, and "average forward over time" for "forward".
+	// This can "ouija" your aim, so it's not so  appropriate for camera controls (sensor fusion was originally made for racing game steering )
+	// Same result as from old InputMotionData_t::rotQuatX/Y/Z/W
+	float sensorFusionQuatX;
+	float sensorFusionQuatY;
+	float sensorFusionQuatZ;
+	float sensorFusionQuatW;
+
+	// Deferred Sensor fusion quaternion with deferred correction
+	// Reduces perception of "ouija" effect by only applying correction when the controller is below "low noise" thresholds,
+	// while the controller rotates fast - never when the user is attempting precision aim.
+	float deferredSensorFusionQuatX;
+	float deferredSensorFusionQuatY;
+	float deferredSensorFusionQuatZ;
+	float deferredSensorFusionQuatW;
+
+	// Same as accel but values are calibrated such that 1 unit = 1G.
+	// X = Right
+	// Y = Forward out through the joystick USB port.
+	// Z = Up through the joystick axis.
+	float gravityX;
+	float gravityY;
+	float gravityZ;
+
+	// 
+	// Same as rotVel values in GetMotionData but values are calibrated to degrees per second.
+	// Local Space (controller relative)
+	// X = Pitch = left to right axis
+	// Y = Roll = axis through charging port
+	// Z = Yaw = axis through sticks
+	float degreesPerSecondX;
+	float degreesPerSecondY;
+	float degreesPerSecondZ;
+
+};
+
 //-----------------------------------------------------------------------------
 // Purpose: when callbacks are enabled this fires each time a controller action
 // state changes
@@ -775,6 +827,12 @@ public:
 	// Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks
 	STEAM_CALL_BACK( SteamInputDeviceDisconnected_t )
 
+	// Controllers using Gamepad emulation (XInput, DirectInput, etc) will be seated in the order that
+	// input is sent by the device. This callback will fire on first input for each device and when the
+	// a user has manually changed the order via the Steam overlay. This also has the device type info
+	// so that you can change out glyph sets without making additional API calls
+	STEAM_CALL_BACK( SteamInputGamepadSlotChange_t )
+
 	// Enable SteamInputActionEvent_t callbacks. Directly calls your callback function
 	// for lower latency than standard Steam callbacks. Supports one callback at a time.
 	// Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks
@@ -919,7 +977,7 @@ public:
 	// See isteamremoteplay.h for more information on Steam Remote Play sessions
 	virtual uint32 GetRemotePlaySessionID( InputHandle_t inputHandle ) = 0;
 
-	// Get a bitmask of the Steam Input Configuration types opted in for the current session. Returns ESteamInputConfigurationEnableType values.?	
+	// Get a bitmask of the Steam Input Configuration types opted in for the current session. Returns ESteamInputConfigurationEnableType values.
 	// Note: user can override the settings from the Steamworks Partner site so the returned values may not exactly match your default configuration
 	virtual uint16 GetSessionInputConfigurationSettings() = 0;
 
@@ -979,6 +1037,20 @@ struct SteamInputConfigurationLoaded_t
 	bool			m_bUsesGamepadAPI;		// Does the configuration contain any Xinput bindings?
 };
 
+//-----------------------------------------------------------------------------
+// Purpose: called when controller gamepad slots change - on Linux/macOS these
+// slots are shared for all running apps.
+//-----------------------------------------------------------------------------
+struct SteamInputGamepadSlotChange_t
+{
+	enum { k_iCallback = k_iSteamControllerCallbacks + 4 };
+	AppId_t			m_unAppID;
+	InputHandle_t	m_ulDeviceHandle;		// Handle for device
+	ESteamInputType m_eDeviceType;			// Type of device
+	int				m_nOldGamepadSlot;		// Previous GamepadSlot - can be -1 controller doesn't uses gamepad bindings
+	int				m_nNewGamepadSlot;		// New Gamepad Slot - can be -1 controller doesn't uses gamepad bindings
+};
+
 #pragma pack( pop )
 
 #endif // ISTEAMINPUT_H

sdk_includes/isteamparentalsettings.h

@@ -29,6 +29,7 @@ enum EParentalFeature
 	k_EFeatureLibrary = 11,
 	k_EFeatureTest = 12,
 	k_EFeatureSiteLicense = 13,
+	k_EFeatureKioskMode = 14,
 	k_EFeatureMax
 };
 

sdk_includes/isteamremoteplay.h

@@ -51,7 +51,7 @@ public:
 	// This is set to 0x0 if the resolution is not available
 	virtual bool BGetSessionClientResolution( RemotePlaySessionID_t unSessionID, int *pnResolutionX, int *pnResolutionY ) = 0;
 
-	// Invite a friend to Remote Play Together
+	// Invite a friend to Remote Play Together, or create a guest invite if steamIDFriend is empty
 	// This returns false if the invite can't be sent
 	virtual bool BSendRemotePlayTogetherInvite( CSteamID steamIDFriend ) = 0;
 };
@@ -82,6 +82,11 @@ STEAM_CALLBACK_BEGIN( SteamRemotePlaySessionDisconnected_t, k_iSteamRemotePlayCa
 STEAM_CALLBACK_END( 0 )
 
 
+STEAM_CALLBACK_BEGIN( SteamRemotePlayTogetherGuestInvite_t, k_iSteamRemotePlayCallbacks + 3 )
+	STEAM_CALLBACK_MEMBER_ARRAY( 0, char, m_szConnectURL, 1024 )
+STEAM_CALLBACK_END( 0 )
+
+
 #pragma pack( pop )
 
 

sdk_includes/isteamugc.h

@@ -157,6 +157,15 @@ enum EItemPreviewType
 	k_EItemPreviewType_ReservedMax						= 255,	// you can specify your own types above this value
 };
 
+enum EUGCContentDescriptorID
+{
+	k_EUGCContentDescriptor_NudityOrSexualContent	= 1,
+	k_EUGCContentDescriptor_FrequentViolenceOrGore	= 2,
+	k_EUGCContentDescriptor_AdultOnlySexualContent	= 3,
+	k_EUGCContentDescriptor_GratuitousSexualContent = 4,
+	k_EUGCContentDescriptor_AnyMatureContent		= 5,
+};
+
 const uint32 kNumUGCResultsPerPage = 50;
 const uint32 k_cchDeveloperMetadataMax = 5000;
 
@@ -237,6 +246,8 @@ public:
 	STEAM_FLAT_NAME( GetQueryFirstUGCKeyValueTag )
 	virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, const char *pchKey, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0;
 
+	virtual uint32 GetQueryUGCContentDescriptors( UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID *pvecDescriptors, uint32 cMaxEntries ) = 0;
+	
 	// Release the request to free up memory, after retrieving results
 	virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
 
@@ -293,6 +304,8 @@ public:
 	virtual bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint32 index, const char *pszPreviewFile ) = 0; //  updates an existing preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size
 	virtual bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint32 index, const char *pszVideoID ) = 0; //  updates an existing preview video for this item
 	virtual bool RemoveItemPreview( UGCUpdateHandle_t handle, uint32 index ) = 0; // remove a preview by index starting at 0 (previews are sorted)
+	virtual bool AddContentDescriptor( UGCUpdateHandle_t handle, EUGCContentDescriptorID descid ) = 0;
+	virtual bool RemoveContentDescriptor( UGCUpdateHandle_t handle, EUGCContentDescriptorID descid ) = 0;
 
 	STEAM_CALL_RESULT( SubmitItemUpdateResult_t )
 	virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate()
@@ -371,7 +384,7 @@ public:
 	virtual SteamAPICall_t GetWorkshopEULAStatus() = 0;
 };
 
-#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION016"
+#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION017"
 
 #ifndef STEAM_API_EXPORTS
 // Global interface accessor

sdk_includes/isteamugc016.h

@@ -0,0 +1,181 @@
+
+#ifndef ISTEAMUGC016_H
+#define ISTEAMUGC016_H
+#ifdef STEAM_WIN32
+#pragma once
+#endif
+
+class ISteamUGC016
+{
+public:
+	// Query UGC associated with a user. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
+	virtual UGCQueryHandle_t CreateQueryUserUGCRequest( AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+	// Query for all matching UGC. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
+	STEAM_FLAT_NAME( CreateQueryAllUGCRequestPage )
+	virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+	// Query for all matching UGC using the new deep paging interface. Creator app id or consumer app id must be valid and be set to the current running app. pchCursor should be set to NULL or "*" to get the first result set.
+	STEAM_FLAT_NAME( CreateQueryAllUGCRequestCursor )
+	virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char *pchCursor = NULL ) = 0;
+
+	// Query for the details of the given published file ids (the RequestUGCDetails call is deprecated and replaced with this)
+	virtual UGCQueryHandle_t CreateQueryUGCDetailsRequest( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
+
+	// Send the query to Steam
+	STEAM_CALL_RESULT( SteamUGCQueryCompleted_t )
+	virtual SteamAPICall_t SendQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+	// Retrieve an individual result after receiving the callback for querying UGC
+	virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0;
+	virtual uint32 GetQueryUGCNumTags( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetQueryUGCTag( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize ) = 0;
+	virtual bool GetQueryUGCTagDisplayName( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize ) = 0;
+	virtual bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURL, uint32 cchURLSize ) = 0;
+	virtual bool GetQueryUGCMetadata( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchMetadatasize) char *pchMetadata, uint32 cchMetadatasize ) = 0;
+	virtual bool GetQueryUGCChildren( UGCQueryHandle_t handle, uint32 index, PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0;
+	virtual bool GetQueryUGCStatistic( UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 *pStatValue ) = 0;
+	virtual uint32 GetQueryUGCNumAdditionalPreviews( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURLOrVideoID, uint32 cchURLSize, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType *pPreviewType ) = 0;
+	virtual uint32 GetQueryUGCNumKeyValueTags( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, STEAM_OUT_STRING_COUNT(cchKeySize) char *pchKey, uint32 cchKeySize, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0;
+
+	// Return the first value matching the pchKey. Note that a key may map to multiple values.  Returns false if there was an error or no matching value was found.
+	STEAM_FLAT_NAME( GetQueryFirstUGCKeyValueTag )
+	virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, const char *pchKey, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0;
+
+	// Release the request to free up memory, after retrieving results
+	virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+	// Options to set for querying UGC
+	virtual bool AddRequiredTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+	virtual bool AddRequiredTagGroup( UGCQueryHandle_t handle, const SteamParamStringArray_t *pTagGroups ) = 0; // match any of the tags in this group
+	virtual bool AddExcludedTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+	virtual bool SetReturnOnlyIDs( UGCQueryHandle_t handle, bool bReturnOnlyIDs ) = 0;
+	virtual bool SetReturnKeyValueTags( UGCQueryHandle_t handle, bool bReturnKeyValueTags ) = 0;
+	virtual bool SetReturnLongDescription( UGCQueryHandle_t handle, bool bReturnLongDescription ) = 0;
+	virtual bool SetReturnMetadata( UGCQueryHandle_t handle, bool bReturnMetadata ) = 0;
+	virtual bool SetReturnChildren( UGCQueryHandle_t handle, bool bReturnChildren ) = 0;
+	virtual bool SetReturnAdditionalPreviews( UGCQueryHandle_t handle, bool bReturnAdditionalPreviews ) = 0;
+	virtual bool SetReturnTotalOnly( UGCQueryHandle_t handle, bool bReturnTotalOnly ) = 0;
+	virtual bool SetReturnPlaytimeStats( UGCQueryHandle_t handle, uint32 unDays ) = 0;
+	virtual bool SetLanguage( UGCQueryHandle_t handle, const char *pchLanguage ) = 0;
+	virtual bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint32 unMaxAgeSeconds ) = 0;
+
+	// Options only for querying user UGC
+	virtual bool SetCloudFileNameFilter( UGCQueryHandle_t handle, const char *pMatchCloudFileName ) = 0;
+
+	// Options only for querying all UGC
+	virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0;
+	virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0;
+	virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0;
+	virtual bool SetTimeCreatedDateRange( UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ) = 0;
+	virtual bool SetTimeUpdatedDateRange( UGCQueryHandle_t handle, RTime32 rtStart, RTime32 rtEnd ) = 0;
+	virtual bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, const char *pKey, const char *pValue ) = 0;
+
+	// DEPRECATED - Use CreateQueryUGCDetailsRequest call above instead!
+	STEAM_CALL_RESULT( SteamUGCRequestUGCDetailsResult_t )
+	virtual SteamAPICall_t RequestUGCDetails( PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds ) = 0;
+
+	// Steam Workshop Creator API
+	STEAM_CALL_RESULT( CreateItemResult_t )
+	virtual SteamAPICall_t CreateItem( AppId_t nConsumerAppId, EWorkshopFileType eFileType ) = 0; // create new item for this app with no content attached yet
+
+	virtual UGCUpdateHandle_t StartItemUpdate( AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID ) = 0; // start an UGC item update. Set changed properties before commiting update with CommitItemUpdate()
+
+	virtual bool SetItemTitle( UGCUpdateHandle_t handle, const char *pchTitle ) = 0; // change the title of an UGC item
+	virtual bool SetItemDescription( UGCUpdateHandle_t handle, const char *pchDescription ) = 0; // change the description of an UGC item
+	virtual bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, const char *pchLanguage ) = 0; // specify the language of the title or description that will be set
+	virtual bool SetItemMetadata( UGCUpdateHandle_t handle, const char *pchMetaData ) = 0; // change the metadata of an UGC item (max = k_cchDeveloperMetadataMax)
+	virtual bool SetItemVisibility( UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0; // change the visibility of an UGC item
+	virtual bool SetItemTags( UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags ) = 0; // change the tags of an UGC item
+	virtual bool SetItemContent( UGCUpdateHandle_t handle, const char *pszContentFolder ) = 0; // update item content from this local folder
+	virtual bool SetItemPreview( UGCUpdateHandle_t handle, const char *pszPreviewFile ) = 0; //  change preview image file for this item. pszPreviewFile points to local image file, which must be under 1MB in size
+	virtual bool SetAllowLegacyUpload( UGCUpdateHandle_t handle, bool bAllowLegacyUpload ) = 0; //  use legacy upload for a single small file. The parameter to SetItemContent() should either be a directory with one file or the full path to the file.  The file must also be less than 10MB in size.
+	virtual bool RemoveAllItemKeyValueTags( UGCUpdateHandle_t handle ) = 0; // remove all existing key-value tags (you can add new ones via the AddItemKeyValueTag function)
+	virtual bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, const char *pchKey ) = 0; // remove any existing key-value tags with the specified key
+	virtual bool AddItemKeyValueTag( UGCUpdateHandle_t handle, const char *pchKey, const char *pchValue ) = 0; // add new key-value tags for the item. Note that there can be multiple values for a tag.
+	virtual bool AddItemPreviewFile( UGCUpdateHandle_t handle, const char *pszPreviewFile, EItemPreviewType type ) = 0; //  add preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size
+	virtual bool AddItemPreviewVideo( UGCUpdateHandle_t handle, const char *pszVideoID ) = 0; //  add preview video for this item
+	virtual bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint32 index, const char *pszPreviewFile ) = 0; //  updates an existing preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size
+	virtual bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint32 index, const char *pszVideoID ) = 0; //  updates an existing preview video for this item
+	virtual bool RemoveItemPreview( UGCUpdateHandle_t handle, uint32 index ) = 0; // remove a preview by index starting at 0 (previews are sorted)
+
+	STEAM_CALL_RESULT( SubmitItemUpdateResult_t )
+	virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate()
+	virtual EItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal ) = 0;
+
+	// Steam Workshop Consumer API
+	STEAM_CALL_RESULT( SetUserItemVoteResult_t )
+	virtual SteamAPICall_t SetUserItemVote( PublishedFileId_t nPublishedFileID, bool bVoteUp ) = 0;
+	STEAM_CALL_RESULT( GetUserItemVoteResult_t )
+	virtual SteamAPICall_t GetUserItemVote( PublishedFileId_t nPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t )
+	virtual SteamAPICall_t AddItemToFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t )
+	virtual SteamAPICall_t RemoveItemFromFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( RemoteStorageSubscribePublishedFileResult_t )
+	virtual SteamAPICall_t SubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // subscribe to this item, will be installed ASAP
+	STEAM_CALL_RESULT( RemoteStorageUnsubscribePublishedFileResult_t )
+	virtual SteamAPICall_t UnsubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // unsubscribe from this item, will be uninstalled after game quits
+	virtual uint32 GetNumSubscribedItems() = 0; // number of subscribed items 
+	virtual uint32 GetSubscribedItems( PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0; // all subscribed item PublishFileIDs
+
+	// get EItemState flags about item on this client
+	virtual uint32 GetItemState( PublishedFileId_t nPublishedFileID ) = 0;
+
+	// get info about currently installed content on disc for items that have k_EItemStateInstalled set
+	// if k_EItemStateLegacyItem is set, pchFolder contains the path to the legacy file itself (not a folder)
+	virtual bool GetItemInstallInfo( PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, STEAM_OUT_STRING_COUNT( cchFolderSize ) char *pchFolder, uint32 cchFolderSize, uint32 *punTimeStamp ) = 0;
+
+	// get info about pending update for items that have k_EItemStateNeedsUpdate set. punBytesTotal will be valid after download started once
+	virtual bool GetItemDownloadInfo( PublishedFileId_t nPublishedFileID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0;
+		
+	// download new or update already installed item. If function returns true, wait for DownloadItemResult_t. If the item is already installed,
+	// then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time.
+	// If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP.
+	virtual bool DownloadItem( PublishedFileId_t nPublishedFileID, bool bHighPriority ) = 0;
+
+	// game servers can set a specific workshop folder before issuing any UGC commands.
+	// This is helpful if you want to support multiple game servers running out of the same install folder
+	virtual bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, const char *pszFolder ) = 0;
+
+	// SuspendDownloads( true ) will suspend all workshop downloads until SuspendDownloads( false ) is called or the game ends
+	virtual void SuspendDownloads( bool bSuspend ) = 0;
+
+	// usage tracking
+	STEAM_CALL_RESULT( StartPlaytimeTrackingResult_t )
+	virtual SteamAPICall_t StartPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
+	STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t )
+	virtual SteamAPICall_t StopPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
+	STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t )
+	virtual SteamAPICall_t StopPlaytimeTrackingForAllItems() = 0;
+
+	// parent-child relationship or dependency management
+	STEAM_CALL_RESULT( AddUGCDependencyResult_t )
+	virtual SteamAPICall_t AddDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( RemoveUGCDependencyResult_t )
+	virtual SteamAPICall_t RemoveDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0;
+
+	// add/remove app dependence/requirements (usually DLC)
+	STEAM_CALL_RESULT( AddAppDependencyResult_t )
+	virtual SteamAPICall_t AddAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0;
+	STEAM_CALL_RESULT( RemoveAppDependencyResult_t )
+	virtual SteamAPICall_t RemoveAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0;
+	// request app dependencies. note that whatever callback you register for GetAppDependenciesResult_t may be called multiple times
+	// until all app dependencies have been returned
+	STEAM_CALL_RESULT( GetAppDependenciesResult_t )
+	virtual SteamAPICall_t GetAppDependencies( PublishedFileId_t nPublishedFileID ) = 0;
+	
+	// delete the item without prompting the user
+	STEAM_CALL_RESULT( DeleteItemResult_t )
+	virtual SteamAPICall_t DeleteItem( PublishedFileId_t nPublishedFileID ) = 0;
+
+	// Show the app's latest Workshop EULA to the user in an overlay window, where they can accept it or not
+	virtual bool ShowWorkshopEULA() = 0;
+	// Retrieve information related to the user's acceptance or not of the app's specific Workshop EULA
+	STEAM_CALL_RESULT( WorkshopEULAStatus_t )
+	virtual SteamAPICall_t GetWorkshopEULAStatus() = 0;
+};
+
+#endif // ISTEAMUGC016_H

sdk_includes/isteamuser.h

@@ -118,7 +118,16 @@ public:
 
 	// Retrieve ticket to be sent to the entity who wishes to authenticate you. 
 	// pcbTicket retrieves the length of the actual ticket.
-	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+	// SteamNetworkingIdentity is an optional input parameter to hold the public IP address or SteamID of the entity you are connecting to
+	// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address
+	// if a Steam ID is passed Steam will only allow the ticket to be used by that Steam ID
+	// not to be used for "ISteamUserAuth\AuthenticateUserTicket" - it will fail
+	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSteamNetworkingIdentity ) = 0;
+
+	// Request a ticket which will be used for webapi "ISteamUserAuth\AuthenticateUserTicket"
+	// pchIdentity is an optional input parameter to identify the service the ticket will be sent to
+	// the ticket will be returned in callback GetTicketForWebApiResponse_t
+	virtual HAuthTicket GetAuthTicketForWebApi( const char *pchIdentity ) = 0;
 
 	// Authenticate ticket from entity steamID to be sure it is valid and isnt reused
 	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
@@ -204,7 +213,7 @@ public:
 
 };
 
-#define STEAMUSER_INTERFACE_VERSION "SteamUser021"
+#define STEAMUSER_INTERFACE_VERSION "SteamUser023"
 
 #ifndef STEAM_API_EXPORTS
 // Global interface accessor
@@ -221,12 +230,13 @@ STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamUser *, SteamUser, STEAMUSER_INTERFA
 #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
 #endif 
 
+
 //-----------------------------------------------------------------------------
-// Purpose: called when a connections to the Steam back-end has been established
+// Purpose: Called when an authenticated connection to the Steam back-end has been established.
-//			this means the Steam client now has a working connection to the Steam servers
+//			This means the Steam client now has a working connection to the Steam servers.
-//			usually this will have occurred before the game has launched, and should
+//			Usually this will have occurred before the game has launched, and should
 //			only be seen if the user has dropped connection due to a networking issue
-//			or a Steam server update
+//			or a Steam server update.
 //-----------------------------------------------------------------------------
 struct SteamServersConnected_t
 {
@@ -346,7 +356,6 @@ struct GetAuthSessionTicketResponse_t
 	EResult m_eResult;
 };
 
-
 //-----------------------------------------------------------------------------
 // Purpose: sent to your game in response to a steam://gamewebcallback/ command
 //-----------------------------------------------------------------------------
@@ -407,6 +416,20 @@ struct DurationControl_t
 };
 
 
+//-----------------------------------------------------------------------------
+// callback for GetTicketForWebApi
+//-----------------------------------------------------------------------------
+struct GetTicketForWebApiResponse_t
+{
+	enum { k_iCallback = k_iSteamUserCallbacks + 68 };
+	HAuthTicket m_hAuthTicket;
+	EResult m_eResult;
+	int m_cubTicket;
+	static const int k_nCubTicketMaxLength = 2560;
+	uint8 m_rgubTicket[k_nCubTicketMaxLength];
+};
+
+
 #pragma pack( pop )
 
 #endif // ISTEAMUSER_H

sdk_includes/isteamuser021.h

@@ -0,0 +1,197 @@
+
+#ifndef ISTEAMUSER021_H
+#define ISTEAMUSER021_H
+#ifdef STEAM_WIN32
+#pragma once
+#endif
+
+
+class ISteamUser021
+{
+public:
+	// returns the HSteamUser this interface represents
+	// this is only used internally by the API, and by a few select interfaces that support multi-user
+	virtual HSteamUser GetHSteamUser() = 0;
+
+	// returns true if the Steam client current has a live connection to the Steam servers. 
+	// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
+	// The Steam client will automatically be trying to recreate the connection as often as possible.
+	virtual bool BLoggedOn() = 0;
+
+	// returns the CSteamID of the account currently logged into the Steam client
+	// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
+	virtual CSteamID GetSteamID() = 0;
+
+	// Multiplayer Authentication functions
+	
+	// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
+	// It is the client portion of a three-way handshake between the client, the game server, and the steam servers
+	//
+	// Parameters:
+	// void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token.
+	// int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes.
+	// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+	// CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( <appID> )
+	// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+	// bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running)
+	//
+	// return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed
+	// The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
+	virtual int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
+
+	// notify of disconnect
+	// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
+	virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
+
+	// Legacy functions
+
+	// used by only a few games to track usage events
+	virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
+
+	// get the local storage folder for current Steam account to write application data, e.g. save games, configs etc.
+	// this will usually be something like "C:\Progam Files\Steam\userdata\<SteamID>\<AppID>\local"
+	virtual bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) = 0;
+
+	// Starts voice recording. Once started, use GetVoice() to get the data
+	virtual void StartVoiceRecording( ) = 0;
+
+	// Stops voice recording. Because people often release push-to-talk keys early, the system will keep recording for
+	// a little bit after this function is called. GetVoice() should continue to be called until it returns
+	// k_eVoiceResultNotRecording
+	virtual void StopVoiceRecording( ) = 0;
+
+	// Determine the size of captured audio data that is available from GetVoice.
+	// Most applications will only use compressed data and should ignore the other
+	// parameters, which exist primarily for backwards compatibility. See comments
+	// below for further explanation of "uncompressed" data.
+	virtual EVoiceResult GetAvailableVoice( uint32 *pcbCompressed, uint32 *pcbUncompressed_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0 ) = 0;
+
+	// ---------------------------------------------------------------------------
+	// NOTE: "uncompressed" audio is a deprecated feature and should not be used
+	// by most applications. It is raw single-channel 16-bit PCM wave data which
+	// may have been run through preprocessing filters and/or had silence removed,
+	// so the uncompressed audio could have a shorter duration than you expect.
+	// There may be no data at all during long periods of silence. Also, fetching
+	// uncompressed audio will cause GetVoice to discard any leftover compressed
+	// audio, so you must fetch both types at once. Finally, GetAvailableVoice is
+	// not precisely accurate when the uncompressed size is requested. So if you
+	// really need to use uncompressed audio, you should call GetVoice frequently
+	// with two very large (20kb+) output buffers instead of trying to allocate
+	// perfectly-sized buffers. But most applications should ignore all of these
+	// details and simply leave the "uncompressed" parameters as NULL/zero.
+	// ---------------------------------------------------------------------------
+
+	// Read captured audio data from the microphone buffer. This should be called
+	// at least once per frame, and preferably every few milliseconds, to keep the
+	// microphone input delay as low as possible. Most applications will only use
+	// compressed data and should pass NULL/zero for the "uncompressed" parameters.
+	// Compressed data can be transmitted by your application and decoded into raw
+	// using the DecompressVoice function below.
+	virtual EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed_Deprecated = false, void *pUncompressedDestBuffer_Deprecated = 0, uint32 cbUncompressedDestBufferSize_Deprecated = 0, uint32 *nUncompressBytesWritten_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0 ) = 0;
+
+	// Decodes the compressed voice data returned by GetVoice. The output data is
+	// raw single-channel 16-bit PCM audio. The decoder supports any sample rate
+	// from 11025 to 48000; see GetVoiceOptimalSampleRate() below for details.
+	// If the output buffer is not large enough, then *nBytesWritten will be set
+	// to the required buffer size, and k_EVoiceResultBufferTooSmall is returned.
+	// It is suggested to start with a 20kb buffer and reallocate as necessary.
+	virtual EVoiceResult DecompressVoice( const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate ) = 0;
+
+	// This returns the native sample rate of the Steam voice decompressor; using
+	// this sample rate for DecompressVoice will perform the least CPU processing.
+	// However, the final audio quality will depend on how well the audio device
+	// (and/or your application's audio output SDK) deals with lower sample rates.
+	// You may find that you get the best audio output quality when you ignore
+	// this function and use the native sample rate of your audio output device,
+	// which is usually 48000 or 44100.
+	virtual uint32 GetVoiceOptimalSampleRate() = 0;
+
+	// Retrieve ticket to be sent to the entity who wishes to authenticate you. 
+	// pcbTicket retrieves the length of the actual ticket.
+	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+
+	// Authenticate ticket from entity steamID to be sure it is valid and isnt reused
+	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+	virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0;
+
+	// Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
+	virtual void EndAuthSession( CSteamID steamID ) = 0;
+
+	// Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
+	virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;
+
+	// After receiving a user's authentication data, and passing it to BeginAuthSession, use this function
+	// to determine if the user owns downloadable content specified by the provided AppID.
+	virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0;
+	
+	// returns true if this users looks like they are behind a NAT device. Only valid once the user has connected to steam 
+	// (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT.
+	virtual bool BIsBehindNAT() = 0;
+
+	// set data to be replicated to friends so that they can join your game
+	// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+	// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+	virtual void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) = 0;
+
+	// Requests a ticket encrypted with an app specific shared key
+	// pDataToInclude, cbDataToInclude will be encrypted into the ticket
+	// ( This is asynchronous, you must wait for the ticket to be completed by the server )
+	STEAM_CALL_RESULT( EncryptedAppTicketResponse_t )
+	virtual SteamAPICall_t RequestEncryptedAppTicket( void *pDataToInclude, int cbDataToInclude ) = 0;
+
+	// Retrieves a finished ticket.
+	// If no ticket is available, or your buffer is too small, returns false.
+	// Upon exit, *pcbTicket will be either the size of the ticket copied into your buffer
+	// (if true was returned), or the size needed (if false was returned).  To determine the
+	// proper size of the ticket, you can pass pTicket=NULL and cbMaxTicket=0; if a ticket
+	// is available, *pcbTicket will contain the size needed, otherwise it will be zero.
+	virtual bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+
+	// Trading Card badges data access
+	// if you only have one set of cards, the series will be 1
+	// the user has can have two different badges for a series; the regular (max level 5) and the foil (max level 1)
+	virtual int GetGameBadgeLevel( int nSeries, bool bFoil ) = 0;
+
+	// gets the Steam Level of the user, as shown on their profile
+	virtual int GetPlayerSteamLevel() = 0;
+
+	// Requests a URL which authenticates an in-game browser for store check-out,
+	// and then redirects to the specified URL. As long as the in-game browser
+	// accepts and handles session cookies, Steam microtransaction checkout pages
+	// will automatically recognize the user instead of presenting a login page.
+	// The result of this API call will be a StoreAuthURLResponse_t callback.
+	// NOTE: The URL has a very short lifetime to prevent history-snooping attacks,
+	// so you should only call this API when you are about to launch the browser,
+	// or else immediately navigate to the result URL using a hidden browser window.
+	// NOTE 2: The resulting authorization cookie has an expiration time of one day,
+	// so it would be a good idea to request and visit a new auth URL every 12 hours.
+	STEAM_CALL_RESULT( StoreAuthURLResponse_t )
+	virtual SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL ) = 0;
+
+	// gets whether the users phone number is verified 
+	virtual bool BIsPhoneVerified() = 0;
+
+	// gets whether the user has two factor enabled on their account
+	virtual bool BIsTwoFactorEnabled() = 0;
+
+	// gets whether the users phone number is identifying
+	virtual bool BIsPhoneIdentifying() = 0;
+
+	// gets whether the users phone number is awaiting (re)verification
+	virtual bool BIsPhoneRequiringVerification() = 0;
+
+	STEAM_CALL_RESULT( MarketEligibilityResponse_t )
+	virtual SteamAPICall_t GetMarketEligibility() = 0;
+
+	// Retrieves anti indulgence / duration control for current user
+	STEAM_CALL_RESULT( DurationControl_t )
+	virtual SteamAPICall_t GetDurationControl() = 0;
+
+	// Advise steam china duration control system about the online state of the game.
+	// This will prevent offline gameplay time from counting against a user's
+	// playtime limits.
+	virtual bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState ) = 0;
+};
+
+
+#endif // ISTEAMUSER021_H

sdk_includes/isteamuser022.h

@@ -0,0 +1,201 @@
+
+#ifndef ISTEAMUSER022_H
+#define ISTEAMUSER022_H
+#ifdef STEAM_WIN32
+#pragma once
+#endif
+
+
+class ISteamUser022
+{
+public:
+	// returns the HSteamUser this interface represents
+	// this is only used internally by the API, and by a few select interfaces that support multi-user
+	virtual HSteamUser GetHSteamUser() = 0;
+
+	// returns true if the Steam client current has a live connection to the Steam servers. 
+	// If false, it means there is no active connection due to either a networking issue on the local machine, or the Steam server is down/busy.
+	// The Steam client will automatically be trying to recreate the connection as often as possible.
+	virtual bool BLoggedOn() = 0;
+
+	// returns the CSteamID of the account currently logged into the Steam client
+	// a CSteamID is a unique identifier for an account, and used to differentiate users in all parts of the Steamworks API
+	virtual CSteamID GetSteamID() = 0;
+
+	// Multiplayer Authentication functions
+	
+	// InitiateGameConnection() starts the state machine for authenticating the game client with the game server
+	// It is the client portion of a three-way handshake between the client, the game server, and the steam servers
+	//
+	// Parameters:
+	// void *pAuthBlob - a pointer to empty memory that will be filled in with the authentication token.
+	// int cbMaxAuthBlob - the number of bytes of allocated memory in pBlob. Should be at least 2048 bytes.
+	// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+	// CGameID gameID - the ID of the current game. For games without mods, this is just CGameID( <appID> )
+	// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+	// bool bSecure - whether or not the client thinks that the game server is reporting itself as secure (i.e. VAC is running)
+	//
+	// return value - returns the number of bytes written to pBlob. If the return is 0, then the buffer passed in was too small, and the call has failed
+	// The contents of pBlob should then be sent to the game server, for it to use to complete the authentication process.
+	virtual int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer, bool bSecure ) = 0;
+
+	// notify of disconnect
+	// needs to occur when the game client leaves the specified game server, needs to match with the InitiateGameConnection() call
+	virtual void TerminateGameConnection( uint32 unIPServer, uint16 usPortServer ) = 0;
+
+	// Legacy functions
+
+	// used by only a few games to track usage events
+	virtual void TrackAppUsageEvent( CGameID gameID, int eAppUsageEvent, const char *pchExtraInfo = "" ) = 0;
+
+	// get the local storage folder for current Steam account to write application data, e.g. save games, configs etc.
+	// this will usually be something like "C:\Progam Files\Steam\userdata\<SteamID>\<AppID>\local"
+	virtual bool GetUserDataFolder( char *pchBuffer, int cubBuffer ) = 0;
+
+	// Starts voice recording. Once started, use GetVoice() to get the data
+	virtual void StartVoiceRecording( ) = 0;
+
+	// Stops voice recording. Because people often release push-to-talk keys early, the system will keep recording for
+	// a little bit after this function is called. GetVoice() should continue to be called until it returns
+	// k_eVoiceResultNotRecording
+	virtual void StopVoiceRecording( ) = 0;
+
+	// Determine the size of captured audio data that is available from GetVoice.
+	// Most applications will only use compressed data and should ignore the other
+	// parameters, which exist primarily for backwards compatibility. See comments
+	// below for further explanation of "uncompressed" data.
+	virtual EVoiceResult GetAvailableVoice( uint32 *pcbCompressed, uint32 *pcbUncompressed_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0 ) = 0;
+
+	// ---------------------------------------------------------------------------
+	// NOTE: "uncompressed" audio is a deprecated feature and should not be used
+	// by most applications. It is raw single-channel 16-bit PCM wave data which
+	// may have been run through preprocessing filters and/or had silence removed,
+	// so the uncompressed audio could have a shorter duration than you expect.
+	// There may be no data at all during long periods of silence. Also, fetching
+	// uncompressed audio will cause GetVoice to discard any leftover compressed
+	// audio, so you must fetch both types at once. Finally, GetAvailableVoice is
+	// not precisely accurate when the uncompressed size is requested. So if you
+	// really need to use uncompressed audio, you should call GetVoice frequently
+	// with two very large (20kb+) output buffers instead of trying to allocate
+	// perfectly-sized buffers. But most applications should ignore all of these
+	// details and simply leave the "uncompressed" parameters as NULL/zero.
+	// ---------------------------------------------------------------------------
+
+	// Read captured audio data from the microphone buffer. This should be called
+	// at least once per frame, and preferably every few milliseconds, to keep the
+	// microphone input delay as low as possible. Most applications will only use
+	// compressed data and should pass NULL/zero for the "uncompressed" parameters.
+	// Compressed data can be transmitted by your application and decoded into raw
+	// using the DecompressVoice function below.
+	virtual EVoiceResult GetVoice( bool bWantCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, bool bWantUncompressed_Deprecated = false, void *pUncompressedDestBuffer_Deprecated = 0, uint32 cbUncompressedDestBufferSize_Deprecated = 0, uint32 *nUncompressBytesWritten_Deprecated = 0, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated = 0 ) = 0;
+
+	// Decodes the compressed voice data returned by GetVoice. The output data is
+	// raw single-channel 16-bit PCM audio. The decoder supports any sample rate
+	// from 11025 to 48000; see GetVoiceOptimalSampleRate() below for details.
+	// If the output buffer is not large enough, then *nBytesWritten will be set
+	// to the required buffer size, and k_EVoiceResultBufferTooSmall is returned.
+	// It is suggested to start with a 20kb buffer and reallocate as necessary.
+	virtual EVoiceResult DecompressVoice( const void *pCompressed, uint32 cbCompressed, void *pDestBuffer, uint32 cbDestBufferSize, uint32 *nBytesWritten, uint32 nDesiredSampleRate ) = 0;
+
+	// This returns the native sample rate of the Steam voice decompressor; using
+	// this sample rate for DecompressVoice will perform the least CPU processing.
+	// However, the final audio quality will depend on how well the audio device
+	// (and/or your application's audio output SDK) deals with lower sample rates.
+	// You may find that you get the best audio output quality when you ignore
+	// this function and use the native sample rate of your audio output device,
+	// which is usually 48000 or 44100.
+	virtual uint32 GetVoiceOptimalSampleRate() = 0;
+
+	// Retrieve ticket to be sent to the entity who wishes to authenticate you. 
+	// pcbTicket retrieves the length of the actual ticket.
+	// SteamNetworkingIdentity is an optional input parameter to hold the public IP address or SteamID of the entity you are connecting to
+	// if an IP address is passed Steam will only allow the ticket to be used by an entity with that IP address
+	// if a Steam ID is passed Steam will only allow the ticket to be used by that Steam ID
+	virtual HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket, const SteamNetworkingIdentity *pSteamNetworkingIdentity ) = 0;
+
+	// Authenticate ticket from entity steamID to be sure it is valid and isnt reused
+	// Registers for callbacks if the entity goes offline or cancels the ticket ( see ValidateAuthTicketResponse_t callback and EAuthSessionResponse )
+	virtual EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) = 0;
+
+	// Stop tracking started by BeginAuthSession - called when no longer playing game with this entity
+	virtual void EndAuthSession( CSteamID steamID ) = 0;
+
+	// Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to
+	virtual void CancelAuthTicket( HAuthTicket hAuthTicket ) = 0;
+
+	// After receiving a user's authentication data, and passing it to BeginAuthSession, use this function
+	// to determine if the user owns downloadable content specified by the provided AppID.
+	virtual EUserHasLicenseForAppResult UserHasLicenseForApp( CSteamID steamID, AppId_t appID ) = 0;
+	
+	// returns true if this users looks like they are behind a NAT device. Only valid once the user has connected to steam 
+	// (i.e a SteamServersConnected_t has been issued) and may not catch all forms of NAT.
+	virtual bool BIsBehindNAT() = 0;
+
+	// set data to be replicated to friends so that they can join your game
+	// CSteamID steamIDGameServer - the steamID of the game server, received from the game server by the client
+	// uint32 unIPServer, uint16 usPortServer - the IP address of the game server
+	virtual void AdvertiseGame( CSteamID steamIDGameServer, uint32 unIPServer, uint16 usPortServer ) = 0;
+
+	// Requests a ticket encrypted with an app specific shared key
+	// pDataToInclude, cbDataToInclude will be encrypted into the ticket
+	// ( This is asynchronous, you must wait for the ticket to be completed by the server )
+	STEAM_CALL_RESULT( EncryptedAppTicketResponse_t )
+	virtual SteamAPICall_t RequestEncryptedAppTicket( void *pDataToInclude, int cbDataToInclude ) = 0;
+
+	// Retrieves a finished ticket.
+	// If no ticket is available, or your buffer is too small, returns false.
+	// Upon exit, *pcbTicket will be either the size of the ticket copied into your buffer
+	// (if true was returned), or the size needed (if false was returned).  To determine the
+	// proper size of the ticket, you can pass pTicket=NULL and cbMaxTicket=0; if a ticket
+	// is available, *pcbTicket will contain the size needed, otherwise it will be zero.
+	virtual bool GetEncryptedAppTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) = 0;
+
+	// Trading Card badges data access
+	// if you only have one set of cards, the series will be 1
+	// the user has can have two different badges for a series; the regular (max level 5) and the foil (max level 1)
+	virtual int GetGameBadgeLevel( int nSeries, bool bFoil ) = 0;
+
+	// gets the Steam Level of the user, as shown on their profile
+	virtual int GetPlayerSteamLevel() = 0;
+
+	// Requests a URL which authenticates an in-game browser for store check-out,
+	// and then redirects to the specified URL. As long as the in-game browser
+	// accepts and handles session cookies, Steam microtransaction checkout pages
+	// will automatically recognize the user instead of presenting a login page.
+	// The result of this API call will be a StoreAuthURLResponse_t callback.
+	// NOTE: The URL has a very short lifetime to prevent history-snooping attacks,
+	// so you should only call this API when you are about to launch the browser,
+	// or else immediately navigate to the result URL using a hidden browser window.
+	// NOTE 2: The resulting authorization cookie has an expiration time of one day,
+	// so it would be a good idea to request and visit a new auth URL every 12 hours.
+	STEAM_CALL_RESULT( StoreAuthURLResponse_t )
+	virtual SteamAPICall_t RequestStoreAuthURL( const char *pchRedirectURL ) = 0;
+
+	// gets whether the users phone number is verified 
+	virtual bool BIsPhoneVerified() = 0;
+
+	// gets whether the user has two factor enabled on their account
+	virtual bool BIsTwoFactorEnabled() = 0;
+
+	// gets whether the users phone number is identifying
+	virtual bool BIsPhoneIdentifying() = 0;
+
+	// gets whether the users phone number is awaiting (re)verification
+	virtual bool BIsPhoneRequiringVerification() = 0;
+
+	STEAM_CALL_RESULT( MarketEligibilityResponse_t )
+	virtual SteamAPICall_t GetMarketEligibility() = 0;
+
+	// Retrieves anti indulgence / duration control for current user
+	STEAM_CALL_RESULT( DurationControl_t )
+	virtual SteamAPICall_t GetDurationControl() = 0;
+
+	// Advise steam china duration control system about the online state of the game.
+	// This will prevent offline gameplay time from counting against a user's
+	// playtime limits.
+	virtual bool BSetDurationControlOnlineState( EDurationControlOnlineState eNewState ) = 0;
+
+};
+
+
+#endif // ISTEAMUSER022_H

sdk_includes/isteamutils.h

@@ -319,6 +319,7 @@ struct GamepadTextInputDismissed_t
 	enum { k_iCallback = k_iSteamUtilsCallbacks + 14 };
 	bool m_bSubmitted;										// true if user entered & accepted text (Call ISteamUtils::GetEnteredGamepadTextInput() for text), false if canceled input
 	uint32 m_unSubmittedText;
+	AppId_t m_unAppID;
 };
 
 // k_iSteamUtilsCallbacks + 15 through 35 are taken
@@ -336,6 +337,15 @@ struct FloatingGamepadTextInputDismissed_t
 	enum { k_iCallback = k_iSteamUtilsCallbacks + 38 };
 };
 
+//-----------------------------------------------------------------------------
+// The text filtering dictionary has changed
+//-----------------------------------------------------------------------------
+struct FilterTextDictionaryChanged_t
+{
+	enum { k_iCallback = k_iSteamUtilsCallbacks + 39 };
+	int m_eLanguage;	// One of ELanguage, or k_LegallyRequiredFiltering
+};
+
 #pragma pack( pop )
 
 #endif // ISTEAMUTILS_H

sdk_includes/steam_api.h

@@ -48,6 +48,8 @@
 #include "isteamuser018.h"
 #include "isteamuser019.h"
 #include "isteamuser020.h"
+#include "isteamuser021.h"
+#include "isteamuser022.h"
 #include "isteamfriends.h"
 #include "isteamfriends003.h"
 #include "isteamfriends004.h"
@@ -160,6 +162,7 @@
 #include "isteamugc013.h"
 #include "isteamugc014.h"
 #include "isteamugc015.h"
+#include "isteamugc016.h"
 #include "isteamapplist.h"
 #include "isteamhtmlsurface.h"
 #include "isteamhtmlsurface001.h"

sdk_includes/steam_api_flat.h

@@ -56,6 +56,8 @@ STEAMAPI_API ISteamParties * SteamAPI_ISteamClient_GetISteamParties( ISteamClien
 STEAMAPI_API ISteamRemotePlay * SteamAPI_ISteamClient_GetISteamRemotePlay( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion );
 
 // ISteamUser
+STEAMAPI_API ISteamUser *SteamAPI_SteamUser_v023();
+STEAMAPI_API ISteamUser *SteamAPI_SteamUser_v022();
 STEAMAPI_API ISteamUser *SteamAPI_SteamUser_v021();
 STEAMAPI_API ISteamUser *SteamAPI_SteamUser_v020();
 STEAMAPI_API HSteamUser SteamAPI_ISteamUser_GetHSteamUser( ISteamUser* self );
@@ -73,7 +75,8 @@ STEAMAPI_API EVoiceResult SteamAPI_ISteamUser_GetAvailableVoice( ISteamUser* sel
 STEAMAPI_API EVoiceResult SteamAPI_ISteamUser_GetVoice( ISteamUser* self, bool bWantCompressed, void * pDestBuffer, uint32 cbDestBufferSize, uint32 * nBytesWritten, bool bWantUncompressed_Deprecated, void * pUncompressedDestBuffer_Deprecated, uint32 cbUncompressedDestBufferSize_Deprecated, uint32 * nUncompressBytesWritten_Deprecated, uint32 nUncompressedVoiceDesiredSampleRate_Deprecated );
 STEAMAPI_API EVoiceResult SteamAPI_ISteamUser_DecompressVoice( ISteamUser* self, const void * pCompressed, uint32 cbCompressed, void * pDestBuffer, uint32 cbDestBufferSize, uint32 * nBytesWritten, uint32 nDesiredSampleRate );
 STEAMAPI_API uint32 SteamAPI_ISteamUser_GetVoiceOptimalSampleRate( ISteamUser* self );
-STEAMAPI_API HAuthTicket SteamAPI_ISteamUser_GetAuthSessionTicket( ISteamUser* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket );
+STEAMAPI_API HAuthTicket SteamAPI_ISteamUser_GetAuthSessionTicket( ISteamUser* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket, const SteamNetworkingIdentity * pSteamNetworkingIdentity );
+STEAMAPI_API HAuthTicket SteamAPI_ISteamUser_GetAuthTicketForWebApi( ISteamUser* self, const char * pchIdentity );
 STEAMAPI_API EBeginAuthSessionResult SteamAPI_ISteamUser_BeginAuthSession( ISteamUser* self, const void * pAuthTicket, int cbAuthTicket, uint64_steamid steamID );
 STEAMAPI_API void SteamAPI_ISteamUser_EndAuthSession( ISteamUser* self, uint64_steamid steamID );
 STEAMAPI_API void SteamAPI_ISteamUser_CancelAuthTicket( ISteamUser* self, HAuthTicket hAuthTicket );
@@ -693,9 +696,11 @@ STEAMAPI_API steam_bool SteamAPI_ISteamController_GetControllerBindingRevision(
 STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v014();
 STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v015();
 STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v016();
+STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v017();
 STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v014();
 STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v015();
 STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v016();
+STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v017();
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest( ISteamUGC* self, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor );
@@ -714,6 +719,7 @@ STEAMAPI_API steam_bool SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview( ISteamU
 STEAMAPI_API uint32 SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index );
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char * pchKey, uint32 cchKeySize, char * pchValue, uint32 cchValueSize );
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, const char * pchKey, char * pchValue, uint32 cchValueSize );
+STEAMAPI_API uint32 SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID * pvecDescriptors, uint32 cMaxEntries );
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_ReleaseQueryUGCRequest( ISteamUGC* self, UGCQueryHandle_t handle );
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_AddRequiredTag( ISteamUGC* self, UGCQueryHandle_t handle, const char * pTagName );
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_AddRequiredTagGroup( ISteamUGC* self, UGCQueryHandle_t handle, const SteamParamStringArray_t * pTagGroups );
@@ -755,6 +761,8 @@ STEAMAPI_API steam_bool SteamAPI_ISteamUGC_AddItemPreviewVideo( ISteamUGC* self,
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_UpdateItemPreviewFile( ISteamUGC* self, UGCUpdateHandle_t handle, uint32 index, const char * pszPreviewFile );
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_UpdateItemPreviewVideo( ISteamUGC* self, UGCUpdateHandle_t handle, uint32 index, const char * pszVideoID );
 STEAMAPI_API steam_bool SteamAPI_ISteamUGC_RemoveItemPreview( ISteamUGC* self, UGCUpdateHandle_t handle, uint32 index );
+STEAMAPI_API steam_bool SteamAPI_ISteamUGC_AddContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid );
+STEAMAPI_API steam_bool SteamAPI_ISteamUGC_RemoveContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid );
 STEAMAPI_API SteamAPICall_t SteamAPI_ISteamUGC_SubmitItemUpdate( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchChangeNote );
 STEAMAPI_API EItemUpdateStatus SteamAPI_ISteamUGC_GetItemUpdateProgress( ISteamUGC* self, UGCUpdateHandle_t handle, uint64 * punBytesProcessed, uint64 * punBytesTotal );
 STEAMAPI_API SteamAPICall_t SteamAPI_ISteamUGC_SetUserItemVote( ISteamUGC* self, PublishedFileId_t nPublishedFileID, bool bVoteUp );
@@ -1039,6 +1047,7 @@ STEAMAPI_API steam_bool SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_P
 // ISteamGameServer
 STEAMAPI_API ISteamGameServer *SteamAPI_SteamGameServer_v013();
 STEAMAPI_API ISteamGameServer *SteamAPI_SteamGameServer_v014();
+STEAMAPI_API ISteamGameServer *SteamAPI_SteamGameServer_v015();
 STEAMAPI_API void SteamAPI_ISteamGameServer_SetProduct( ISteamGameServer* self, const char * pszProduct );
 STEAMAPI_API void SteamAPI_ISteamGameServer_SetGameDescription( ISteamGameServer* self, const char * pszGameDescription );
 STEAMAPI_API void SteamAPI_ISteamGameServer_SetModDir( ISteamGameServer* self, const char * pszModDir );
@@ -1067,7 +1076,7 @@ STEAMAPI_API uint64_steamid SteamAPI_ISteamGameServer_CreateUnauthenticatedUserC
 STEAMAPI_API void SteamAPI_ISteamGameServer_SendUserDisconnect( ISteamGameServer* self, uint64_steamid steamIDUser );
 STEAMAPI_API steam_bool SteamAPI_ISteamGameServer_BUpdateUserData( ISteamGameServer* self, uint64_steamid steamIDUser, const char * pchPlayerName, uint32 uScore );
 STEAMAPI_API void SteamAPI_ISteamGameServer_SetAdvertiseServerActive( ISteamGameServer* self, bool bActive );
-STEAMAPI_API HAuthTicket SteamAPI_ISteamGameServer_GetAuthSessionTicket( ISteamGameServer* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket );
+STEAMAPI_API HAuthTicket SteamAPI_ISteamGameServer_GetAuthSessionTicket( ISteamGameServer* self, void * pTicket, int cbMaxTicket, uint32 * pcbTicket, const SteamNetworkingIdentity * pSnid );
 STEAMAPI_API EBeginAuthSessionResult SteamAPI_ISteamGameServer_BeginAuthSession( ISteamGameServer* self, const void * pAuthTicket, int cbAuthTicket, uint64_steamid steamID );
 STEAMAPI_API void SteamAPI_ISteamGameServer_EndAuthSession( ISteamGameServer* self, uint64_steamid steamID );
 STEAMAPI_API void SteamAPI_ISteamGameServer_CancelAuthTicket( ISteamGameServer* self, HAuthTicket hAuthTicket );

sdk_includes/steam_api_internal.h

@@ -245,6 +245,9 @@ class ISteamParties;
 class ISteamTV;
 class ISteamRemotePlay;
 
+// Forward declare types
+struct SteamNetworkingIdentity;
+
 //-----------------------------------------------------------------------------
 // Purpose: Base values for callback identifiers, each callback must
 //			have a unique ID.

sdk_includes/steam_gameserver.h

@@ -12,6 +12,7 @@
 
 #include "steam_api.h"
 #include "isteamgameserver.h"
+#include "isteamgameserver014.h"
 #include "isteamgameserver013.h"
 #include "isteamgameserver012.h"
 #include "isteamgameserver011.h"

sdk_includes/steamclientpublic.h

@@ -91,7 +91,7 @@ enum EResult
 	k_EResultAccountLogonDenied = 63,			// account login denied due to 2nd factor authentication failure
 	k_EResultCannotUseOldPassword = 64,			// The requested new password is not legal
 	k_EResultInvalidLoginAuthCode = 65,			// account login denied due to auth code invalid
-	k_EResultAccountLogonDeniedNoMail = 66,		// account login denied due to 2nd factor auth failure - and no mail has been sent
+	k_EResultAccountLogonDeniedNoMail = 66,		// account login denied due to 2nd factor auth failure - and no mail has been sent - partner site specific
 	k_EResultHardwareNotCapableOfIPT = 67,		// 
 	k_EResultIPTInitError = 68,					// 
 	k_EResultParentalControlRestricted = 69,	// operation failed due to parental control restrictions for current user
@@ -220,6 +220,7 @@ enum EAuthSessionResponse
 	k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed = 7,	// This ticket has already been used, it is not valid.
 	k_EAuthSessionResponseAuthTicketInvalid = 8,			// This ticket is not from a user instance currently connected to steam.
 	k_EAuthSessionResponsePublisherIssuedBan = 9,			// The user is banned for this game. The ban came via the web api and not VAC
+	k_EAuthSessionResponseAuthTicketNetworkIdentityFailure = 10,	// The network identity in the ticket does not match the server authenticating the ticket
 };
 
 // results from UserHasLicenseForApp
@@ -439,6 +440,7 @@ enum EMarketingMessageFlags
 //-----------------------------------------------------------------------------
 enum ENotificationPosition
 {
+	k_EPositionInvalid = -1,
 	k_EPositionTopLeft = 0,
 	k_EPositionTopRight = 1,
 	k_EPositionBottomLeft = 2,
@@ -1214,6 +1216,14 @@ class CGameID
 {
 public:
 
+	enum EGameIDType
+	{
+		k_EGameIDTypeApp		= 0,
+		k_EGameIDTypeGameMod	= 1,
+		k_EGameIDTypeShortcut	= 2,
+		k_EGameIDTypeP2P		= 3,
+	};
+
 	CGameID()
 	{
 		m_gameID.m_nType = k_EGameIDTypeApp;
@@ -1244,12 +1254,12 @@ public:
 		m_gameID.m_nAppID = nAppID;
 	}
 
-	CGameID( uint32 nAppID, uint32 nModID )
+	// Not validating anything .. use IsValid()
+	explicit CGameID( uint32 nAppID, uint32 nModID, CGameID::EGameIDType nType )
 	{
-		m_ulGameID = 0;
 		m_gameID.m_nAppID = nAppID;
 		m_gameID.m_nModID = nModID;
-		m_gameID.m_nType = k_EGameIDTypeGameMod;
+		m_gameID.m_nType = nType;
 	}
 
 	CGameID( const CGameID &that )
@@ -1374,10 +1384,14 @@ public:
 		return m_gameID.m_nModID;
 	}
 
-	uint32 AppID() const
+#if !defined(VALVE_SHORTCUT_DEBUG)
+	uint32 AppID( bool = false ) const
 	{
 		return m_gameID.m_nAppID;
 	}
+#else
+	uint32 AppID( bool bShortcutOK = false ) const;
+#endif
 
 	bool operator == ( const CGameID &rhs ) const
 	{
@@ -1403,13 +1417,15 @@ public:
 			return m_gameID.m_nAppID != k_uAppIdInvalid;
 
 		case k_EGameIDTypeGameMod:
-			return m_gameID.m_nAppID != k_uAppIdInvalid && m_gameID.m_nModID & 0x80000000;
+			return m_gameID.m_nAppID != k_uAppIdInvalid && (m_gameID.m_nModID & 0x80000000);
 
 		case k_EGameIDTypeShortcut:
-			return (m_gameID.m_nModID & 0x80000000) != 0;
+			return m_gameID.m_nAppID == k_uAppIdInvalid
+				&& (m_gameID.m_nModID & 0x80000000)
+				&& m_gameID.m_nModID >= (5000 | 0x80000000); // k_unMaxExpectedLocalAppId - shortcuts are pushed beyond that range
 
 		case k_EGameIDTypeP2P:
-			return m_gameID.m_nAppID == k_uAppIdInvalid && m_gameID.m_nModID & 0x80000000;
+			return m_gameID.m_nAppID == k_uAppIdInvalid && (m_gameID.m_nModID & 0x80000000);
 
 		default:
 			return false;
@@ -1422,17 +1438,9 @@ public:
 		m_ulGameID = 0;
 	}
 
-
+//
-
+// Internal stuff.  Use the accessors above if possible
-private:
+//
-
-	enum EGameIDType
-	{
-		k_EGameIDTypeApp		= 0,
-		k_EGameIDTypeGameMod	= 1,
-		k_EGameIDTypeShortcut	= 2,
-		k_EGameIDTypeP2P		= 3,
-	};
 
 	struct GameID_t
 	{
@@ -1452,6 +1460,8 @@ private:
 		uint64 m_ulGameID;
 		GameID_t m_gameID;
 	};
+
+	friend CGameID GameIDFromAppAndModPath( uint32 nAppID, const char *pchModPath );
 };
 
 #pragma pack( pop )
@@ -1521,7 +1531,7 @@ enum ESteamIPv6ConnectivityState
 // Define compile time assert macros to let us validate the structure sizes.
 #define VALVE_COMPILE_TIME_ASSERT( pred ) typedef char compile_time_assert_type[(pred) ? 1 : -1];
 
-#if defined(__linux__) || defined(__APPLE__) 
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
 // The 32-bit version of gcc has the alignment requirement for uint64 and double set to
 // 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
 // The 64-bit version of gcc has the alignment requirement for these types set to

sdk_includes/steamhttpenums.h

@@ -62,6 +62,7 @@ enum EHTTPStatusCode
 	k_EHTTPStatusCode305UseProxy =				305,
 	//k_EHTTPStatusCode306Unused =				306, (used in old HTTP spec, now unused in 1.1)
 	k_EHTTPStatusCode307TemporaryRedirect =		307,
+	k_EHTTPStatusCode308PermanentRedirect =		308,
 
 	// Error codes
 	k_EHTTPStatusCode400BadRequest =			400,

sdk_includes/steamnetworkingtypes.h

@@ -1701,7 +1701,7 @@ inline SteamNetworkingPOPID CalculateSteamNetworkingPOPIDFromString( const char
 	//
 	// There is also extra paranoia to make sure the bytes are not treated as signed.
 	SteamNetworkingPOPID result = (uint32)(uint8)pszCode[0] << 16U;
-	if ( pszCode[1] )
+	if ( result && pszCode[1] )
 	{
 		result |= ( (uint32)(uint8)pszCode[1] << 8U );
 		if ( pszCode[2] )
@@ -1718,9 +1718,7 @@ inline SteamNetworkingPOPID CalculateSteamNetworkingPOPIDFromString( const char
 template <int N>
 inline void GetSteamNetworkingLocationPOPStringFromID( SteamNetworkingPOPID id, char (&szCode)[N] )
 {
-#if !defined( __GNUC__ ) || __GNUC__ >= 5
 	static_assert( N >= 5, "Fixed-size buffer not big enough to hold SDR POP ID" );
-#endif
 	szCode[0] = char( id >> 16U );
 	szCode[1] = char( id >> 8U );
 	szCode[2] = char( id );