Upgrade to Steamworks 1.61

WIP due to server list crashing for some reason

Facepunch.Steamworks/Classes/SteamApi.cs

@@ -11,9 +11,8 @@ internal static class SteamAPI
 	{
 		internal static class Native
 		{
-			[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_Init", CallingConvention = CallingConvention.Cdecl )]
+			[DllImport( Platform.LibraryName, EntryPoint = "SteamInternal_SteamAPI_Init", CallingConvention = CallingConvention.Cdecl )]
-			[return: MarshalAs( UnmanagedType.I1 )]
+			public static extern SteamAPIInitResult SteamInternal_SteamAPI_Init( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszInternalCheckInterfaceVersions, IntPtr pOutErrMsg );
-			public static extern bool SteamAPI_Init();
 
 			[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_Shutdown", CallingConvention = CallingConvention.Cdecl )]
 			public static extern void SteamAPI_Shutdown();
@@ -26,9 +25,13 @@ internal static class Native
 			public static extern bool SteamAPI_RestartAppIfNecessary( uint unOwnAppID );
 			
 		}
-		static internal bool Init()
+		
+		static internal SteamAPIInitResult Init( string pszInternalCheckInterfaceVersions, out string pOutErrMsg )
 		{
-			return Native.SteamAPI_Init();
+			using var buffer = Helpers.Memory.Take();
+			var result = Native.SteamInternal_SteamAPI_Init( pszInternalCheckInterfaceVersions, buffer.Ptr );
+			pOutErrMsg = Helpers.MemoryToString( buffer.Ptr );
+			return result;
 		}
 		
 		static internal void Shutdown()

Facepunch.Steamworks/Classes/SteamInternal.cs

@@ -11,14 +11,16 @@ internal static class SteamInternal
 	{
 		internal static class Native
 		{
-			[DllImport( Platform.LibraryName, EntryPoint = "SteamInternal_GameServer_Init", CallingConvention = CallingConvention.Cdecl )]
+			[DllImport( Platform.LibraryName, EntryPoint = "SteamInternal_GameServer_Init_V2", CallingConvention = CallingConvention.Cdecl )]
-			[return: MarshalAs( UnmanagedType.I1 )]
+			public static extern SteamAPIInitResult SteamInternal_GameServer_Init_V2( uint unIP, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersionString, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszInternalCheckInterfaceVersions, IntPtr pOutErrMsg );	
-			public static extern bool SteamInternal_GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersionString );	
 		}
 
-		static internal bool GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersionString )
+		static internal SteamAPIInitResult GameServer_Init( uint unIP, ushort usGamePort, ushort usQueryPort, int eServerMode, string pchVersionString, string pszInternalCheckInterfaceVersions, out string pOutErrMsg )
 		{
-			return Native.SteamInternal_GameServer_Init( unIP, usPort, usGamePort, usQueryPort, eServerMode, pchVersionString );
+			using var buffer = Helpers.Memory.Take();
+			var result = Native.SteamInternal_GameServer_Init_V2( unIP, usGamePort, usQueryPort, eServerMode, pchVersionString, pszInternalCheckInterfaceVersions, buffer.Ptr );
+			pOutErrMsg = Helpers.MemoryToString( buffer.Ptr );
+			return result;
 		}		
 	}
 }

Facepunch.Steamworks/Generated/CustomEnums.cs

@@ -159,8 +159,6 @@ public enum CallbackType
 		DeleteItemResult = 3417,
 		UserSubscribedItemsListChanged = 3418,
 		WorkshopEULAStatus = 3420,
-		SteamAppInstalled = 3901,
-		SteamAppUninstalled = 3902,
 		PlaybackStatusHasChanged = 4001,
 		VolumeHasChanged = 4002,
 		MusicPlayerWantsVolume = 4011,
@@ -200,6 +198,8 @@ public enum CallbackType
 		HTML_UpdateToolTip = 4525,
 		HTML_HideToolTip = 4526,
 		HTML_BrowserRestarted = 4527,
+		BroadcastUploadStart = 4604,
+		BroadcastUploadStop = 4605,
 		GetVideoURLResult = 4611,
 		GetOPFSettingsResult = 4624,
 		SteamInventoryResultReady = 4700,
@@ -225,6 +225,8 @@ public enum CallbackType
 		SteamRemotePlaySessionConnected = 5701,
 		SteamRemotePlaySessionDisconnected = 5702,
 		SteamRemotePlayTogetherGuestInvite = 5703,
+		SteamTimelineGamePhaseRecordingExists = 6001,
+		SteamTimelineEventRecordingExists = 6002,
 	}
 	internal static partial class CallbackTypeFactory
 	{
@@ -379,8 +381,6 @@ internal static partial class CallbackTypeFactory
 			{ CallbackType.DeleteItemResult, typeof( DeleteItemResult_t )},
 			{ CallbackType.UserSubscribedItemsListChanged, typeof( UserSubscribedItemsListChanged_t )},
 			{ CallbackType.WorkshopEULAStatus, typeof( WorkshopEULAStatus_t )},
-			{ CallbackType.SteamAppInstalled, typeof( SteamAppInstalled_t )},
-			{ CallbackType.SteamAppUninstalled, typeof( SteamAppUninstalled_t )},
 			{ CallbackType.PlaybackStatusHasChanged, typeof( PlaybackStatusHasChanged_t )},
 			{ CallbackType.VolumeHasChanged, typeof( VolumeHasChanged_t )},
 			{ CallbackType.MusicPlayerWantsVolume, typeof( MusicPlayerWantsVolume_t )},
@@ -420,6 +420,8 @@ internal static partial class CallbackTypeFactory
 			{ CallbackType.HTML_UpdateToolTip, typeof( HTML_UpdateToolTip_t )},
 			{ CallbackType.HTML_HideToolTip, typeof( HTML_HideToolTip_t )},
 			{ CallbackType.HTML_BrowserRestarted, typeof( HTML_BrowserRestarted_t )},
+			{ CallbackType.BroadcastUploadStart, typeof( BroadcastUploadStart_t )},
+			{ CallbackType.BroadcastUploadStop, typeof( BroadcastUploadStop_t )},
 			{ CallbackType.GetVideoURLResult, typeof( GetVideoURLResult_t )},
 			{ CallbackType.GetOPFSettingsResult, typeof( GetOPFSettingsResult_t )},
 			{ CallbackType.SteamInventoryResultReady, typeof( SteamInventoryResultReady_t )},
@@ -445,6 +447,8 @@ internal static partial class CallbackTypeFactory
 			{ CallbackType.SteamRemotePlaySessionConnected, typeof( SteamRemotePlaySessionConnected_t )},
 			{ CallbackType.SteamRemotePlaySessionDisconnected, typeof( SteamRemotePlaySessionDisconnected_t )},
 			{ CallbackType.SteamRemotePlayTogetherGuestInvite, typeof( SteamRemotePlayTogetherGuestInvite_t )},
+			{ CallbackType.SteamTimelineGamePhaseRecordingExists, typeof( SteamTimelineGamePhaseRecordingExists_t )},
+			{ CallbackType.SteamTimelineEventRecordingExists, typeof( SteamTimelineEventRecordingExists_t )},
 		};
 	}
 }

Facepunch.Steamworks/Generated/Interfaces/ISteamApps.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamApps : SteamInterface
 	{
+		public const string Version = "STEAMAPPS_INTERFACE_VERSION008";
 		
 		internal ISteamApps( bool IsGameServer )
 		{
@@ -369,5 +370,44 @@ internal bool SetDlcContext( AppId nAppID )
 			return returnValue;
 		}
 		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamApps_GetNumBetas", CallingConvention = Platform.CC)]
+		private static extern int _GetNumBetas( IntPtr self, ref int pnAvailable, ref int pnPrivate );
+		
+		#endregion
+		internal int GetNumBetas( ref int pnAvailable, ref int pnPrivate )
+		{
+			var returnValue = _GetNumBetas( Self, ref pnAvailable, ref pnPrivate );
+			return returnValue;
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamApps_GetBetaInfo", CallingConvention = Platform.CC)]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private static extern bool _GetBetaInfo( IntPtr self, int iBetaIndex, ref uint punFlags, ref uint punBuildID, IntPtr pchBetaName, int cchBetaName, IntPtr pchDescription, int cchDescription );
+		
+		#endregion
+		internal bool GetBetaInfo( int iBetaIndex, ref uint punFlags, ref uint punBuildID, out string pchBetaName, out string pchDescription )
+		{
+			using var mempchBetaName = Helpers.TakeMemory();
+			using var mempchDescription = Helpers.TakeMemory();
+			var returnValue = _GetBetaInfo( Self, iBetaIndex, ref punFlags, ref punBuildID, mempchBetaName, (1024 * 32), mempchDescription, (1024 * 32) );
+			pchBetaName = Helpers.MemoryToString( mempchBetaName );
+			pchDescription = Helpers.MemoryToString( mempchDescription );
+			return returnValue;
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamApps_SetActiveBeta", CallingConvention = Platform.CC)]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private static extern bool _SetActiveBeta( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchBetaName );
+		
+		#endregion
+		internal bool SetActiveBeta( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchBetaName )
+		{
+			var returnValue = _SetActiveBeta( Self, pchBetaName );
+			return returnValue;
+		}
+		
 	}
 }

Facepunch.Steamworks/Generated/Interfaces/ISteamClient.cs

@@ -9,7 +9,6 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamClient : SteamInterface
 	{
-		
 		internal ISteamClient( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );
@@ -300,17 +299,6 @@ internal IntPtr GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [Mar
 			return returnValue;
 		}
 		
-		#region FunctionMeta
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamAppList", CallingConvention = Platform.CC)]
-		private static extern IntPtr _GetISteamAppList( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion );
-		
-		#endregion
-		internal IntPtr GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion )
-		{
-			var returnValue = _GetISteamAppList( Self, hSteamUser, hSteamPipe, pchVersion );
-			return returnValue;
-		}
-		
 		#region FunctionMeta
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamMusic", CallingConvention = Platform.CC)]
 		private static extern IntPtr _GetISteamMusic( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion );

Facepunch.Steamworks/Generated/Interfaces/ISteamController.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamController : SteamInterface
 	{
+		public const string Version = "SteamController008";
 		
 		internal ISteamController( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamFriends.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamFriends : SteamInterface
 	{
+		public const string Version = "SteamFriends017";
 		
 		internal ISteamFriends( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamGameSearch.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamGameSearch : SteamInterface
 	{
+		public const string Version = "SteamMatchGameSearch001";
 		
 		internal ISteamGameSearch( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamGameServer : SteamInterface
 	{
+		public const string Version = "SteamGameServer015";
 		
 		internal ISteamGameServer( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamGameServerStats.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamGameServerStats : SteamInterface
 	{
+		public const string Version = "SteamGameServerStats001";
 		
 		internal ISteamGameServerStats( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamHTMLSurface.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamHTMLSurface : SteamInterface
 	{
+		public const string Version = "STEAMHTMLSURFACE_INTERFACE_VERSION_005";
 		
 		internal ISteamHTMLSurface( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamHTTP.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamHTTP : SteamInterface
 	{
+		public const string Version = "STEAMHTTP_INTERFACE_VERSION003";
 		
 		internal ISteamHTTP( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamInput.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamInput : SteamInterface
 	{
+		public const string Version = "SteamInput006";
 		
 		internal ISteamInput( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamInventory.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamInventory : SteamInterface
 	{
+		public const string Version = "STEAMINVENTORY_INTERFACE_V003";
 		
 		internal ISteamInventory( bool IsGameServer )
 		{
@@ -52,10 +53,11 @@ internal bool GetResultItems( SteamInventoryResult_t resultHandle, [In,Out] Stea
 		private static extern bool _GetResultItemProperty( IntPtr self, SteamInventoryResult_t resultHandle, uint unItemIndex, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, IntPtr pchValueBuffer, ref uint punValueBufferSizeOut );
 		
 		#endregion
-		internal bool GetResultItemProperty( SteamInventoryResult_t resultHandle, uint unItemIndex, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, out string pchValueBuffer, ref uint punValueBufferSizeOut )
+		internal bool GetResultItemProperty( SteamInventoryResult_t resultHandle, uint unItemIndex, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, out string pchValueBuffer )
 		{
 			using var mempchValueBuffer = Helpers.TakeMemory();
-			var returnValue = _GetResultItemProperty( Self, resultHandle, unItemIndex, pchPropertyName, mempchValueBuffer, ref punValueBufferSizeOut );
+			uint szpunValueBufferSizeOut = (1024 * 32);
+			var returnValue = _GetResultItemProperty( Self, resultHandle, unItemIndex, pchPropertyName, mempchValueBuffer, ref szpunValueBufferSizeOut );
 			pchValueBuffer = Helpers.MemoryToString( mempchValueBuffer );
 			return returnValue;
 		}
@@ -289,10 +291,11 @@ internal bool GetItemDefinitionIDs( [In,Out] InventoryDefId[]  pItemDefIDs, ref
 		private static extern bool _GetItemDefinitionProperty( IntPtr self, InventoryDefId iDefinition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, IntPtr pchValueBuffer, ref uint punValueBufferSizeOut );
 		
 		#endregion
-		internal bool GetItemDefinitionProperty( InventoryDefId iDefinition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, out string pchValueBuffer, ref uint punValueBufferSizeOut )
+		internal bool GetItemDefinitionProperty( InventoryDefId iDefinition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, out string pchValueBuffer )
 		{
 			using var mempchValueBuffer = Helpers.TakeMemory();
-			var returnValue = _GetItemDefinitionProperty( Self, iDefinition, pchPropertyName, mempchValueBuffer, ref punValueBufferSizeOut );
+			uint szpunValueBufferSizeOut = (1024 * 32);
+			var returnValue = _GetItemDefinitionProperty( Self, iDefinition, pchPropertyName, mempchValueBuffer, ref szpunValueBufferSizeOut );
 			pchValueBuffer = Helpers.MemoryToString( mempchValueBuffer );
 			return returnValue;
 		}

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmaking.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMatchmaking : SteamInterface
 	{
+		public const string Version = "SteamMatchMaking009";
 		
 		internal ISteamMatchmaking( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPingResponse.cs

@@ -9,7 +9,6 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMatchmakingPingResponse : SteamInterface
 	{
-		
 		internal ISteamMatchmakingPingResponse( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPlayersResponse.cs

@@ -9,7 +9,6 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMatchmakingPlayersResponse : SteamInterface
 	{
-		
 		internal ISteamMatchmakingPlayersResponse( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingRulesResponse.cs

@@ -9,7 +9,6 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMatchmakingRulesResponse : SteamInterface
 	{
-		
 		internal ISteamMatchmakingRulesResponse( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingServerListResponse.cs

@@ -9,7 +9,6 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMatchmakingServerListResponse : SteamInterface
 	{
-		
 		internal ISteamMatchmakingServerListResponse( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingServers.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMatchmakingServers : SteamInterface
 	{
+		public const string Version = "SteamMatchMakingServers002";
 		
 		internal ISteamMatchmakingServers( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamMusic.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMusic : SteamInterface
 	{
+		public const string Version = "STEAMMUSIC_INTERFACE_VERSION001";
 		
 		internal ISteamMusic( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamMusicRemote.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamMusicRemote : SteamInterface
 	{
+		public const string Version = "STEAMMUSICREMOTE_INTERFACE_VERSION001";
 		
 		internal ISteamMusicRemote( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamNetworking.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamNetworking : SteamInterface
 	{
+		public const string Version = "SteamNetworking006";
 		
 		internal ISteamNetworking( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingFakeUDPPort.cs

@@ -9,7 +9,6 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamNetworkingFakeUDPPort : SteamInterface
 	{
-		
 		internal ISteamNetworkingFakeUDPPort( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );

Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingMessages.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamNetworkingMessages : SteamInterface
 	{
+		public const string Version = "SteamNetworkingMessages002";
 		
 		internal ISteamNetworkingMessages( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingSockets.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamNetworkingSockets : SteamInterface
 	{
+		public const string Version = "SteamNetworkingSockets012";
 		
 		internal ISteamNetworkingSockets( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingUtils.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamNetworkingUtils : SteamInterface
 	{
+		public const string Version = "SteamNetworkingUtils004";
 		
 		internal ISteamNetworkingUtils( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamParentalSettings.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamParentalSettings : SteamInterface
 	{
+		public const string Version = "STEAMPARENTALSETTINGS_INTERFACE_VERSION001";
 		
 		internal ISteamParentalSettings( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamParties.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamParties : SteamInterface
 	{
+		public const string Version = "SteamParties002";
 		
 		internal ISteamParties( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamRemotePlay.cs

@@ -9,15 +9,16 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamRemotePlay : SteamInterface
 	{
+		public const string Version = "STEAMREMOTEPLAY_INTERFACE_VERSION002";
 		
 		internal ISteamRemotePlay( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );
 		}
 		
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamRemotePlay_v001", CallingConvention = Platform.CC)]
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamRemotePlay_v002", CallingConvention = Platform.CC)]
-		internal static extern IntPtr SteamAPI_SteamRemotePlay_v001();
+		internal static extern IntPtr SteamAPI_SteamRemotePlay_v002();
-		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamRemotePlay_v001();
+		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamRemotePlay_v002();
 		
 		
 		#region FunctionMeta
@@ -87,6 +88,18 @@ internal bool BGetSessionClientResolution( RemotePlaySessionID_t unSessionID, re
 			return returnValue;
 		}
 		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether", CallingConvention = Platform.CC)]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private static extern bool _BStartRemotePlayTogether( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bShowOverlay );
+		
+		#endregion
+		internal bool BStartRemotePlayTogether( [MarshalAs( UnmanagedType.U1 )] bool bShowOverlay )
+		{
+			var returnValue = _BStartRemotePlayTogether( Self, bShowOverlay );
+			return returnValue;
+		}
+		
 		#region FunctionMeta
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite", CallingConvention = Platform.CC)]
 		[return: MarshalAs( UnmanagedType.I1 )]

Facepunch.Steamworks/Generated/Interfaces/ISteamRemoteStorage.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamRemoteStorage : SteamInterface
 	{
+		public const string Version = "STEAMREMOTESTORAGE_INTERFACE_VERSION016";
 		
 		internal ISteamRemoteStorage( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamScreenshots.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamScreenshots : SteamInterface
 	{
+		public const string Version = "STEAMSCREENSHOTS_INTERFACE_VERSION003";
 		
 		internal ISteamScreenshots( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamTimeline.cs

@@ -0,0 +1,210 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Steamworks.Data;
+
+
+namespace Steamworks
+{
+	internal unsafe partial class ISteamTimeline : SteamInterface
+	{
+		public const string Version = "STEAMTIMELINE_INTERFACE_V004";
+		
+		internal ISteamTimeline( bool IsGameServer )
+		{
+			SetupInterface( IsGameServer );
+		}
+		
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamTimeline_v004", CallingConvention = Platform.CC)]
+		internal static extern IntPtr SteamAPI_SteamTimeline_v004();
+		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamTimeline_v004();
+		
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_SetTimelineTooltip", CallingConvention = Platform.CC)]
+		private static extern void _SetTimelineTooltip( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, float flTimeDelta );
+		
+		#endregion
+		internal void SetTimelineTooltip( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, float flTimeDelta )
+		{
+			_SetTimelineTooltip( Self, pchDescription, flTimeDelta );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_ClearTimelineTooltip", CallingConvention = Platform.CC)]
+		private static extern void _ClearTimelineTooltip( IntPtr self, float flTimeDelta );
+		
+		#endregion
+		internal void ClearTimelineTooltip( float flTimeDelta )
+		{
+			_ClearTimelineTooltip( Self, flTimeDelta );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_SetTimelineGameMode", CallingConvention = Platform.CC)]
+		private static extern void _SetTimelineGameMode( IntPtr self, TimelineGameMode eMode );
+		
+		#endregion
+		internal void SetTimelineGameMode( TimelineGameMode eMode )
+		{
+			_SetTimelineGameMode( Self, eMode );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent", CallingConvention = Platform.CC)]
+		private static extern TimelineEventHandle_t _AddInstantaneousTimelineEvent( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unIconPriority, float flStartOffsetSeconds, TimelineEventClipPriority ePossibleClip );
+		
+		#endregion
+		internal TimelineEventHandle_t AddInstantaneousTimelineEvent( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unIconPriority, float flStartOffsetSeconds, TimelineEventClipPriority ePossibleClip )
+		{
+			var returnValue = _AddInstantaneousTimelineEvent( Self, pchTitle, pchDescription, pchIcon, unIconPriority, flStartOffsetSeconds, ePossibleClip );
+			return returnValue;
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_AddRangeTimelineEvent", CallingConvention = Platform.CC)]
+		private static extern TimelineEventHandle_t _AddRangeTimelineEvent( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unIconPriority, float flStartOffsetSeconds, float flDuration, TimelineEventClipPriority ePossibleClip );
+		
+		#endregion
+		internal TimelineEventHandle_t AddRangeTimelineEvent( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unIconPriority, float flStartOffsetSeconds, float flDuration, TimelineEventClipPriority ePossibleClip )
+		{
+			var returnValue = _AddRangeTimelineEvent( Self, pchTitle, pchDescription, pchIcon, unIconPriority, flStartOffsetSeconds, flDuration, ePossibleClip );
+			return returnValue;
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_StartRangeTimelineEvent", CallingConvention = Platform.CC)]
+		private static extern TimelineEventHandle_t _StartRangeTimelineEvent( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unPriority, float flStartOffsetSeconds, TimelineEventClipPriority ePossibleClip );
+		
+		#endregion
+		internal TimelineEventHandle_t StartRangeTimelineEvent( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unPriority, float flStartOffsetSeconds, TimelineEventClipPriority ePossibleClip )
+		{
+			var returnValue = _StartRangeTimelineEvent( Self, pchTitle, pchDescription, pchIcon, unPriority, flStartOffsetSeconds, ePossibleClip );
+			return returnValue;
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent", CallingConvention = Platform.CC)]
+		private static extern void _UpdateRangeTimelineEvent( IntPtr self, TimelineEventHandle_t ulEvent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unPriority, TimelineEventClipPriority ePossibleClip );
+		
+		#endregion
+		internal void UpdateRangeTimelineEvent( TimelineEventHandle_t ulEvent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTitle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDescription, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchIcon, uint unPriority, TimelineEventClipPriority ePossibleClip )
+		{
+			_UpdateRangeTimelineEvent( Self, ulEvent, pchTitle, pchDescription, pchIcon, unPriority, ePossibleClip );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_EndRangeTimelineEvent", CallingConvention = Platform.CC)]
+		private static extern void _EndRangeTimelineEvent( IntPtr self, TimelineEventHandle_t ulEvent, float flEndOffsetSeconds );
+		
+		#endregion
+		internal void EndRangeTimelineEvent( TimelineEventHandle_t ulEvent, float flEndOffsetSeconds )
+		{
+			_EndRangeTimelineEvent( Self, ulEvent, flEndOffsetSeconds );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_RemoveTimelineEvent", CallingConvention = Platform.CC)]
+		private static extern void _RemoveTimelineEvent( IntPtr self, TimelineEventHandle_t ulEvent );
+		
+		#endregion
+		internal void RemoveTimelineEvent( TimelineEventHandle_t ulEvent )
+		{
+			_RemoveTimelineEvent( Self, ulEvent );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_DoesEventRecordingExist", CallingConvention = Platform.CC)]
+		private static extern SteamAPICall_t _DoesEventRecordingExist( IntPtr self, TimelineEventHandle_t ulEvent );
+		
+		#endregion
+		internal CallResult<SteamTimelineEventRecordingExists_t> DoesEventRecordingExist( TimelineEventHandle_t ulEvent )
+		{
+			var returnValue = _DoesEventRecordingExist( Self, ulEvent );
+			return new CallResult<SteamTimelineEventRecordingExists_t>( returnValue, IsServer );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_StartGamePhase", CallingConvention = Platform.CC)]
+		private static extern void _StartGamePhase( IntPtr self );
+		
+		#endregion
+		internal void StartGamePhase()
+		{
+			_StartGamePhase( Self );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_EndGamePhase", CallingConvention = Platform.CC)]
+		private static extern void _EndGamePhase( IntPtr self );
+		
+		#endregion
+		internal void EndGamePhase()
+		{
+			_EndGamePhase( Self );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_SetGamePhaseID", CallingConvention = Platform.CC)]
+		private static extern void _SetGamePhaseID( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPhaseID );
+		
+		#endregion
+		internal void SetGamePhaseID( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPhaseID )
+		{
+			_SetGamePhaseID( Self, pchPhaseID );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist", CallingConvention = Platform.CC)]
+		private static extern SteamAPICall_t _DoesGamePhaseRecordingExist( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPhaseID );
+		
+		#endregion
+		internal CallResult<SteamTimelineGamePhaseRecordingExists_t> DoesGamePhaseRecordingExist( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPhaseID )
+		{
+			var returnValue = _DoesGamePhaseRecordingExist( Self, pchPhaseID );
+			return new CallResult<SteamTimelineGamePhaseRecordingExists_t>( returnValue, IsServer );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_AddGamePhaseTag", CallingConvention = Platform.CC)]
+		private static extern void _AddGamePhaseTag( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTagName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTagIcon, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTagGroup, uint unPriority );
+		
+		#endregion
+		internal void AddGamePhaseTag( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTagName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTagIcon, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTagGroup, uint unPriority )
+		{
+			_AddGamePhaseTag( Self, pchTagName, pchTagIcon, pchTagGroup, unPriority );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_SetGamePhaseAttribute", CallingConvention = Platform.CC)]
+		private static extern void _SetGamePhaseAttribute( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchAttributeGroup, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchAttributeValue, uint unPriority );
+		
+		#endregion
+		internal void SetGamePhaseAttribute( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchAttributeGroup, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchAttributeValue, uint unPriority )
+		{
+			_SetGamePhaseAttribute( Self, pchAttributeGroup, pchAttributeValue, unPriority );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_OpenOverlayToGamePhase", CallingConvention = Platform.CC)]
+		private static extern void _OpenOverlayToGamePhase( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPhaseID );
+		
+		#endregion
+		internal void OpenOverlayToGamePhase( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPhaseID )
+		{
+			_OpenOverlayToGamePhase( Self, pchPhaseID );
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent", CallingConvention = Platform.CC)]
+		private static extern void _OpenOverlayToTimelineEvent( IntPtr self, TimelineEventHandle_t ulEvent );
+		
+		#endregion
+		internal void OpenOverlayToTimelineEvent( TimelineEventHandle_t ulEvent )
+		{
+			_OpenOverlayToTimelineEvent( Self, ulEvent );
+		}
+		
+	}
+}

Facepunch.Steamworks/Generated/Interfaces/ISteamUGC.cs

@@ -9,18 +9,19 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamUGC : SteamInterface
 	{
+		public const string Version = "STEAMUGC_INTERFACE_VERSION020";
 		
 		internal ISteamUGC( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );
 		}
 		
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamUGC_v017", CallingConvention = Platform.CC)]
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamUGC_v020", CallingConvention = Platform.CC)]
-		internal static extern IntPtr SteamAPI_SteamUGC_v017();
+		internal static extern IntPtr SteamAPI_SteamUGC_v020();
-		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamUGC_v017();
+		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamUGC_v020();
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamGameServerUGC_v017", CallingConvention = Platform.CC)]
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamGameServerUGC_v020", CallingConvention = Platform.CC)]
-		internal static extern IntPtr SteamAPI_SteamGameServerUGC_v017();
+		internal static extern IntPtr SteamAPI_SteamGameServerUGC_v020();
-		public override IntPtr GetServerInterfacePointer() => SteamAPI_SteamGameServerUGC_v017();
+		public override IntPtr GetServerInterfacePointer() => SteamAPI_SteamGameServerUGC_v020();
 		
 		
 		#region FunctionMeta
@@ -249,6 +250,33 @@ internal bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint index, [Mars
 			return returnValue;
 		}
 		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_GetNumSupportedGameVersions", CallingConvention = Platform.CC)]
+		private static extern uint _GetNumSupportedGameVersions( IntPtr self, UGCQueryHandle_t handle, uint index );
+		
+		#endregion
+		internal uint GetNumSupportedGameVersions( UGCQueryHandle_t handle, uint index )
+		{
+			var returnValue = _GetNumSupportedGameVersions( Self, handle, index );
+			return returnValue;
+		}
+		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_GetSupportedGameVersionData", CallingConvention = Platform.CC)]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private static extern bool _GetSupportedGameVersionData( IntPtr self, UGCQueryHandle_t handle, uint index, uint versionIndex, IntPtr pchGameBranchMin, IntPtr pchGameBranchMax, uint cchGameBranchSize );
+		
+		#endregion
+		internal bool GetSupportedGameVersionData( UGCQueryHandle_t handle, uint index, uint versionIndex, out string pchGameBranchMin, out string pchGameBranchMax )
+		{
+			using var mempchGameBranchMin = Helpers.TakeMemory();
+			using var mempchGameBranchMax = Helpers.TakeMemory();
+			var returnValue = _GetSupportedGameVersionData( Self, handle, index, versionIndex, mempchGameBranchMin, mempchGameBranchMax, (1024 * 32) );
+			pchGameBranchMin = Helpers.MemoryToString( mempchGameBranchMin );
+			pchGameBranchMax = Helpers.MemoryToString( mempchGameBranchMax );
+			return returnValue;
+		}
+		
 		#region FunctionMeta
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors", CallingConvention = Platform.CC)]
 		private static extern uint _GetQueryUGCContentDescriptors( IntPtr self, UGCQueryHandle_t handle, uint index, [In,Out] UGCContentDescriptorID[]  pvecDescriptors, uint cMaxEntries );
@@ -428,6 +456,18 @@ internal bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint unMaxAgeSeco
 			return returnValue;
 		}
 		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_SetAdminQuery", CallingConvention = Platform.CC)]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private static extern bool _SetAdminQuery( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bAdminQuery );
+		
+		#endregion
+		internal bool SetAdminQuery( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bAdminQuery )
+		{
+			var returnValue = _SetAdminQuery( Self, handle, bAdminQuery );
+			return returnValue;
+		}
+		
 		#region FunctionMeta
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_SetCloudFileNameFilter", CallingConvention = Platform.CC)]
 		[return: MarshalAs( UnmanagedType.I1 )]
@@ -597,12 +637,12 @@ internal bool SetItemVisibility( UGCUpdateHandle_t handle, RemoteStoragePublishe
 		#region FunctionMeta
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_SetItemTags", CallingConvention = Platform.CC)]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private static extern bool _SetItemTags( IntPtr self, UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags );
+		private static extern bool _SetItemTags( IntPtr self, UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags, [MarshalAs( UnmanagedType.U1 )] bool bAllowAdminTags );
 		
 		#endregion
-		internal bool SetItemTags( UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags )
+		internal bool SetItemTags( UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags, [MarshalAs( UnmanagedType.U1 )] bool bAllowAdminTags )
 		{
-			var returnValue = _SetItemTags( Self, updateHandle, ref pTags );
+			var returnValue = _SetItemTags( Self, updateHandle, ref pTags, bAllowAdminTags );
 			return returnValue;
 		}
 		
@@ -762,6 +802,18 @@ internal bool RemoveContentDescriptor( UGCUpdateHandle_t handle, UGCContentDescr
 			return returnValue;
 		}
 		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_SetRequiredGameVersions", CallingConvention = Platform.CC)]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private static extern bool _SetRequiredGameVersions( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszGameBranchMin, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszGameBranchMax );
+		
+		#endregion
+		internal bool SetRequiredGameVersions( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszGameBranchMin, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszGameBranchMax )
+		{
+			var returnValue = _SetRequiredGameVersions( Self, handle, pszGameBranchMin, pszGameBranchMax );
+			return returnValue;
+		}
+		
 		#region FunctionMeta
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_SubmitItemUpdate", CallingConvention = Platform.CC)]
 		private static extern SteamAPICall_t _SubmitItemUpdate( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchChangeNote );
@@ -1065,5 +1117,16 @@ internal CallResult<WorkshopEULAStatus_t> GetWorkshopEULAStatus()
 			return new CallResult<WorkshopEULAStatus_t>( returnValue, IsServer );
 		}
 		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences", CallingConvention = Platform.CC)]
+		private static extern uint _GetUserContentDescriptorPreferences( IntPtr self, [In,Out] UGCContentDescriptorID[]  pvecDescriptors, uint cMaxEntries );
+		
+		#endregion
+		internal uint GetUserContentDescriptorPreferences( [In,Out] UGCContentDescriptorID[]  pvecDescriptors, uint cMaxEntries )
+		{
+			var returnValue = _GetUserContentDescriptorPreferences( Self, pvecDescriptors, cMaxEntries );
+			return returnValue;
+		}
+		
 	}
 }

Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamUser : SteamInterface
 	{
+		public const string Version = "SteamUser023";
 		
 		internal ISteamUser( bool IsGameServer )
 		{

Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs

@@ -9,29 +9,18 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamUserStats : SteamInterface
 	{
+		public const string Version = "STEAMUSERSTATS_INTERFACE_VERSION013";
 		
 		internal ISteamUserStats( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );
 		}
 		
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamUserStats_v012", CallingConvention = Platform.CC)]
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamUserStats_v013", CallingConvention = Platform.CC)]
-		internal static extern IntPtr SteamAPI_SteamUserStats_v012();
+		internal static extern IntPtr SteamAPI_SteamUserStats_v013();
-		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamUserStats_v012();
+		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamUserStats_v013();
 		
 		
-		#region FunctionMeta
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_RequestCurrentStats", CallingConvention = Platform.CC)]
-		[return: MarshalAs( UnmanagedType.I1 )]
-		private static extern bool _RequestCurrentStats( IntPtr self );
-		
-		#endregion
-		internal bool RequestCurrentStats()
-		{
-			var returnValue = _RequestCurrentStats( Self );
-			return returnValue;
-		}
-		
 		#region FunctionMeta
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetStatInt32", CallingConvention = Platform.CC)]
 		[return: MarshalAs( UnmanagedType.I1 )]

Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs

@@ -9,6 +9,7 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamUtils : SteamInterface
 	{
+		public const string Version = "SteamUtils010";
 		
 		internal ISteamUtils( bool IsGameServer )
 		{
@@ -433,5 +434,17 @@ internal bool DismissFloatingGamepadTextInput()
 			return returnValue;
 		}
 		
+		#region FunctionMeta
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUtils_DismissGamepadTextInput", CallingConvention = Platform.CC)]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private static extern bool _DismissGamepadTextInput( IntPtr self );
+		
+		#endregion
+		internal bool DismissGamepadTextInput()
+		{
+			var returnValue = _DismissGamepadTextInput( Self );
+			return returnValue;
+		}
+		
 	}
 }

Facepunch.Steamworks/Generated/Interfaces/ISteamVideo.cs

@@ -9,15 +9,16 @@ namespace Steamworks
 {
 	internal unsafe partial class ISteamVideo : SteamInterface
 	{
+		public const string Version = "STEAMVIDEO_INTERFACE_V007";
 		
 		internal ISteamVideo( bool IsGameServer )
 		{
 			SetupInterface( IsGameServer );
 		}
 		
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamVideo_v002", CallingConvention = Platform.CC)]
+		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamVideo_v007", CallingConvention = Platform.CC)]
-		internal static extern IntPtr SteamAPI_SteamVideo_v002();
+		internal static extern IntPtr SteamAPI_SteamVideo_v007();
-		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamVideo_v002();
+		public override IntPtr GetUserInterfacePointer() => SteamAPI_SteamVideo_v007();
 		
 		
 		#region FunctionMeta
@@ -58,10 +59,11 @@ internal void GetOPFSettings( AppId unVideoAppID )
 		private static extern bool _GetOPFStringForApp( IntPtr self, AppId unVideoAppID, IntPtr pchBuffer, ref int pnBufferSize );
 		
 		#endregion
-		internal bool GetOPFStringForApp( AppId unVideoAppID, out string pchBuffer, ref int pnBufferSize )
+		internal bool GetOPFStringForApp( AppId unVideoAppID, out string pchBuffer )
 		{
 			using var mempchBuffer = Helpers.TakeMemory();
-			var returnValue = _GetOPFStringForApp( Self, unVideoAppID, mempchBuffer, ref pnBufferSize );
+			int szpnBufferSize = (1024 * 32);
+			var returnValue = _GetOPFStringForApp( Self, unVideoAppID, mempchBuffer, ref szpnBufferSize );
 			pchBuffer = Helpers.MemoryToString( mempchBuffer );
 			return returnValue;
 		}

Facepunch.Steamworks/Generated/SteamCallbacks.cs

@@ -242,6 +242,7 @@ internal struct GameOverlayActivated_t : ICallbackData
 		[MarshalAs(UnmanagedType.I1)]
 		internal bool UserInitiated; // m_bUserInitiated bool
 		internal AppId AppID; // m_nAppID AppId_t
+		internal uint DwOverlayPID; // m_dwOverlayPID uint32
 		
 		#region SteamCallback
 		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameOverlayActivated_t) );
@@ -533,6 +534,8 @@ internal struct EquippedProfileItems_t : ICallbackData
 		internal bool HasProfileBackground; // m_bHasProfileBackground bool
 		[MarshalAs(UnmanagedType.I1)]
 		internal bool HasMiniProfileBackground; // m_bHasMiniProfileBackground bool
+		[MarshalAs(UnmanagedType.I1)]
+		internal bool FromCache; // m_bFromCache bool
 		
 		#region SteamCallback
 		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(EquippedProfileItems_t) );
@@ -2070,6 +2073,8 @@ internal struct ItemInstalled_t : ICallbackData
 	{
 		internal AppId AppID; // m_unAppID AppId_t
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
+		internal ulong LegacyContent; // m_hLegacyContent UGCHandle_t
+		internal ulong ManifestID; // m_unManifestID uint64
 		
 		#region SteamCallback
 		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ItemInstalled_t) );
@@ -2282,32 +2287,6 @@ internal struct WorkshopEULAStatus_t : ICallbackData
 		#endregion
 	}
 	
-	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
-	internal struct SteamAppInstalled_t : ICallbackData
-	{
-		internal AppId AppID; // m_nAppID AppId_t
-		internal int InstallFolderIndex; // m_iInstallFolderIndex int
-		
-		#region SteamCallback
-		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamAppInstalled_t) );
-		public int DataSize => _datasize;
-		public CallbackType CallbackType => CallbackType.SteamAppInstalled;
-		#endregion
-	}
-	
-	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
-	internal struct SteamAppUninstalled_t : ICallbackData
-	{
-		internal AppId AppID; // m_nAppID AppId_t
-		internal int InstallFolderIndex; // m_iInstallFolderIndex int
-		
-		#region SteamCallback
-		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamAppUninstalled_t) );
-		public int DataSize => _datasize;
-		public CallbackType CallbackType => CallbackType.SteamAppUninstalled;
-		#endregion
-	}
-	
 	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
 	internal struct HTML_BrowserReady_t : ICallbackData
 	{
@@ -2732,6 +2711,38 @@ internal struct SteamInventoryRequestPricesResult_t : ICallbackData
 		#endregion
 	}
 	
+	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
+	internal struct SteamTimelineGamePhaseRecordingExists_t : ICallbackData
+	{
+		internal string PhaseIDUTF8() => System.Text.Encoding.UTF8.GetString( PhaseID, 0, System.Array.IndexOf<byte>( PhaseID, 0 ) );
+		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] // byte[] m_rgchPhaseID
+		internal byte[] PhaseID; // m_rgchPhaseID char [64]
+		internal ulong RecordingMS; // m_ulRecordingMS uint64
+		internal ulong LongestClipMS; // m_ulLongestClipMS uint64
+		internal uint ClipCount; // m_unClipCount uint32
+		internal uint ScreenshotCount; // m_unScreenshotCount uint32
+		
+		#region SteamCallback
+		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamTimelineGamePhaseRecordingExists_t) );
+		public int DataSize => _datasize;
+		public CallbackType CallbackType => CallbackType.SteamTimelineGamePhaseRecordingExists;
+		#endregion
+	}
+	
+	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
+	internal struct SteamTimelineEventRecordingExists_t : ICallbackData
+	{
+		internal ulong EventID; // m_ulEventID uint64
+		[MarshalAs(UnmanagedType.I1)]
+		internal bool RecordingExists; // m_bRecordingExists bool
+		
+		#region SteamCallback
+		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamTimelineEventRecordingExists_t) );
+		public int DataSize => _datasize;
+		public CallbackType CallbackType => CallbackType.SteamTimelineEventRecordingExists;
+		#endregion
+	}
+	
 	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
 	internal struct GetVideoURLResult_t : ICallbackData
 	{
@@ -2761,6 +2772,31 @@ internal struct GetOPFSettingsResult_t : ICallbackData
 		#endregion
 	}
 	
+	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
+	internal struct BroadcastUploadStart_t : ICallbackData
+	{
+		[MarshalAs(UnmanagedType.I1)]
+		internal bool IsRTMP; // m_bIsRTMP bool
+		
+		#region SteamCallback
+		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(BroadcastUploadStart_t) );
+		public int DataSize => _datasize;
+		public CallbackType CallbackType => CallbackType.BroadcastUploadStart;
+		#endregion
+	}
+	
+	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
+	internal struct BroadcastUploadStop_t : ICallbackData
+	{
+		internal BroadcastUploadResult Result; // m_eResult EBroadcastUploadResult
+		
+		#region SteamCallback
+		public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(BroadcastUploadStop_t) );
+		public int DataSize => _datasize;
+		public CallbackType CallbackType => CallbackType.BroadcastUploadStop;
+		#endregion
+	}
+	
 	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
 	internal struct SteamParentalSettingsChanged_t : ICallbackData
 	{

Facepunch.Steamworks/Generated/SteamConstants.cs

@@ -11,16 +11,20 @@ internal static class Defines
 		internal static readonly AppId k_uAppIdInvalid = 0x0;
 		internal static readonly DepotId_t k_uDepotIdInvalid = 0x0;
 		internal static readonly SteamAPICall_t k_uAPICallInvalid = 0x0;
+		internal static readonly AccountID_t k_uAccountIdInvalid = 0;
 		internal static readonly PartyBeaconID_t k_ulPartyBeaconIdInvalid = 0;
 		internal static readonly HAuthTicket k_HAuthTicketInvalid = 0;
 		internal static readonly uint k_unSteamAccountIDMask = 0xFFFFFFFF;
 		internal static readonly uint k_unSteamAccountInstanceMask = 0x000FFFFF;
 		internal static readonly uint k_unSteamUserDefaultInstance = 1;
 		internal static readonly int k_cchGameExtraInfoMax = 64;
+		internal static readonly int k_cchMaxSteamErrMsg = 1024;
 		internal static readonly int k_cchMaxFriendsGroupName = 64;
 		internal static readonly int k_cFriendsGroupLimit = 100;
 		internal static readonly FriendsGroupID_t k_FriendsGroupID_Invalid = - 1;
 		internal static readonly int k_cEnumerateFollowersMax = 50;
+		internal static readonly ushort k_usFriendGameInfoQueryPort_NotInitialized = 0xFFFF;
+		internal static readonly ushort k_usFriendGameInfoQueryPort_Error = 0xFFFE;
 		internal static readonly uint k_cubChatMetadataMax = 8192;
 		internal static readonly int k_cbMaxGameServerGameDir = 32;
 		internal static readonly int k_cbMaxGameServerMapName = 32;
@@ -58,6 +62,10 @@ internal static class Defines
 		internal static readonly InventoryItemId k_SteamItemInstanceIDInvalid = ~default(ulong);
 		internal static readonly SteamInventoryResult_t k_SteamInventoryResultInvalid = - 1;
 		internal static readonly SteamInventoryUpdateHandle_t k_SteamInventoryUpdateHandleInvalid = 0xffffffffffffffff;
+		internal static readonly uint k_unMaxTimelinePriority = 1000;
+		internal static readonly uint k_unTimelinePriority_KeepCurrentValue = 1000000;
+		internal static readonly float k_flMaxTimelineEventDuration = 600.0f;
+		internal static readonly uint k_cchMaxPhaseIDLength = 64;
 		internal static readonly Connection k_HSteamNetConnection_Invalid = 0;
 		internal static readonly Socket k_HSteamListenSocket_Invalid = 0;
 		internal static readonly HSteamNetPollGroup k_HSteamNetPollGroup_Invalid = 0;

Facepunch.Steamworks/Generated/SteamEnums.cs

@@ -160,6 +160,9 @@ public enum Result : int
 		ChargerRequired = 125,
 		CachedCredentialInvalid = 126,
 		K_EResultPhoneNumberIsVOIP = 127,
+		NotSupported = 128,
+		FamilySizeLimitExceeded = 129,
+		OfflineAppCacheInvalid = 130,
 	}
 	
 	//
@@ -417,6 +420,19 @@ internal enum DurationControlOnlineState : int
 		OnlineHighPri = 3,
 	}
 	
+	//
+	// EBetaBranchFlags
+	//
+	internal enum BetaBranchFlags : int
+	{
+		None = 0,
+		Default = 1,
+		Available = 2,
+		Private = 4,
+		Selected = 8,
+		Installed = 16,
+	}
+	
 	//
 	// EGameSearchErrorCode_t
 	//
@@ -796,7 +812,8 @@ internal enum WorkshopFileType : int
 		SteamworksAccessInvite = 13,
 		SteamVideo = 14,
 		GameManagedItem = 15,
-		Max = 16,
+		Clip = 16,
+		Max = 17,
 	}
 	
 	//
@@ -1456,7 +1473,11 @@ internal enum InputActionOrigin : int
 		SteamDeck_Reserved18 = 403,
 		SteamDeck_Reserved19 = 404,
 		SteamDeck_Reserved20 = 405,
-		Count = 406,
+		Horipad_M1 = 406,
+		Horipad_M2 = 407,
+		Horipad_L4 = 408,
+		Horipad_R4 = 409,
+		Count = 410,
 		MaximumPossibleValue = 32767,
 	}
 	
@@ -1993,7 +2014,11 @@ internal enum ControllerActionOrigin : int
 		PS5_RightGrip = 383,
 		PS5_LeftFn = 384,
 		PS5_RightFn = 385,
-		Count = 386,
+		Horipad_M1 = 386,
+		Horipad_M2 = 387,
+		Horipad_L4 = 388,
+		Horipad_R4 = 389,
+		Count = 390,
 		MaximumPossibleValue = 32767,
 	}
 	
@@ -2109,6 +2134,7 @@ internal enum ItemState : int
 		NeedsUpdate = 8,
 		Downloading = 16,
 		DownloadPending = 32,
+		DisabledLocally = 64,
 	}
 	
 	//
@@ -2141,6 +2167,7 @@ public enum ItemPreviewType : int
 		Sketchfab = 2,
 		EnvironmentMap_HorizontalCross = 3,
 		EnvironmentMap_LatLong = 4,
+		Clip = 5,
 		ReservedMax = 255,
 	}
 	
@@ -2166,6 +2193,30 @@ internal enum SteamItemFlags : int
 		Consumed = 512,
 	}
 	
+	//
+	// ETimelineGameMode
+	//
+	internal enum TimelineGameMode : int
+	{
+		Invalid = 0,
+		Playing = 1,
+		Staging = 2,
+		Menus = 3,
+		LoadingScreen = 4,
+		Max = 5,
+	}
+	
+	//
+	// ETimelineEventClipPriority
+	//
+	internal enum TimelineEventClipPriority : int
+	{
+		Invalid = 0,
+		None = 1,
+		Standard = 2,
+		Featured = 3,
+	}
+	
 	//
 	// EParentalFeature
 	//
@@ -2185,8 +2236,9 @@ public enum ParentalFeature : int
 		Library = 11,
 		Test = 12,
 		SiteLicense = 13,
-		KioskMode = 14,
+		KioskMode_Deprecated = 14,
-		Max = 15,
+		BlockAlways = 15,
+		Max = 16,
 	}
 	
 	//
@@ -2199,6 +2251,7 @@ public enum SteamDeviceFormFactor : int
 		Tablet = 2,
 		Computer = 3,
 		TV = 4,
+		VRHeadset = 5,
 	}
 	
 	//
@@ -2227,7 +2280,6 @@ internal enum NetIdentityType : int
 		SteamID = 16,
 		XboxPairwiseID = 17,
 		SonyPSN = 18,
-		GoogleStadia = 19,
 		IPAddress = 1,
 		GenericString = 2,
 		GenericBytes = 3,
@@ -2333,11 +2385,16 @@ internal enum NetConfig : int
 		TimeoutInitial = 24,
 		TimeoutConnected = 25,
 		SendBufferSize = 9,
+		RecvBufferSize = 47,
+		RecvBufferMessages = 48,
+		RecvMaxMessageSize = 49,
+		RecvMaxSegmentsPerPacket = 50,
 		ConnectionUserData = 40,
 		SendRateMin = 10,
 		SendRateMax = 11,
 		NagleTime = 12,
 		IP_AllowWithoutAuth = 23,
+		IPLocalHost_AllowWithoutAuth = 52,
 		MTU_PacketSize = 32,
 		MTU_DataSize = 33,
 		Unencrypted = 34,
@@ -2345,10 +2402,17 @@ internal enum NetConfig : int
 		LocalVirtualPort = 38,
 		DualWifi_Enable = 39,
 		EnableDiagnosticsUI = 46,
+		SendTimeSincePreviousPacket = 59,
 		FakePacketLoss_Send = 2,
 		FakePacketLoss_Recv = 3,
 		FakePacketLag_Send = 4,
 		FakePacketLag_Recv = 5,
+		FakePacketJitter_Send_Avg = 53,
+		FakePacketJitter_Send_Max = 54,
+		FakePacketJitter_Send_Pct = 55,
+		FakePacketJitter_Recv_Avg = 56,
+		FakePacketJitter_Recv_Max = 57,
+		FakePacketJitter_Recv_Pct = 58,
 		FakePacketReorder_Send = 6,
 		FakePacketReorder_Recv = 7,
 		FakePacketReorder_Time = 8,
@@ -2360,6 +2424,7 @@ internal enum NetConfig : int
 		FakeRateLimit_Send_Burst = 43,
 		FakeRateLimit_Recv_Rate = 44,
 		FakeRateLimit_Recv_Burst = 45,
+		OutOfOrderCorrectionWindowMicroseconds = 51,
 		Callback_ConnectionStatusChanged = 201,
 		Callback_AuthStatusChanged = 202,
 		Callback_RelayNetworkStatusChanged = 203,
@@ -2380,15 +2445,17 @@ internal enum NetConfig : int
 		SDRClient_MinPingsBeforePingAccurate = 21,
 		SDRClient_SingleSocket = 22,
 		SDRClient_ForceRelayCluster = 29,
-		SDRClient_DebugTicketAddress = 30,
+		SDRClient_DevTicket = 30,
 		SDRClient_ForceProxyAddr = 31,
 		SDRClient_FakeClusterPing = 36,
+		SDRClient_LimitPingProbesToNearestN = 60,
 		LogLevel_AckRTT = 13,
 		LogLevel_PacketDecode = 14,
 		LogLevel_Message = 15,
 		LogLevel_PacketGaps = 16,
 		LogLevel_P2PRendezvous = 17,
 		LogLevel_SDRRelayPings = 18,
+		ECN = 999,
 		DELETED_EnumerateDevVars = 35,
 	}
 	
@@ -2420,6 +2487,17 @@ public enum NetDebugOutput : int
 		Everything = 8,
 	}
 	
+	//
+	// ESteamAPIInitResult
+	//
+	internal enum SteamAPIInitResult : int
+	{
+		OK = 0,
+		FailedGeneric = 1,
+		NoSteamClient = 2,
+		VersionMismatch = 3,
+	}
+	
 	//
 	// EServerMode
 	//

Facepunch.Steamworks/Generated/SteamStructFunctions.cs

@@ -141,12 +141,6 @@ public partial struct NetIdentity
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetPSNID", CallingConvention = Platform.CC)]
 		internal static extern ulong InternalGetPSNID( ref NetIdentity self );
 		
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetStadiaID", CallingConvention = Platform.CC)]
-		internal static extern void InternalSetStadiaID( ref NetIdentity self, ulong id );
-		
-		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamNetworkingIdentity_GetStadiaID", CallingConvention = Platform.CC)]
-		internal static extern ulong InternalGetStadiaID( ref NetIdentity self );
-		
 		[DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_SteamNetworkingIdentity_SetIPAddr", CallingConvention = Platform.CC)]
 		internal static extern void InternalSetIPAddr( ref NetIdentity self, ref NetAddress addr );
 		

Facepunch.Steamworks/Generated/SteamStructs.cs

@@ -105,30 +105,6 @@ internal struct P2PSessionState_t
 		
 	}
 	
-	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
-	internal struct InputMotionDataV2_t
-	{
-		internal float DriftCorrectedQuatX; // driftCorrectedQuatX float
-		internal float DriftCorrectedQuatY; // driftCorrectedQuatY float
-		internal float DriftCorrectedQuatZ; // driftCorrectedQuatZ float
-		internal float DriftCorrectedQuatW; // driftCorrectedQuatW float
-		internal float SensorFusionQuatX; // sensorFusionQuatX float
-		internal float SensorFusionQuatY; // sensorFusionQuatY float
-		internal float SensorFusionQuatZ; // sensorFusionQuatZ float
-		internal float SensorFusionQuatW; // sensorFusionQuatW float
-		internal float DeferredSensorFusionQuatX; // deferredSensorFusionQuatX float
-		internal float DeferredSensorFusionQuatY; // deferredSensorFusionQuatY float
-		internal float DeferredSensorFusionQuatZ; // deferredSensorFusionQuatZ float
-		internal float DeferredSensorFusionQuatW; // deferredSensorFusionQuatW float
-		internal float GravityX; // gravityX float
-		internal float GravityY; // gravityY float
-		internal float GravityZ; // gravityZ float
-		internal float DegreesPerSecondX; // degreesPerSecondX float
-		internal float DegreesPerSecondY; // degreesPerSecondY float
-		internal float DegreesPerSecondZ; // degreesPerSecondZ float
-		
-	}
-	
 	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )]
 	internal struct SteamInputActionEvent_t
 	{
@@ -180,6 +156,7 @@ internal struct SteamUGCDetails_t
 		internal uint VotesDown; // m_unVotesDown uint32
 		internal float Score; // m_flScore float
 		internal uint NumChildren; // m_unNumChildren uint32
+		internal ulong TotalFilesSize; // m_ulTotalFilesSize uint64
 		
 	}
 	

Facepunch.Steamworks/Generated/SteamTypes.cs

@@ -598,6 +598,22 @@ internal struct SteamInventoryUpdateHandle_t : IEquatable<SteamInventoryUpdateHa
 		public int CompareTo( SteamInventoryUpdateHandle_t other ) => Value.CompareTo( other.Value );
 	}
 	
+	internal struct TimelineEventHandle_t : IEquatable<TimelineEventHandle_t>, IComparable<TimelineEventHandle_t>
+	{
+		// Name: TimelineEventHandle_t, Type: unsigned long long
+		public ulong Value;
+		
+		public static implicit operator TimelineEventHandle_t( ulong value ) => new TimelineEventHandle_t(){ Value = value };
+		public static implicit operator ulong( TimelineEventHandle_t value ) => value.Value;
+		public override string ToString() => Value.ToString();
+		public override int GetHashCode() => Value.GetHashCode();
+		public override bool Equals( object p ) => this.Equals( (TimelineEventHandle_t) p );
+		public bool Equals( TimelineEventHandle_t p ) => p.Value == Value;
+		public static bool operator ==( TimelineEventHandle_t a, TimelineEventHandle_t b ) => a.Equals( b );
+		public static bool operator !=( TimelineEventHandle_t a, TimelineEventHandle_t b ) => !a.Equals( b );
+		public int CompareTo( TimelineEventHandle_t other ) => Value.CompareTo( other.Value );
+	}
+	
 	internal struct RemotePlaySessionID_t : IEquatable<RemotePlaySessionID_t>, IComparable<RemotePlaySessionID_t>
 	{
 		// Name: RemotePlaySessionID_t, Type: unsigned int

Facepunch.Steamworks/SteamClient.cs

@@ -23,9 +23,31 @@ public static void Init( uint appid, bool asyncCallbacks = true )
 			System.Environment.SetEnvironmentVariable( "SteamAppId", appid.ToString() );
 			System.Environment.SetEnvironmentVariable( "SteamGameId", appid.ToString() );
 
-			if ( !SteamAPI.Init() )
+			var interfaceVersions = Helpers.BuildVersionString(
+				ISteamApps.Version,
+				ISteamFriends.Version,
+				ISteamInput.Version,
+				ISteamInventory.Version,
+				ISteamMatchmaking.Version,
+				ISteamMatchmakingServers.Version,
+				ISteamMusic.Version,
+				ISteamNetworking.Version,
+				ISteamNetworkingSockets.Version,
+				ISteamNetworkingUtils.Version,
+				ISteamParentalSettings.Version,
+				ISteamParties.Version,
+				ISteamRemoteStorage.Version,
+				ISteamScreenshots.Version,
+				ISteamUGC.Version,
+				ISteamUser.Version,
+				ISteamUserStats.Version,
+				ISteamUtils.Version,
+				ISteamVideo.Version,
+				ISteamRemotePlay.Version );
+			var result = SteamAPI.Init( interfaceVersions, out var error );
+			if ( result != SteamAPIInitResult.OK )
 			{
-				throw new System.Exception( "SteamApi_Init returned false. Steam isn't running, couldn't find Steam, App ID is unreleased, Don't own App ID." );
+				throw new System.Exception( $"SteamApi_Init failed with {result} - error: {error}" );
 			}
 
 			AppId = appid;

Facepunch.Steamworks/SteamServer.cs

@@ -83,14 +83,24 @@ public static void Init( AppId appid, SteamServerInit init, bool asyncCallbacks
 			//
 			// Get other interfaces
 			//
-			if ( !SteamInternal.GameServer_Init( ipaddress, 0, init.GamePort, init.QueryPort, secure, init.VersionString ) )
+			var interfaceVersions = Helpers.BuildVersionString(
+				ISteamGameServer.Version,
+				ISteamUtils.Version,
+				ISteamNetworking.Version,
+				ISteamGameServerStats.Version,
+				ISteamInventory.Version,
+				ISteamUGC.Version,
+				ISteamApps.Version,
+				ISteamNetworkingUtils.Version,
+				ISteamNetworkingSockets.Version );
+			var result = SteamInternal.GameServer_Init( ipaddress, init.GamePort, init.QueryPort, secure, init.VersionString, interfaceVersions, out var error );
+			if ( result != SteamAPIInitResult.OK )
 			{
-				throw new System.Exception( $"InitGameServer returned false ({ipaddress},{0},{init.GamePort},{init.QueryPort},{secure},\"{init.VersionString}\")" );
+				throw new System.Exception( $"InitGameServer({ipaddress},{init.GamePort},{init.QueryPort},{secure},\"{init.VersionString}\") returned false - error: {error}" );
 			}
 
 			//
-			// Dispatch is responsible for pumping the
+			// Dispatch is responsible for pumping the event loop.
-			// event loop.
 			//
 			Dispatch.Init();
 			Dispatch.ServerPipe = SteamGameServer.GetHSteamPipe();

Facepunch.Steamworks/SteamUserStats.cs

@@ -130,14 +130,13 @@ public static bool StoreStats()
 		}
 
 		/// <summary>
-		/// Asynchronously request the user's current stats and achievements from the server.
+		/// This call is no longer required as it is managed by the Steam client. The game stats and achievements
-		/// You must always call this first to get the initial status of stats and achievements.
+		/// will be synchronized with Steam before the game process begins.
-		/// Only after the resulting callback comes back can you start calling the rest of the stats 
-		/// and achievement functions for the current user.
 		/// </summary>
+		[Obsolete( "No longer required. Automatically handled by the Steam client.", false )]
 		public static bool RequestCurrentStats()
 		{
-			return Internal.RequestCurrentStats();
+			return true;
 		}
 
 		/// <summary>

Facepunch.Steamworks/Structs/InventoryDef.cs

@@ -100,7 +100,7 @@ public string GetProperty( string name )
 
 			uint _ = (uint)Helpers.MemoryBufferSize;
 
-			if ( !SteamInventory.Internal.GetItemDefinitionProperty( Id, name, out var vl, ref _ ) )
+			if ( !SteamInventory.Internal.GetItemDefinitionProperty( Id, name, out var vl ) )
 				return null;
 				
 			if (name == null) //return keys string

Facepunch.Steamworks/Structs/InventoryItem.cs

@@ -100,18 +100,14 @@ internal static InventoryItem From( SteamItemDetails_t details )
 
 		internal static Dictionary<string, string> GetProperties( SteamInventoryResult_t result, int index )
 		{
-			var strlen = (uint) Helpers.MemoryBufferSize;
+			if ( !SteamInventory.Internal.GetResultItemProperty( result, (uint)index, null, out var propNames ) )
-
-			if ( !SteamInventory.Internal.GetResultItemProperty( result, (uint)index, null, out var propNames, ref strlen ) )
 				return null;
 
 			var props = new Dictionary<string, string>();
 
 			foreach ( var propertyName in propNames.Split( ',' ) )
 			{
-				strlen = (uint)Helpers.MemoryBufferSize;
+				if ( SteamInventory.Internal.GetResultItemProperty( result, (uint)index, propertyName, out var strVal ) )
-
-				if ( SteamInventory.Internal.GetResultItemProperty( result, (uint)index, propertyName, out var strVal, ref strlen ) )
 				{
 					props.Add( propertyName, strVal );
 				}
@@ -179,4 +175,4 @@ public struct Amount
 		public override int GetHashCode() => _id.GetHashCode();
 		public bool Equals( InventoryItem p ) => p._id == _id;
 	}
-}
+}

Facepunch.Steamworks/Structs/MatchMakingKeyValuePair.cs

@@ -3,7 +3,7 @@
 
 namespace Steamworks.Data
 {
-	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )]
+	[StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize, CharSet = CharSet.Ansi )]
 	internal partial struct MatchMakingKeyValuePair
 	{
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]

Facepunch.Steamworks/Structs/UgcEditor.cs

@@ -194,7 +194,7 @@ public async Task<PublishResult> SubmitAsync( IProgress<float> progress = null,
 					using ( var a = SteamParamStringArray.From( Tags.ToArray() ) )
 					{
 						var val = a.Value;
-						SteamUGC.Internal.SetItemTags( handle, ref val );
+						SteamUGC.Internal.SetItemTags( handle, ref val, false );
 					}
 				}
 
@@ -297,4 +297,4 @@ public struct PublishResult
 		/// </summary>
 		public bool NeedsWorkshopAgreement;
 	}
-}
+}

Facepunch.Steamworks/Utility/Helpers.cs

@@ -99,6 +99,18 @@ internal unsafe static string MemoryToString( IntPtr ptr )
 
 			return UTF8Encoding.UTF8.GetString( (byte*)ptr, len );
 		}
+		
+		internal static string BuildVersionString( params string[] interfaceVersions )
+		{
+			var sb = new StringBuilder();
+			foreach ( var version in interfaceVersions )
+			{
+				sb.Append( version ).Append( '\0' );
+			}
+
+			sb.Append( '\0' );
+			return sb.ToString();
+		}
 	}
 
 	internal class MonoPInvokeCallbackAttribute : Attribute

Facepunch.Steamworks/Utility/SteamInterface.cs

@@ -143,4 +143,4 @@ internal override void DestroyInterface( bool server )
 		}
 	}
 
-}
+}

Generator/CodeWriter/Constants.cs

@@ -25,6 +25,7 @@ private void Constants()
                 val = val.Replace( "uint32", "uint" );
                 val = val.Replace( "16U", "16" );
                 val = val.Replace( "8U", "8" );
+                val = val.Replace( ".f", ".0f" );
 
                 // we're not an actual typedef so can't cast like this
                 val = val.Replace( "( SteamItemInstanceID_t ) ~ 0", "~default(ulong)" );
@@ -39,4 +40,4 @@ private void Constants()
             EndBlock();
         }
     }
-}
+}

Generator/CodeWriter/Interface.cs

@@ -25,7 +25,12 @@ public void GenerateInterface( SteamApiDefinition.Interface iface, string folder
 			{
 				StartBlock( $"internal unsafe partial class {iface.Name} : SteamInterface" );
 				{
-					WriteLine();
+					if ( !string.IsNullOrWhiteSpace( iface.VersionString ) )
+					{
+						WriteLine($"public const string Version = \"{iface.VersionString}\";");
+						WriteLine();
+					}
+					
 					StartBlock( $"internal {iface.Name}( bool IsGameServer )" );
 					{
 						WriteLine( $"SetupInterface( IsGameServer );" );
@@ -87,31 +92,7 @@ private void WriteFunction( SteamApiDefinition.Interface iface, SteamApiDefiniti
 			if ( func.Params == null )
 				func.Params = new SteamApiDefinition.Interface.Method.Param[0];
 
-			var args = func.Params.Select( x =>
+			var args = ProcessArgs( func );
-			{
-				var bt = BaseType.Parse( x.ParamType, x.ParamName );
-				bt.Func = func.Name;
-				return bt;
-			} ).ToArray();
-
-			for( int i=0; i<args.Length; i++ )
-			{
-				if ( args[i] is FetchStringType )
-				{
-					if ( args[i + 1] is IntType || args[i + 1] is UIntType || args[i + 1] is UIntPtrType )
-					{
-						if ( string.IsNullOrEmpty(  args[i + 1].Ref ) )
-						{
-							args[i + 1] = new LiteralType( args[i + 1], "(1024 * 32)" );
-						}
-					}
-					else
-					{
-						throw new System.Exception( $"String Builder Next Type Is {args[i+1].GetType()}" );
-					}
-				}
-			}
-
 			var argstr = string.Join( ", ", args.Where( x => !x.ShouldSkipAsArgument ).Select( x => x.AsArgument() ) ); ;
 			var delegateargstr = string.Join( ", ", args.Select( x => x.AsNativeArgument() ) );
 
@@ -154,6 +135,10 @@ private void WriteFunction( SteamApiDefinition.Interface iface, SteamApiDefiniti
 					{
 						WriteLine( $"using var mem{sb.VarName} = Helpers.TakeMemory();" );
 					}
+					else if ( arg is LiteralType literal && literal.IsOutValue )
+					{
+						WriteLine( literal.OutVarDeclaration );
+					}
 				}
 
 				if ( returnType.IsVoid )

Generator/CodeWriter/StructFunctions.cs

@@ -33,31 +33,7 @@ void StructFunctions()
                         var returnType = BaseType.Parse( func.ReturnType, null, func.CallResult );
                         returnType.Func = func.Name;
 
-                        var args = func.Params.Select( x =>
+                        var args = ProcessArgs( func );
-                        {
-                            var bt = BaseType.Parse( x.ParamType, x.ParamName );
-                            bt.Func = func.Name;
-                            return bt;
-                        } ).ToArray();
-
-                        for ( int i = 0; i < args.Length; i++ )
-                        {
-                            if ( args[i] is FetchStringType )
-                            {
-                                if ( args[i + 1] is IntType || args[i + 1] is UIntType || args[i + 1] is UIntPtrType )
-                                {
-                                    if ( string.IsNullOrEmpty( args[i + 1].Ref ) )
-                                    {
-                                        args[i + 1] = new LiteralType( args[i + 1], "(1024 * 32)" );
-                                    }
-                                }
-                                else
-                                {
-                                    throw new System.Exception( $"String Builder Next Type Is {args[i + 1].GetType()}" );
-                                }
-                            }
-                        }
-
                         var delegateargstr = string.Join( ", ", args.Select( x => x.AsNativeArgument() ) );
 
                         if ( !string.IsNullOrEmpty( func.Desc ) )

Generator/CodeWriter/Types.cs

@@ -18,7 +18,8 @@ public partial class CodeWriter
             "SteamAPIWarningMessageHook_t",
             "Salt_t",
             "SteamAPI_CheckCallbackRegistered_t",
-            "compile_time_assert_type"
+            "compile_time_assert_type",
+            "SteamErrMsg",
         };
 
         //

Generator/CodeWriter/Utility.cs

@@ -88,5 +88,47 @@ private string ToManagedType( string type )
 
             return type;
         }
+
+        private List<BaseType> ProcessArgs( SteamApiDefinition.Interface.Method func )
+        {
+	        var args = func.Params.Select( x =>
+	        {
+		        var bt = BaseType.Parse( x.ParamType, x.ParamName, bufferSizeName: x.OutStringCount );
+		        bt.Func = func.Name;
+		        return bt;
+	        } ).ToList();
+
+	        for ( var i = 0; i < args.Count; i++ )
+	        {
+		        if ( args[i] is not FetchStringType fetchString )
+		        {
+			        continue;
+		        }
+
+		        var bufferSizeIdx = -1;
+		        if ( !string.IsNullOrWhiteSpace( fetchString.BufferSizeParamName ) )
+		        {
+			        bufferSizeIdx = args.FindIndex( x => x.VarName == fetchString.BufferSizeParamName );
+		        }
+		        else if ( args[i + 1] is IntType || args[i + 1] is UIntType || args[i + 1] is UIntPtrType )
+		        {
+			        bufferSizeIdx = i + 1;
+		        }
+				
+		        if ( bufferSizeIdx >= 0 )
+		        {
+			        if ( args[bufferSizeIdx] is not LiteralType )
+			        {
+				        args[bufferSizeIdx] = new LiteralType( args[bufferSizeIdx], "(1024 * 32)" );
+			        }
+		        }
+		        else
+		        {
+			        throw new System.Exception( $"Couldn't determine buffer size for parameter {args[i].VarName} in {func.FlatName}" );
+		        }
+	        }
+
+	        return args;
+        }
     }
 }

Generator/SteamApiDefinition.cs

@@ -27,6 +27,9 @@ public class Param
                 {
                     public string ParamType { get; set; }
                     public string ParamName { get; set; }
+                    
+                    [JsonProperty( PropertyName = "out_string_count" )]
+                    public string OutStringCount { get; set; }
                 }
 
                 public Param[] Params { get; set; }

Generator/Types/BaseType.cs

@@ -13,7 +13,7 @@ internal class BaseType
 
 	public string Func;
 
-	public static BaseType Parse( string type, string varname = null, string callresult = null )
+	public static BaseType Parse( string type, string varname = null, string callresult = null, string bufferSizeName = null )
 	{
 		type = Cleanup.ConvertType( type );
 
@@ -24,7 +24,7 @@ public static BaseType Parse( string type, string varname = null, string callres
 
 		if ( type == "void" ) return new VoidType { NativeType = type, VarName = varname };
 		if ( type.Replace( " ", "" ).StartsWith( "constchar*" ) ) return new ConstCharType { NativeType = type, VarName = varname };
-		if ( type == "char *" ) return new FetchStringType { NativeType = type, VarName = varname };
+		if ( type == "char *" ) return new FetchStringType { NativeType = type, VarName = varname, BufferSizeParamName = bufferSizeName };
 
 		var basicType = type.Replace( "const ", "" ).Trim( ' ', '*', '&' );
 

Generator/Types/FetchStringType.cs

@@ -15,6 +15,8 @@
 
 internal class FetchStringType : BaseType
 {
+	public string BufferSizeParamName; // optional, use next parameter if not set
+	
 	public override string TypeName => $"string";
 	public override string AsArgument() => $"out string {VarName}";
 
@@ -22,4 +24,4 @@ internal class FetchStringType : BaseType
 
 	public override string AsCallArgument() => $"mem{VarName}";
 	public override string Ref => "";
-}
+}

Generator/Types/LiteralType.cs

@@ -15,18 +15,23 @@
 internal class LiteralType : BaseType
 {
 	private string Value;
-	BaseType basetype;
+	private BaseType baseType;
 
-	public LiteralType( BaseType basetype, string value )
+	public LiteralType( BaseType baseType, string value )
 	{
-		this.basetype = basetype;
+		this.baseType = baseType;
 		this.Value = value;
+
+		VarName = baseType.VarName;
 	}
 
+	public bool IsOutValue => !string.IsNullOrEmpty( Ref );
+	public string OutVarDeclaration => IsOutValue ? $"{baseType.TypeName} sz{VarName} = {Value};" : null;
+
 	public override bool ShouldSkipAsArgument => true;
 
-	public override string Ref => "";
+	public override string Ref => baseType.Ref;
 	public override bool IsVector => false;
-	public override string AsArgument() => basetype.AsArgument();
+	public override string AsArgument() => baseType.AsArgument();
-	public override string AsCallArgument() => Value;
+	public override string AsCallArgument() => string.IsNullOrEmpty( Ref ) ? Value : $"{Ref}sz{VarName}";
-}
+}

Generator/steam_sdk/isteamapplist.h

@@ -1,68 +0,0 @@
-//====== Copyright © 1996-2008, Valve Corporation, All rights reserved. =======
-//
-// Purpose: interface to app data in Steam
-//
-//=============================================================================
-
-#ifndef ISTEAMAPPLIST_H
-#define ISTEAMAPPLIST_H
-#ifdef _WIN32
-#pragma once
-#endif
-
-#include "steam_api_common.h"
-
-//-----------------------------------------------------------------------------
-// Purpose: This is a restricted interface that can only be used by previously approved apps,
-//	contact your Steam Account Manager if you believe you need access to this API.
-//	This interface lets you detect installed apps for the local Steam client, useful for debugging tools
-//	to offer lists of apps to debug via Steam.
-//-----------------------------------------------------------------------------
-class ISteamAppList
-{
-public:
-	virtual uint32 GetNumInstalledApps() = 0;
-	virtual uint32 GetInstalledApps( AppId_t *pvecAppID, uint32 unMaxAppIDs ) = 0;
-
-	virtual int  GetAppName( AppId_t nAppID, STEAM_OUT_STRING() char *pchName, int cchNameMax ) = 0; // returns -1 if no name was found
-	virtual int  GetAppInstallDir( AppId_t nAppID, char *pchDirectory, int cchNameMax ) = 0; // returns -1 if no dir was found
-
-	virtual int GetAppBuildId( AppId_t nAppID ) = 0; // return the buildid of this app, may change at any time based on backend updates to the game
-};
-
-#define STEAMAPPLIST_INTERFACE_VERSION "STEAMAPPLIST_INTERFACE_VERSION001"
-
-// Global interface accessor
-inline ISteamAppList *SteamAppList();
-STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamAppList *, SteamAppList, STEAMAPPLIST_INTERFACE_VERSION );
-
-// callbacks
-#if defined( VALVE_CALLBACK_PACK_SMALL )
-#pragma pack( push, 4 )
-#elif defined( VALVE_CALLBACK_PACK_LARGE )
-#pragma pack( push, 8 )
-#else
-#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
-#endif 
-
-
-//---------------------------------------------------------------------------------
-// Purpose: Sent when a new app is installed (not downloaded yet)
-//---------------------------------------------------------------------------------
-STEAM_CALLBACK_BEGIN( SteamAppInstalled_t, k_iSteamAppListCallbacks + 1 )
-STEAM_CALLBACK_MEMBER( 0, AppId_t, m_nAppID )			// ID of the app that installs
-STEAM_CALLBACK_MEMBER( 1, int, m_iInstallFolderIndex ) // library folder the app is installed 
-STEAM_CALLBACK_END( 2 )
-
-
-//---------------------------------------------------------------------------------
-// Purpose: Sent when an app is uninstalled
-//---------------------------------------------------------------------------------
-STEAM_CALLBACK_BEGIN( SteamAppUninstalled_t, k_iSteamAppListCallbacks + 2 )
-STEAM_CALLBACK_MEMBER( 0, AppId_t, m_nAppID )			// ID of the app that installs
-STEAM_CALLBACK_MEMBER( 1, int, m_iInstallFolderIndex ) // library folder the app was installed 
-STEAM_CALLBACK_END(2)
-
-
-#pragma pack( pop )
-#endif // ISTEAMAPPLIST_H

Generator/steam_sdk/isteamapps.h

@@ -84,7 +84,7 @@ public:
 	// return the buildid of this app, may change at any time based on backend updates to the game
 	virtual int GetAppBuildId() = 0;
 
-	// Request all proof of purchase keys for the calling appid and asociated DLC.
+	// Request all proof of purchase keys for the calling appid and associated DLC.
 	// A series of AppProofOfPurchaseKeyResponse_t callbacks will be sent with
 	// appropriate appid values, ending with a final callback where the m_nAppId
 	// member is k_uAppIdInvalid (zero).
@@ -110,7 +110,16 @@ public:
 	virtual bool BIsTimedTrial( uint32* punSecondsAllowed, uint32* punSecondsPlayed ) = 0; 
 
 	// set current DLC AppID being played (or 0 if none). Allows Steam to track usage of major DLC extensions
-	virtual bool SetDlcContext( AppId_t nAppID ) = 0; 
+	virtual bool SetDlcContext( AppId_t nAppID ) = 0;
+
+	// returns total number of known app branches (including default "public" branch ). nAvailable is number of available betas
+	virtual int  GetNumBetas( int *pnAvailable, int *pnPrivate ) = 0; //
+
+	// return beta branch details, name, description, current BuildID and state flags (EBetaBranchFlags)
+	virtual bool GetBetaInfo( int iBetaIndex, uint32 *punFlags, uint32 *punBuildID, char *pchBetaName, int cchBetaName, char *pchDescription, int cchDescription ) = 0; // iterate through
+
+	// select this beta branch for this app as active, might need the game to restart so Steam can update to that branch
+	virtual bool SetActiveBeta( const char *pchBetaName ) = 0;
 };
 
 #define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION008"

Generator/steam_sdk/isteamclient.h

@@ -115,18 +115,12 @@ public:
 	// Expose HTTP interface
 	virtual ISteamHTTP *GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
 
-	// Deprecated - the ISteamUnifiedMessages interface is no longer intended for public consumption.
-	STEAM_PRIVATE_API( virtual void *DEPRECATED_GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0 ; )
-
 	// Exposes the ISteamController interface - deprecated in favor of Steam Input
 	virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
 
 	// Exposes the ISteamUGC interface
 	virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
 
-	// returns app list interface, only available on specially registered apps
-	virtual ISteamAppList *GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
-	
 	// Music Player
 	virtual ISteamMusic *GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
 
@@ -162,7 +156,7 @@ public:
 	STEAM_PRIVATE_API( virtual void DestroyAllInterfaces() = 0; )
 
 };
-#define STEAMCLIENT_INTERFACE_VERSION		"SteamClient020"
+#define STEAMCLIENT_INTERFACE_VERSION		"SteamClient021"
 
 #ifndef STEAM_API_EXPORTS
 

Generator/steam_sdk/isteamcontroller.h

@@ -458,6 +458,11 @@ enum EControllerActionOrigin
 	k_EControllerActionOrigin_PS5_LeftFn,
 	k_EControllerActionOrigin_PS5_RightFn,
 
+	k_EControllerActionOrigin_Horipad_M1,
+	k_EControllerActionOrigin_Horipad_M2,
+	k_EControllerActionOrigin_Horipad_L4,
+	k_EControllerActionOrigin_Horipad_R4,
+
 	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.
 };
@@ -539,7 +544,6 @@ 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
 {

Generator/steam_sdk/isteamfriends.h

@@ -103,6 +103,10 @@ struct FriendGameInfo_t
 };
 #pragma pack( pop )
 
+// special values for FriendGameInfo_t::m_usQueryPort
+const uint16 k_usFriendGameInfoQueryPort_NotInitialized = 0xFFFF;		// We haven't asked the GS for this query port's actual value yet.  Was #define QUERY_PORT_NOT_INITIALIZED in older versions of Steamworks SDK.
+const uint16 k_usFriendGameInfoQueryPort_Error          = 0xFFFE;		// We were unable to get the query port for this server.  Was #define QUERY_PORT_ERROR in older versions of Steamworks SDK.
+
 // maximum number of characters in a user's name. Two flavors; one for UTF-8 and one for UTF-16.
 // The UTF-8 version has to be very generous to accomodate characters that get large when encoded
 // in UTF-8.
@@ -517,6 +521,7 @@ struct GameOverlayActivated_t
 	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)
+	uint32 m_dwOverlayPID;	// used internally
 };
 
 
@@ -745,6 +750,7 @@ struct EquippedProfileItems_t
 	bool m_bHasProfileModifier;
 	bool m_bHasProfileBackground;
 	bool m_bHasMiniProfileBackground;
+	bool m_bFromCache;
 };
 
 #pragma pack( pop )

Generator/steam_sdk/isteaminput.h

@@ -482,6 +482,11 @@ enum EInputActionOrigin
 	k_EInputActionOrigin_SteamDeck_Reserved19,
 	k_EInputActionOrigin_SteamDeck_Reserved20,
 
+	k_EInputActionOrigin_Horipad_M1,
+	k_EInputActionOrigin_Horipad_M2,
+	k_EInputActionOrigin_Horipad_L4,
+	k_EInputActionOrigin_Horipad_R4,
+
 	k_EInputActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
 	k_EInputActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
 };
@@ -643,73 +648,38 @@ struct InputDigitalActionData_t
 
 struct InputMotionData_t
 {
-	// Sensor-fused absolute rotation; will drift in heading toward average
+	// Gyro Quaternion:
+	// Absolute rotation of the controller since wakeup, using the Accelerometer reading at startup to determine the first value.
+	// This means real world "up" is know, but heading is not known.
+	// Every rotation packet is integrated using sensor time delta, and that change is used to update this quaternion.
+	// A Quaternion Identity ( x:0, y:0, z:0, w:1 ) will be sent in the first few packets while the controller's IMU is still waking up;
+	// some controllers have a short "warmup" period before these values should be used.
+
+	// After the first time GetMotionData is called per controller handle, the IMU will be active until your app is closed.
+	// The exception is the Sony Dualshock, which will stay on until the controller has been turned off.
+
+	// Filtering: When rotating the controller at low speeds, low level noise is filtered out without noticeable latency. High speed movement is always unfiltered.
+	// Drift: Gyroscopic "Drift" can be fixed using the Steam Input "Gyro Calibration" button. Users will have to be informed of this feature.
 	float rotQuatX;
 	float rotQuatY;
 	float rotQuatZ;
 	float rotQuatW;
 
 	// Positional acceleration
-	float posAccelX;
+	// This represents only the latest hardware packet's state.
-	float posAccelY;
+	// Values range from -SHRT_MAX..SHRT_MAX
-	float posAccelZ;
+	// This represents -2G..+2G along each axis
+	float posAccelX; // +tive when controller's Right hand side is pointed toward the sky.
+	float posAccelY; // +tive when controller's charging port (forward side of controller) is pointed toward the sky.
+	float posAccelZ; // +tive when controller's sticks point toward the sky.
 
 	// Angular velocity
-	float rotVelX;
+	// Values range from -SHRT_MAX..SHRT_MAX
-	float rotVelY;
+	// These values map to a real world range of -2000..+2000 degrees per second on each axis (SDL standard)
-	float rotVelZ;
+	// This represents only the latest hardware packet's state.
-};
+	float rotVelX; // Local Pitch
-
+	float rotVelY; // Local Roll
-
+	float rotVelZ; // Local Yaw
-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;
-
 };
 
 //-----------------------------------------------------------------------------

Generator/steam_sdk/isteamnetworkingsockets.h

@@ -206,7 +206,7 @@ public:
 	/// WARNING: Be *very careful* when using the value provided in callbacks structs.
 	/// Callbacks are queued, and the value that you will receive in your
 	/// callback is the userdata that was effective at the time the callback
-	/// was queued.  There are subtle race conditions that can hapen if you
+	/// was queued.  There are subtle race conditions that can happen if you
 	/// don't understand this!
 	///
 	/// If any incoming messages for this connection are queued, the userdata
@@ -397,10 +397,9 @@ public:
 	/// lanes may be sent out of order.  Each lane has its own message number
 	/// sequence.  The first message sent on each lane will be assigned the number 1.
 	///
-	/// Each lane has a "priority".  Lower priority lanes will only be processed
+	/// Each lane has a "priority".  Lanes with higher numeric values will only be processed
-	/// when all higher-priority lanes are empty.  The magnitudes of the priority
+	/// when all lanes with lower number values are empty.  The magnitudes of the priority
-	/// values are not relevant, only their sort order.  Higher numeric values
+	/// values are not relevant, only their sort order.
-	/// take priority over lower numeric values.
 	/// 
 	/// Each lane also is assigned a weight, which controls the approximate proportion
 	/// of the bandwidth that will be consumed by the lane, relative to other lanes
@@ -829,7 +828,7 @@ public:
 	/// different types of traffic.  Because these allocations come from a global
 	/// namespace, there is a relatively strict limit on the maximum number of
 	/// ports you may request.  (At the time of this writing, the limit is 4.)
-	/// The Port assignments are *not* guaranteed to have any particular order
+	/// The port assignments are *not* guaranteed to have any particular order
 	/// or relationship!  Do *not* assume they are contiguous, even though that
 	/// may often occur in practice.
 	///

Generator/steam_sdk/isteamparentalsettings.h

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

Generator/steam_sdk/isteamremoteplay.h

@@ -19,6 +19,7 @@ enum ESteamDeviceFormFactor
 	k_ESteamDeviceFormFactorTablet		= 2,
 	k_ESteamDeviceFormFactorComputer	= 3,
 	k_ESteamDeviceFormFactorTV			= 4,
+	k_ESteamDeviceFormFactorVRHeadset	= 5,
 };
 
 // Steam Remote Play session ID
@@ -51,12 +52,17 @@ public:
 	// This is set to 0x0 if the resolution is not available
 	virtual bool BGetSessionClientResolution( RemotePlaySessionID_t unSessionID, int *pnResolutionX, int *pnResolutionY ) = 0;
 
+	// Start Remote Play Together and optionally show the UI in the overlay
+	// This returns false if Remote Play Together can't be started or your game is not configured for Remote Play Together
+	virtual bool BStartRemotePlayTogether( bool bShowOverlay = true ) = 0;
+
 	// 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
+	// This will automatically start Remote Play Together if it hasn't already been started
+	// This returns false if the invite can't be sent or your game is not configured for Remote Play Together
 	virtual bool BSendRemotePlayTogetherInvite( CSteamID steamIDFriend ) = 0;
 };
 
-#define STEAMREMOTEPLAY_INTERFACE_VERSION "STEAMREMOTEPLAY_INTERFACE_VERSION001"
+#define STEAMREMOTEPLAY_INTERFACE_VERSION "STEAMREMOTEPLAY_INTERFACE_VERSION002"
 
 // Global interface accessor
 inline ISteamRemotePlay *SteamRemotePlay();

Generator/steam_sdk/isteamremotestorage.h

@@ -102,9 +102,10 @@ enum EWorkshopFileType
 	k_EWorkshopFileTypeSteamworksAccessInvite = 13,		// internal
 	k_EWorkshopFileTypeSteamVideo			  = 14,		// Steam video
 	k_EWorkshopFileTypeGameManagedItem		  = 15,		// managed completely by the game, not the user, and not shown on the web
+	k_EWorkshopFileTypeClip					  = 16,		// internal
 
 	// Update k_EWorkshopFileTypeMax if you add values.
-	k_EWorkshopFileTypeMax = 16
+	k_EWorkshopFileTypeMax = 17
 	
 };
 

Generator/steam_sdk/isteamtimeline.h

@@ -0,0 +1,261 @@
+//====== Copyright <20> Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to Steam Timeline
+//
+//=============================================================================
+
+#ifndef ISTEAMTIMELINE_H
+#define ISTEAMTIMELINE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "steam_api_common.h"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
+#endif
+
+// Controls the color of the timeline bar segments. The value names listed here map to a multiplayer game, where
+// the user starts a game (in menus), then joins a multiplayer session that first has a character selection lobby
+// then finally the multiplayer session starts. However, you can also map these values to any type of game. In a single
+// player game where you visit towns & dungeons, you could set k_ETimelineGameMode_Menus when the player is in a town
+// buying items, k_ETimelineGameMode_Staging for when a dungeon is loading and k_ETimelineGameMode_Playing for when
+// inside the dungeon fighting monsters.
+enum ETimelineGameMode
+{
+	k_ETimelineGameMode_Invalid = 0,
+	k_ETimelineGameMode_Playing = 1,
+	k_ETimelineGameMode_Staging = 2,
+	k_ETimelineGameMode_Menus = 3,
+	k_ETimelineGameMode_LoadingScreen = 4,
+
+	k_ETimelineGameMode_Max, // one past the last valid value
+};
+
+// Used in AddTimelineEvent, where Featured events will be offered before Standard events
+enum ETimelineEventClipPriority
+{
+	k_ETimelineEventClipPriority_Invalid = 0,
+	k_ETimelineEventClipPriority_None = 1,
+	k_ETimelineEventClipPriority_Standard = 2,
+	k_ETimelineEventClipPriority_Featured = 3,
+};
+
+
+const uint32 k_unMaxTimelinePriority = 1000;
+const uint32 k_unTimelinePriority_KeepCurrentValue = 1000000; // Use with UpdateRangeTimelineEvent to not change the priority
+const float k_flMaxTimelineEventDuration = 600.f;
+const uint32 k_cchMaxPhaseIDLength = 64;
+
+typedef uint64 TimelineEventHandle_t;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Steam Timeline API
+//-----------------------------------------------------------------------------
+class ISteamTimeline
+{
+public:
+
+	// Sets a description for the current game state in the timeline. These help the user to find specific
+	// moments in the timeline when saving clips. Setting a new state description replaces any previous
+	// description.
+	//
+	// Examples could include:
+	//  * Where the user is in the world in a single player game
+	//  * Which round is happening in a multiplayer game
+	//  * The current score for a sports game
+	//
+	// Parameters:
+	// - pchDescription: provide a localized string in the language returned by SteamUtils()->GetSteamUILanguage()
+	// - flTimeDelta: The time offset in seconds to apply to this event. Negative times indicate an
+	//			event that happened in the past.
+	virtual void SetTimelineTooltip( const char *pchDescription, float flTimeDelta ) = 0;
+	virtual void ClearTimelineTooltip( float flTimeDelta ) = 0;
+
+	// Changes the color of the timeline bar. See ETimelineGameMode comments for how to use each value
+	virtual void SetTimelineGameMode( ETimelineGameMode eMode ) = 0;
+
+	/*******************    Timeline Events    *******************/
+
+	// The following functions add events and/or tags to the timeline.  There are helpers to add simple events or tags in a single call.
+	// or you can use StartEvent and CloseEvent to customize what gets added.
+	//
+	// Examples of events to add could include:
+	//   * a boss battle
+	//   * a cut scene
+	//   * a large team fight
+	//   * picking up a new weapon or ammunition
+	//   * scoring a goal
+	//
+	// Adding an event and a time range with the simple API:
+	//   SteamTimeline()->AddSimpleTimelineEvent( "steam_heart", Localize( "#user healed" ), Localize( "#health_amount", 27 ), 15, 0, 0, k_ETimelineEventClipPriority_None );
+	//   SteamTimeline()->AddTaggedTimeRange( Localize( "#player_resting" ), "steam_flag", /* don't show filter */nullptr, 15, /* start now */0, 10 );
+	//   SteamTimeline()->AddTaggedTimeRange( Localize( "#player_cast_light" ), "steam_starburst", Localize( "#player_spells" ), 10, /* start 10 sec ago */ -10, 5 );
+	//
+	// Adding a marker and time range in one event:
+	//   TimelineEventHandle_t event = SteamTimeline()->StartEvent( /* start now */ 0 );
+	//   SteamTimeline()->ShowEventOnTimeline( event, "steam_heart", Localize( "#player_healed" ), Localize( "#player_healed_amount", 27 ), 15 );
+	//   SteamTimeline()->AddEventTag( event, Localize( "#player_cast_heal" ), "steam_heart", Localize( "#player_, 15, /* start now */0, 10 );
+	//   ... // time passes
+	//   SteamTimeline()->CloseEvent( event );
+	//
+	// Parameters used by the event functions:
+	//
+	// - ulOpenEvent: An event returned by StartEvent that has not yet had CancelEvent or CloseEvent called on it
+	// - ulEvent: An event that has had CloseEvent called on it, or an event returned from AddSimpleTimelineEvent or AddTaggedTimeRange (which
+	//   are closed automatically.)
+	// - pchIcon: specify the name of the icon uploaded through the Steamworks Partner Site for your title
+	//   or one of the provided icons that start with steam_
+	// - pchTitle & pchDescription: provide a localized string in the language returned by
+	//	 SteamUtils()->GetSteamUILanguage()
+	// - unIconPriority: specify how important this range is compared to other markers provided by the game.
+	//   Ranges with larger priority values will be displayed more prominently in the UI. This value
+	//   may be between 0 and k_unMaxTimelinePriority.
+	// - flStartOffsetSeconds: The time that this range started relative to now. Negative times
+	//   indicate an event that happened in the past.
+	// - flDurationSeconds: How long the time range should be in seconds. For instantaneous events, this
+	//   should be 0
+	// - ePossibleClip: By setting this parameter to Featured or Standard, the game indicates to Steam that it
+	//   would be appropriate to offer this range as a clip to the user. For instantaneous events, the
+	//   suggested clip will be for a short time before and after the event itself.
+	// - pchTagIcon: specify an icon name that will be used next to the tag name in the UI
+	// - pchTagName: The localized name of the tag to show in the UI.
+	// - pchTagGroup: The localized name of the tag group to show in the UI. If this is not specified, users will not be able to filter by this tag
+	// - unTagPriority: specify how important this tag is compared to other tags provided by the game.
+	// Returns:
+	//   A TimelineEventHandle_t that can be used to make subsequent calls to refer to the timeline event. This event handle is invalid
+	//   after the game exits.
+
+	// quick helpers that add to the timeline in one call
+	virtual TimelineEventHandle_t AddInstantaneousTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unIconPriority, float flStartOffsetSeconds = 0.f, ETimelineEventClipPriority ePossibleClip = k_ETimelineEventClipPriority_None ) = 0;
+	virtual TimelineEventHandle_t AddRangeTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unIconPriority, float flStartOffsetSeconds = 0.f, float flDuration = 0.f, ETimelineEventClipPriority ePossibleClip = k_ETimelineEventClipPriority_None ) = 0;
+
+	// Starts a timeline event at a the current time, plus an offset in seconds. This event must be ended with EndRangeTimelineEvent.
+	// Any timeline events that have not been ended when the game exits will be discarded.
+	virtual TimelineEventHandle_t StartRangeTimelineEvent( const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip ) = 0;
+
+	// Updates fields on a range timeline event that was started with StartRangeTimelineEvent, and which has not been ended.
+	virtual void UpdateRangeTimelineEvent( TimelineEventHandle_t ulEvent, const char *pchTitle, const char *pchDescription, const char *pchIcon, uint32 unPriority, ETimelineEventClipPriority ePossibleClip ) = 0;
+
+	// Ends a range timeline event and shows it in the UI.
+	virtual void EndRangeTimelineEvent( TimelineEventHandle_t ulEvent, float flEndOffsetSeconds ) = 0;
+
+	// delete the event from the timeline. This can be called on a timeline event from AddInstantaneousTimelineEvent,
+	// AddRangeTimelineEvent, or StartRangeTimelineEvent/EndRangeTimelineEvent. The timeline event handle must be from the
+	// current game process.
+	virtual void RemoveTimelineEvent( TimelineEventHandle_t ulEvent ) = 0;
+
+	// add a tag to whatever time range is represented by the event
+	STEAM_CALL_RESULT( SteamTimelineEventRecordingExists_t )
+	virtual SteamAPICall_t DoesEventRecordingExist( TimelineEventHandle_t ulEvent ) = 0;
+
+	/*******************    Game Phases    *******************/
+
+	// Game phases allow the user to navigate their background recordings and clips. Exactly what a game phase means will vary game to game, but
+	// the game phase should be a section of gameplay that is usually between 10 minutes and a few hours in length, and should be the
+	// main way a user would think to divide up the game. These are presented to the user in a UI that shows the date the game was played,
+	// with one row per game slice. Game phases should be used to mark sections of gameplay that the user might be interested in watching.
+	//
+	//	Examples could include:
+	//		* A single match in a multiplayer PvP game
+	//		* A chapter of a story-based singleplayer game
+	//		* A single run in a roguelike
+	//
+	// Game phases are started with StartGamePhase, and while a phase is still happening, they can have tags and attributes added to them.
+	//
+	// Phase attributes represent generic text fields that can be updated throughout the duration of the phase. They are meant
+	// to be used for phase metadata that is not part of a well defined set of options. For example, a KDA attribute that starts
+	// with the value "0/0/0" and updates as the phase progresses, or something like a played-entered character name. Attributes
+	// can be set as many times as the game likes with SetGamePhaseAttribute, and only the last value will be shown to the user.
+	//
+	// Phase tags represent data with a well defined set of options, which could be data such as match resolution, hero played,
+	// game mode, etc. Tags can have an icon in addition to a text name. Multiple tags within the same group may be added per phase
+	// and all will be remembered. For example, AddGamePhaseTag may be called multiple times for a "Bosses Defeated" group, with
+	// different names and icons for each boss defeated during the phase, all of which will be shown to the user.
+	//
+	// The phase will continue until the game exits, until the game calls EndGamePhase, or until the game calls
+	// StartGamePhase to start a new phase.
+	//
+	// The game phase functions take these parameters:
+	// - pchTagIcon: The name of a game provided timeline icon or builtin "steam_" icon.
+	// - pchPhaseID: A game-provided persistent ID for a game phase. This could be a the match ID in a multiplayer game, a chapter name in a
+	//   single player game, the ID of a character, etc.
+	// - pchTagName: The localized name of the tag in the language returned by SteamUtils()->GetSteamUILanguage().
+	// - pchTagGroup: The localized name of the tag group.
+	// - pchAttributeValue: The localized name of the attribute.
+	// - pchAttributeGroup: The localized name of the attribute group.
+	// - unPriority: Used to order tags and attributes in the UI displayed to the user, with higher priority values leading
+	//   to more prominent positioning. In contexts where there is limited space, lower priority items may be hidden.
+	virtual void StartGamePhase() = 0;
+	virtual void EndGamePhase() = 0;
+
+	// Games can set a phase ID so they can refer back to a phase in OpenOverlayToPhase
+	virtual void SetGamePhaseID( const char *pchPhaseID ) = 0;
+	STEAM_CALL_RESULT( SteamTimelineGamePhaseRecordingExists_t )
+	virtual SteamAPICall_t DoesGamePhaseRecordingExist( const char *pchPhaseID ) = 0;
+
+	// Add a tag that applies to the entire phase
+	virtual void AddGamePhaseTag( const char *pchTagName, const char *pchTagIcon, const char *pchTagGroup, uint32 unPriority ) = 0;
+
+	// Add a text attribute that applies to the entire phase
+	virtual void SetGamePhaseAttribute( const char *pchAttributeGroup, const char *pchAttributeValue, uint32 unPriority ) = 0;
+
+	/*******************    Opening the overlay    *******************/
+
+	// Opens the Steam overlay to a game phase.
+	//
+	// Parameters:
+	// - pchPhaseID: The ID of a phase that was previously provided by the game in SetGamePhaseID.
+	virtual void OpenOverlayToGamePhase( const char *pchPhaseID ) = 0;
+
+	// Opens the Steam overlay to a timeline event.
+	//
+	// Parameters:
+	// - ulEventID: The ID of a timeline event returned by StartEvent or AddSimpleTimelineEvent
+	virtual void OpenOverlayToTimelineEvent( const TimelineEventHandle_t ulEvent ) = 0;
+
+};
+
+#define STEAMTIMELINE_INTERFACE_VERSION "STEAMTIMELINE_INTERFACE_V004"
+
+// Global interface accessor
+inline ISteamTimeline *SteamTimeline();
+STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamTimeline *, SteamTimeline, STEAMTIMELINE_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for querying UGC
+//-----------------------------------------------------------------------------
+struct SteamTimelineGamePhaseRecordingExists_t
+{
+	enum { k_iCallback = k_iSteamTimelineCallbacks + 1 };
+	char m_rgchPhaseID[ k_cchMaxPhaseIDLength ];
+	uint64 m_ulRecordingMS;
+	uint64 m_ulLongestClipMS;
+	uint32 m_unClipCount;
+	uint32 m_unScreenshotCount;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for querying UGC
+//-----------------------------------------------------------------------------
+struct SteamTimelineEventRecordingExists_t
+{
+	enum { k_iCallback = k_iSteamTimelineCallbacks + 2 };
+	uint64 m_ulEventID;
+	bool m_bRecordingExists;
+};
+
+
+
+#pragma pack( pop )
+
+
+#endif // ISTEAMTIMELINE_H

Generator/steam_sdk/isteamugc.h

@@ -121,6 +121,7 @@ enum EItemState
 	k_EItemStateNeedsUpdate		= 8,	// items needs an update. Either because it's not installed yet or creator updated content
 	k_EItemStateDownloading		= 16,	// item update is currently downloading
 	k_EItemStateDownloadPending	= 32,	// DownloadItem() was called for this item, content isn't available until DownloadItemResult_t is fired
+	k_EItemStateDisabledLocally = 64,	// Item is disabled locally, so it shouldn't be considered subscribed
 };
 
 enum EItemStatistic
@@ -154,6 +155,7 @@ enum EItemPreviewType
 																// |   |Dn |       |
 																// +---+---+---+---+
 	k_EItemPreviewType_EnvironmentMap_LatLong			= 4,	// standard image file expected
+	k_EItemPreviewType_Clip								= 5,	// clip id is stored
 	k_EItemPreviewType_ReservedMax						= 255,	// you can specify your own types above this value
 };
 
@@ -192,7 +194,7 @@ struct SteamUGCDetails_t
 	UGCHandle_t m_hFile;											// The handle of the primary file
 	UGCHandle_t m_hPreviewFile;										// The handle of the preview file
 	char m_pchFileName[k_cchFilenameMax];							// The cloud filename of the primary file
-	int32 m_nFileSize;												// Size of the primary file
+	int32 m_nFileSize;												// Size of the primary file (for legacy items which only support one file). This may not be accurate for non-legacy items which can be greater than 4gb in size.
 	int32 m_nPreviewFileSize;										// Size of the preview file
 	char m_rgchURL[k_cchPublishedFileURLMax];						// URL (for a video or a website)
 	// voting information
@@ -200,7 +202,8 @@ struct SteamUGCDetails_t
 	uint32 m_unVotesDown;											// number of votes down
 	float m_flScore;												// calculated score
 	// collection details
-	uint32 m_unNumChildren;							
+	uint32 m_unNumChildren;
+	uint64 m_ulTotalFilesSize;										// Total size of all files (non-legacy), excluding the preview file
 };
 
 //-----------------------------------------------------------------------------
@@ -246,6 +249,10 @@ 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;
 
+	// Some items can specify that they have a version that is valid for a range of game versions (Steam branch)
+	virtual uint32 GetNumSupportedGameVersions( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetSupportedGameVersionData( UGCQueryHandle_t handle, uint32 index, uint32 versionIndex, STEAM_OUT_STRING_COUNT( cchGameBranchSize ) char *pchGameBranchMin, STEAM_OUT_STRING_COUNT( cchGameBranchSize ) char *pchGameBranchMax, uint32 cchGameBranchSize ) = 0;
+
 	virtual uint32 GetQueryUGCContentDescriptors( UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID *pvecDescriptors, uint32 cMaxEntries ) = 0;
 	
 	// Release the request to free up memory, after retrieving results
@@ -265,6 +272,7 @@ public:
 	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;
+	virtual bool SetAdminQuery( UGCUpdateHandle_t handle, bool bAdminQuery ) = 0; // admin queries return hidden items
 
 	// Options only for querying user UGC
 	virtual bool SetCloudFileNameFilter( UGCQueryHandle_t handle, const char *pMatchCloudFileName ) = 0;
@@ -292,7 +300,7 @@ public:
 	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 SetItemTags( UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags, bool bAllowAdminTags = false ) = 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.
@@ -306,6 +314,7 @@ public:
 	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;
+	virtual bool SetRequiredGameVersions( UGCUpdateHandle_t handle, const char *pszGameBranchMin, const char *pszGameBranchMax ) = 0; // an empty string for either parameter means that it will match any version on that end of the range. This will only be applied if the actual content has been changed.
 
 	STEAM_CALL_RESULT( SubmitItemUpdateResult_t )
 	virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate()
@@ -382,9 +391,12 @@ public:
 	// 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;
+
+	// Return the user's community content descriptor preferences
+	virtual uint32 GetUserContentDescriptorPreferences( EUGCContentDescriptorID *pvecDescriptors, uint32 cMaxEntries ) = 0;
 };
 
-#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION017"
+#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION020"
 
 // Global interface accessor
 inline ISteamUGC *SteamUGC();
@@ -452,6 +464,8 @@ struct ItemInstalled_t
 	enum { k_iCallback = k_iSteamUGCCallbacks + 5 };
 	AppId_t m_unAppID;
 	PublishedFileId_t m_nPublishedFileId;
+	UGCHandle_t m_hLegacyContent;
+	uint64 m_unManifestID;
 };
 
 

Generator/steam_sdk/isteamuserstats.h

@@ -88,9 +88,11 @@ struct LeaderboardEntry_t
 class ISteamUserStats
 {
 public:
-	// Ask the server to send down this user's data and achievements for this game
+
-	STEAM_CALL_BACK( UserStatsReceived_t )
+	// Note: this call is no longer required as it is managed by the Steam client
-	virtual bool RequestCurrentStats() = 0;
+	// The game stats and achievements will be synchronized with Steam before
+	// the game process begins.
+	// virtual bool RequestCurrentStats() = 0;
 
 	// Data accessors
 	STEAM_FLAT_NAME( GetStatInt32 )
@@ -303,7 +305,7 @@ public:
 
 };
 
-#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION012"
+#define STEAMUSERSTATS_INTERFACE_VERSION "STEAMUSERSTATS_INTERFACE_VERSION013"
 
 // Global interface accessor
 inline ISteamUserStats *SteamUserStats();

Generator/steam_sdk/isteamutils.h

@@ -215,6 +215,9 @@ public:
 
 	// Dismisses the floating keyboard.
 	virtual bool DismissFloatingGamepadTextInput() = 0;
+
+	// Dismisses the full-screen text input dialog.
+	virtual bool DismissGamepadTextInput() = 0;
 };
 
 #define STEAMUTILS_INTERFACE_VERSION "SteamUtils010"
@@ -246,7 +249,7 @@ struct IPCountry_t
 
 
 //-----------------------------------------------------------------------------
-// Purpose: Fired when running on a laptop and less than 10 minutes of battery is left, fires then every minute
+// Purpose: Fired when running on a handheld PC or laptop with less than 10 minutes of battery is left, fires then every minute
 //-----------------------------------------------------------------------------
 struct LowBatteryPower_t
 {

Generator/steam_sdk/isteamvideo.h

@@ -21,9 +21,6 @@
 #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
 #endif
 
-
-
-
 //-----------------------------------------------------------------------------
 // Purpose: Steam Video API
 //-----------------------------------------------------------------------------
@@ -41,9 +38,11 @@ public:
 	STEAM_CALL_BACK( GetOPFSettingsResult_t )
 	virtual void GetOPFSettings( AppId_t unVideoAppID ) = 0;
 	virtual bool GetOPFStringForApp( AppId_t unVideoAppID, char *pchBuffer, int32 *pnBufferSize ) = 0;
+
+
 };
 
-#define STEAMVIDEO_INTERFACE_VERSION "STEAMVIDEO_INTERFACE_V002"
+#define STEAMVIDEO_INTERFACE_VERSION "STEAMVIDEO_INTERFACE_V007"
 
 // Global interface accessor
 inline ISteamVideo *SteamVideo();
@@ -61,6 +60,13 @@ STEAM_CALLBACK_BEGIN( GetOPFSettingsResult_t, k_iSteamVideoCallbacks + 24 )
 	STEAM_CALLBACK_MEMBER( 1, AppId_t, m_unVideoAppID )
 STEAM_CALLBACK_END(2)
 
+STEAM_CALLBACK_BEGIN( BroadcastUploadStart_t, k_iSteamVideoCallbacks + 4 )
+	STEAM_CALLBACK_MEMBER( 0, bool, m_bIsRTMP )
+STEAM_CALLBACK_END( 1 )
+
+STEAM_CALLBACK_BEGIN( BroadcastUploadStop_t, k_iSteamVideoCallbacks + 5 )
+	STEAM_CALLBACK_MEMBER( 0, EBroadcastUploadResult, m_eResult )
+STEAM_CALLBACK_END( 1 )
 
 #pragma pack( pop )
 

Generator/steam_sdk/steam_api.h

@@ -36,9 +36,9 @@
 #include "isteamhttp.h"
 #include "isteamcontroller.h"
 #include "isteamugc.h"
-#include "isteamapplist.h"
 #include "isteamhtmlsurface.h"
 #include "isteaminventory.h"
+#include "isteamtimeline.h"
 #include "isteamvideo.h"
 #include "isteamparentalsettings.h"
 #include "isteaminput.h"
@@ -55,10 +55,54 @@
 //
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
 
+enum ESteamAPIInitResult
+{
+	k_ESteamAPIInitResult_OK = 0,
+	k_ESteamAPIInitResult_FailedGeneric = 1, // Some other failure
+	k_ESteamAPIInitResult_NoSteamClient = 2, // We cannot connect to Steam, steam probably isn't running
+	k_ESteamAPIInitResult_VersionMismatch = 3, // Steam client appears to be out of date
+};
 
-// SteamAPI_Init must be called before using any other API functions. If it fails, an
+// Initializing the Steamworks SDK
-// error message will be output to the debugger (or stderr) with further information.
+// -----------------------------
-S_API bool S_CALLTYPE SteamAPI_Init();
+// 
+// There are three different methods you can use to initialize the Steamworks SDK, depending on
+// your project's environment. You should only use one method in your project.
+// 
+// If you are able to include this C++ header in your project, we recommend using the following
+// initialization methods. They will ensure that all ISteam* interfaces defined in other
+// C++ header files have versions that are supported by the user's Steam Client:
+// - SteamAPI_InitEx() for new projects so you can show a detailed error message to the user
+// - SteamAPI_Init() for existing projects that only display a generic error message
+// 
+// If you are unable to include this C++ header in your project and are dynamically loading
+// Steamworks SDK methods from dll/so, you can use the following method:
+// - SteamAPI_InitFlat()
+
+
+// See "Initializing the Steamworks SDK" above for how to choose an init method.
+// On success k_ESteamAPIInitResult_OK is returned. Otherwise, returns a value that can be used
+// to create a localized error message for the user. If pOutErrMsg is non-NULL,
+// it will receive an example error message, in English, that explains the reason for the failure.
+//
+// Example usage:
+// 
+//   SteamErrMsg errMsg;
+//   if ( SteamAPI_Init(&errMsg) != k_ESteamAPIInitResult_OK )
+//       FatalError( "Failed to init Steam.  %s", errMsg );
+inline ESteamAPIInitResult SteamAPI_InitEx( SteamErrMsg *pOutErrMsg );
+
+// See "Initializing the Steamworks SDK" above for how to choose an init method.
+// Returns true on success
+inline bool SteamAPI_Init()
+{
+	return SteamAPI_InitEx( NULL ) == k_ESteamAPIInitResult_OK;
+}
+
+// See "Initializing the Steamworks SDK" above for how to choose an init method.
+// Same usage as SteamAPI_InitEx(), however does not verify ISteam* interfaces are
+// supported by the user's client and is exported from the dll
+S_API ESteamAPIInitResult S_CALLTYPE SteamAPI_InitFlat( SteamErrMsg *pOutErrMsg );
 
 // SteamAPI_Shutdown should be called during process shutdown if possible.
 S_API void S_CALLTYPE SteamAPI_Shutdown();
@@ -181,117 +225,42 @@ S_API void S_CALLTYPE SteamAPI_ManualDispatch_FreeLastCallback( HSteamPipe hStea
 /// only call this in a handler for SteamAPICallCompleted_t callback.
 S_API bool S_CALLTYPE SteamAPI_ManualDispatch_GetAPICallResult( HSteamPipe hSteamPipe, SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed );
 
-//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// Internal implementation of SteamAPI_InitEx.  This is done in a way that checks
-//
+// all of the versions of interfaces from headers being compiled into this code.
-// CSteamAPIContext
+S_API ESteamAPIInitResult S_CALLTYPE SteamInternal_SteamAPI_Init( const char *pszInternalCheckInterfaceVersions, SteamErrMsg *pOutErrMsg );
-//
+inline ESteamAPIInitResult SteamAPI_InitEx( SteamErrMsg *pOutErrMsg )
-// Deprecated!  This is not necessary any more.  Please use the global accessors directly
-//
-//----------------------------------------------------------------------------------------------------------------------------------------------------------//
-
-#ifndef STEAM_API_EXPORTS
-
-inline bool CSteamAPIContext::Init()
 {
-	m_pSteamClient = ::SteamClient();
+	const char *pszInternalCheckInterfaceVersions = 
-	if ( !m_pSteamClient )
+		STEAMUTILS_INTERFACE_VERSION "\0"
-		return false;
+		STEAMNETWORKINGUTILS_INTERFACE_VERSION "\0"
+		STEAMAPPS_INTERFACE_VERSION "\0"
+		STEAMCONTROLLER_INTERFACE_VERSION "\0"
+		STEAMFRIENDS_INTERFACE_VERSION "\0"
+		STEAMGAMESEARCH_INTERFACE_VERSION "\0"
+		STEAMHTMLSURFACE_INTERFACE_VERSION "\0"
+		STEAMHTTP_INTERFACE_VERSION "\0"
+		STEAMINPUT_INTERFACE_VERSION "\0"
+		STEAMINVENTORY_INTERFACE_VERSION "\0"
+		STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION "\0"
+		STEAMMATCHMAKING_INTERFACE_VERSION "\0"
+		STEAMMUSICREMOTE_INTERFACE_VERSION "\0"
+		STEAMMUSIC_INTERFACE_VERSION "\0"
+		STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "\0"
+		STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "\0"
+		STEAMNETWORKING_INTERFACE_VERSION "\0"
+		STEAMPARENTALSETTINGS_INTERFACE_VERSION "\0"
+		STEAMPARTIES_INTERFACE_VERSION "\0"
+		STEAMREMOTEPLAY_INTERFACE_VERSION "\0"
+		STEAMREMOTESTORAGE_INTERFACE_VERSION "\0"
+		STEAMSCREENSHOTS_INTERFACE_VERSION "\0"
+		STEAMUGC_INTERFACE_VERSION "\0"
+		STEAMUSERSTATS_INTERFACE_VERSION "\0"
+		STEAMUSER_INTERFACE_VERSION "\0"
+		STEAMVIDEO_INTERFACE_VERSION "\0"
 
-	m_pSteamUser = ::SteamUser();
+		"\0";
-	if ( !m_pSteamUser )
-		return false;
 
-	m_pSteamFriends = ::SteamFriends();
+	return SteamInternal_SteamAPI_Init( pszInternalCheckInterfaceVersions, pOutErrMsg );
-	if ( !m_pSteamFriends )
-		return false;
-
-	m_pSteamUtils = ::SteamUtils();
-	if ( !m_pSteamUtils )
-		return false;
-
-	m_pSteamMatchmaking = ::SteamMatchmaking();
-	if ( !m_pSteamMatchmaking )
-		return false;
-
-	m_pSteamGameSearch = ::SteamGameSearch();
-	if ( !m_pSteamGameSearch )
-		return false;
-
-#if !defined( IOSALL) // Not yet supported on iOS.
-	m_pSteamMatchmakingServers = ::SteamMatchmakingServers();
-	if ( !m_pSteamMatchmakingServers )
-		return false;
-#endif
-
-	m_pSteamUserStats = ::SteamUserStats();
-	if ( !m_pSteamUserStats )
-		return false;
-
-	m_pSteamApps = ::SteamApps();
-	if ( !m_pSteamApps )
-		return false;
-
-	m_pSteamNetworking = ::SteamNetworking();
-	if ( !m_pSteamNetworking )
-		return false;
-
-	m_pSteamRemoteStorage = ::SteamRemoteStorage();
-	if ( !m_pSteamRemoteStorage )
-		return false;
-
-	m_pSteamScreenshots = ::SteamScreenshots();
-	if ( !m_pSteamScreenshots )
-		return false;
-
-	m_pSteamHTTP = ::SteamHTTP();
-	if ( !m_pSteamHTTP )
-		return false;
-
-	m_pController = ::SteamController();
-	if ( !m_pController )
-		return false;
-
-	m_pSteamUGC = ::SteamUGC();
-	if ( !m_pSteamUGC )
-		return false;
-
-	m_pSteamAppList = ::SteamAppList();
-	if ( !m_pSteamAppList )
-		return false;
-
-	m_pSteamMusic = ::SteamMusic();
-	if ( !m_pSteamMusic )
-		return false;
-
-	m_pSteamMusicRemote = ::SteamMusicRemote();
-	if ( !m_pSteamMusicRemote )
-		return false;
-
-#if !defined( ANDROID ) && !defined( IOSALL) // Not yet supported on Android or ios.
-	m_pSteamHTMLSurface = ::SteamHTMLSurface();
-	if ( !m_pSteamHTMLSurface )
-	return false;
-#endif
-
-	m_pSteamInventory = ::SteamInventory();
-	if ( !m_pSteamInventory )
-		return false;
-
-	m_pSteamVideo = ::SteamVideo();
-	if ( !m_pSteamVideo )
-		return false;
-
-	m_pSteamParentalSettings = ::SteamParentalSettings();
-	if ( !m_pSteamParentalSettings )
-		return false;
-
-	m_pSteamInput = ::SteamInput();
-	if ( !m_pSteamInput )
-		return false;
-
-	return true;
 }
 
-#endif
-
 #endif // STEAM_API_H

Generator/steam_sdk/steam_api.json

@@ -148,7 +148,8 @@
       "fields": [
         { "fieldname":"m_bActive", "fieldtype":"uint8" },
         { "fieldname":"m_bUserInitiated", "fieldtype":"bool" },
-        { "fieldname":"m_nAppID", "fieldtype":"AppId_t" }
+        { "fieldname":"m_nAppID", "fieldtype":"AppId_t" },
+        { "fieldname":"m_dwOverlayPID", "fieldtype":"uint32" }
       ],
       "struct": "GameOverlayActivated_t"
     },
@@ -318,7 +319,8 @@
         { "fieldname":"m_bHasAvatarFrame", "fieldtype":"bool" },
         { "fieldname":"m_bHasProfileModifier", "fieldtype":"bool" },
         { "fieldname":"m_bHasProfileBackground", "fieldtype":"bool" },
-        { "fieldname":"m_bHasMiniProfileBackground", "fieldtype":"bool" }
+        { "fieldname":"m_bHasMiniProfileBackground", "fieldtype":"bool" },
+        { "fieldname":"m_bFromCache", "fieldtype":"bool" }
       ],
       "struct": "EquippedProfileItems_t"
     },
@@ -1264,7 +1266,9 @@
       "callback_id": 3405,
       "fields": [
         { "fieldname":"m_unAppID", "fieldtype":"AppId_t" },
-        { "fieldname":"m_nPublishedFileId", "fieldtype":"PublishedFileId_t" }
+        { "fieldname":"m_nPublishedFileId", "fieldtype":"PublishedFileId_t" },
+        { "fieldname":"m_hLegacyContent", "fieldtype":"UGCHandle_t" },
+        { "fieldname":"m_unManifestID", "fieldtype":"uint64" }
       ],
       "struct": "ItemInstalled_t"
     },
@@ -1394,22 +1398,6 @@
       ],
       "struct": "WorkshopEULAStatus_t"
     },
-    {
-      "callback_id": 3901,
-      "fields": [
-        { "fieldname":"m_nAppID", "fieldtype":"AppId_t" },
-        { "fieldname":"m_iInstallFolderIndex", "fieldtype":"int" }
-      ],
-      "struct": "SteamAppInstalled_t"
-    },
-    {
-      "callback_id": 3902,
-      "fields": [
-        { "fieldname":"m_nAppID", "fieldtype":"AppId_t" },
-        { "fieldname":"m_iInstallFolderIndex", "fieldtype":"int" }
-      ],
-      "struct": "SteamAppUninstalled_t"
-    },
     {
       "callback_id": 4501,
       "fields": [
@@ -1676,6 +1664,25 @@
       ],
       "struct": "SteamInventoryRequestPricesResult_t"
     },
+    {
+      "callback_id": 6001,
+      "fields": [
+        { "fieldname":"m_rgchPhaseID", "fieldtype":"char [64]" },
+        { "fieldname":"m_ulRecordingMS", "fieldtype":"uint64" },
+        { "fieldname":"m_ulLongestClipMS", "fieldtype":"uint64" },
+        { "fieldname":"m_unClipCount", "fieldtype":"uint32" },
+        { "fieldname":"m_unScreenshotCount", "fieldtype":"uint32" }
+      ],
+      "struct": "SteamTimelineGamePhaseRecordingExists_t"
+    },
+    {
+      "callback_id": 6002,
+      "fields": [
+        { "fieldname":"m_ulEventID", "fieldtype":"uint64" },
+        { "fieldname":"m_bRecordingExists", "fieldtype":"bool" }
+      ],
+      "struct": "SteamTimelineEventRecordingExists_t"
+    },
     {
       "callback_id": 4611,
       "fields": [
@@ -1693,6 +1700,20 @@
       ],
       "struct": "GetOPFSettingsResult_t"
     },
+    {
+      "callback_id": 4604,
+      "fields": [
+        { "fieldname":"m_bIsRTMP", "fieldtype":"bool" }
+      ],
+      "struct": "BroadcastUploadStart_t"
+    },
+    {
+      "callback_id": 4605,
+      "fields": [
+        { "fieldname":"m_eResult", "fieldtype":"EBroadcastUploadResult" }
+      ],
+      "struct": "BroadcastUploadStop_t"
+    },
     {
       "callback_id": 5001,
       "fields": [],
@@ -1894,16 +1915,20 @@
     { "constname":"k_uAppIdInvalid", "consttype":"AppId_t", "constval":"0x0" },
     { "constname":"k_uDepotIdInvalid", "consttype":"DepotId_t", "constval":"0x0" },
     { "constname":"k_uAPICallInvalid", "consttype":"SteamAPICall_t", "constval":"0x0" },
+    { "constname":"k_uAccountIdInvalid", "consttype":"AccountID_t", "constval":"0" },
     { "constname":"k_ulPartyBeaconIdInvalid", "consttype":"PartyBeaconID_t", "constval":"0" },
     { "constname":"k_HAuthTicketInvalid", "consttype":"HAuthTicket", "constval":"0" },
     { "constname":"k_unSteamAccountIDMask", "consttype":"unsigned int", "constval":"0xFFFFFFFF" },
     { "constname":"k_unSteamAccountInstanceMask", "consttype":"unsigned int", "constval":"0x000FFFFF" },
     { "constname":"k_unSteamUserDefaultInstance", "consttype":"unsigned int", "constval":"1" },
     { "constname":"k_cchGameExtraInfoMax", "consttype":"int", "constval":"64" },
+    { "constname":"k_cchMaxSteamErrMsg", "consttype":"int", "constval":"1024" },
     { "constname":"k_cchMaxFriendsGroupName", "consttype":"int", "constval":"64" },
     { "constname":"k_cFriendsGroupLimit", "consttype":"int", "constval":"100" },
     { "constname":"k_FriendsGroupID_Invalid", "consttype":"FriendsGroupID_t", "constval":"- 1" },
     { "constname":"k_cEnumerateFollowersMax", "consttype":"int", "constval":"50" },
+    { "constname":"k_usFriendGameInfoQueryPort_NotInitialized", "consttype":"uint16", "constval":"0xFFFF" },
+    { "constname":"k_usFriendGameInfoQueryPort_Error", "consttype":"uint16", "constval":"0xFFFE" },
     { "constname":"k_cubChatMetadataMax", "consttype":"uint32", "constval":"8192" },
     { "constname":"k_cbMaxGameServerGameDir", "consttype":"int", "constval":"32" },
     { "constname":"k_cbMaxGameServerMapName", "consttype":"int", "constval":"32" },
@@ -1941,6 +1966,10 @@
     { "constname":"k_SteamItemInstanceIDInvalid", "consttype":"SteamItemInstanceID_t", "constval":"( SteamItemInstanceID_t ) ~ 0" },
     { "constname":"k_SteamInventoryResultInvalid", "consttype":"SteamInventoryResult_t", "constval":"- 1" },
     { "constname":"k_SteamInventoryUpdateHandleInvalid", "consttype":"SteamInventoryUpdateHandle_t", "constval":"0xffffffffffffffffull" },
+    { "constname":"k_unMaxTimelinePriority", "consttype":"uint32", "constval":"1000" },
+    { "constname":"k_unTimelinePriority_KeepCurrentValue", "consttype":"uint32", "constval":"1000000" },
+    { "constname":"k_flMaxTimelineEventDuration", "consttype":"float", "constval":"600.f" },
+    { "constname":"k_cchMaxPhaseIDLength", "consttype":"uint32", "constval":"64" },
     { "constname":"k_HSteamNetConnection_Invalid", "consttype":"HSteamNetConnection", "constval":"0" },
     { "constname":"k_HSteamListenSocket_Invalid", "consttype":"HSteamListenSocket", "constval":"0" },
     { "constname":"k_HSteamNetPollGroup_Invalid", "consttype":"HSteamNetPollGroup", "constval":"0" },
@@ -2130,7 +2159,10 @@
         { "name":"k_EResultInsufficientBattery", "value":"124" },
         { "name":"k_EResultChargerRequired", "value":"125" },
         { "name":"k_EResultCachedCredentialInvalid", "value":"126" },
-        { "name":"K_EResultPhoneNumberIsVOIP", "value":"127" }
+        { "name":"K_EResultPhoneNumberIsVOIP", "value":"127" },
+        { "name":"k_EResultNotSupported", "value":"128" },
+        { "name":"k_EResultFamilySizeLimitExceeded", "value":"129" },
+        { "name":"k_EResultOfflineAppCacheInvalid", "value":"130" }
       ]
     },
     {
@@ -2358,6 +2390,17 @@
         { "name":"k_EDurationControlOnlineState_OnlineHighPri", "value":"3" }
       ]
     },
+    {
+      "enumname": "EBetaBranchFlags",
+      "values": [
+        { "name":"k_EBetaBranch_None", "value":"0" },
+        { "name":"k_EBetaBranch_Default", "value":"1" },
+        { "name":"k_EBetaBranch_Available", "value":"2" },
+        { "name":"k_EBetaBranch_Private", "value":"4" },
+        { "name":"k_EBetaBranch_Selected", "value":"8" },
+        { "name":"k_EBetaBranch_Installed", "value":"16" }
+      ]
+    },
     {
       "enumname": "EGameSearchErrorCode_t",
       "values": [
@@ -2679,7 +2722,8 @@
         { "name":"k_EWorkshopFileTypeSteamworksAccessInvite", "value":"13" },
         { "name":"k_EWorkshopFileTypeSteamVideo", "value":"14" },
         { "name":"k_EWorkshopFileTypeGameManagedItem", "value":"15" },
-        { "name":"k_EWorkshopFileTypeMax", "value":"16" }
+        { "name":"k_EWorkshopFileTypeClip", "value":"16" },
+        { "name":"k_EWorkshopFileTypeMax", "value":"17" }
       ]
     },
     {
@@ -3334,7 +3378,11 @@
         { "name":"k_EInputActionOrigin_SteamDeck_Reserved18", "value":"403" },
         { "name":"k_EInputActionOrigin_SteamDeck_Reserved19", "value":"404" },
         { "name":"k_EInputActionOrigin_SteamDeck_Reserved20", "value":"405" },
-        { "name":"k_EInputActionOrigin_Count", "value":"406" },
+        { "name":"k_EInputActionOrigin_Horipad_M1", "value":"406" },
+        { "name":"k_EInputActionOrigin_Horipad_M2", "value":"407" },
+        { "name":"k_EInputActionOrigin_Horipad_L4", "value":"408" },
+        { "name":"k_EInputActionOrigin_Horipad_R4", "value":"409" },
+        { "name":"k_EInputActionOrigin_Count", "value":"410" },
         { "name":"k_EInputActionOrigin_MaximumPossibleValue", "value":"32767" }
       ]
     },
@@ -3849,7 +3897,11 @@
         { "name":"k_EControllerActionOrigin_PS5_RightGrip", "value":"383" },
         { "name":"k_EControllerActionOrigin_PS5_LeftFn", "value":"384" },
         { "name":"k_EControllerActionOrigin_PS5_RightFn", "value":"385" },
-        { "name":"k_EControllerActionOrigin_Count", "value":"386" },
+        { "name":"k_EControllerActionOrigin_Horipad_M1", "value":"386" },
+        { "name":"k_EControllerActionOrigin_Horipad_M2", "value":"387" },
+        { "name":"k_EControllerActionOrigin_Horipad_L4", "value":"388" },
+        { "name":"k_EControllerActionOrigin_Horipad_R4", "value":"389" },
+        { "name":"k_EControllerActionOrigin_Count", "value":"390" },
         { "name":"k_EControllerActionOrigin_MaximumPossibleValue", "value":"32767" }
       ]
     },
@@ -3950,7 +4002,8 @@
         { "name":"k_EItemStateInstalled", "value":"4" },
         { "name":"k_EItemStateNeedsUpdate", "value":"8" },
         { "name":"k_EItemStateDownloading", "value":"16" },
-        { "name":"k_EItemStateDownloadPending", "value":"32" }
+        { "name":"k_EItemStateDownloadPending", "value":"32" },
+        { "name":"k_EItemStateDisabledLocally", "value":"64" }
       ]
     },
     {
@@ -3979,6 +4032,7 @@
         { "name":"k_EItemPreviewType_Sketchfab", "value":"2" },
         { "name":"k_EItemPreviewType_EnvironmentMap_HorizontalCross", "value":"3" },
         { "name":"k_EItemPreviewType_EnvironmentMap_LatLong", "value":"4" },
+        { "name":"k_EItemPreviewType_Clip", "value":"5" },
         { "name":"k_EItemPreviewType_ReservedMax", "value":"255" }
       ]
     },
@@ -4000,6 +4054,26 @@
         { "name":"k_ESteamItemConsumed", "value":"512" }
       ]
     },
+    {
+      "enumname": "ETimelineGameMode",
+      "values": [
+        { "name":"k_ETimelineGameMode_Invalid", "value":"0" },
+        { "name":"k_ETimelineGameMode_Playing", "value":"1" },
+        { "name":"k_ETimelineGameMode_Staging", "value":"2" },
+        { "name":"k_ETimelineGameMode_Menus", "value":"3" },
+        { "name":"k_ETimelineGameMode_LoadingScreen", "value":"4" },
+        { "name":"k_ETimelineGameMode_Max", "value":"5" }
+      ]
+    },
+    {
+      "enumname": "ETimelineEventClipPriority",
+      "values": [
+        { "name":"k_ETimelineEventClipPriority_Invalid", "value":"0" },
+        { "name":"k_ETimelineEventClipPriority_None", "value":"1" },
+        { "name":"k_ETimelineEventClipPriority_Standard", "value":"2" },
+        { "name":"k_ETimelineEventClipPriority_Featured", "value":"3" }
+      ]
+    },
     {
       "enumname": "EParentalFeature",
       "values": [
@@ -4017,8 +4091,9 @@
         { "name":"k_EFeatureLibrary", "value":"11" },
         { "name":"k_EFeatureTest", "value":"12" },
         { "name":"k_EFeatureSiteLicense", "value":"13" },
-        { "name":"k_EFeatureKioskMode", "value":"14" },
+        { "name":"k_EFeatureKioskMode_Deprecated", "value":"14" },
-        { "name":"k_EFeatureMax", "value":"15" }
+        { "name":"k_EFeatureBlockAlways", "value":"15" },
+        { "name":"k_EFeatureMax", "value":"16" }
       ]
     },
     {
@@ -4028,7 +4103,8 @@
         { "name":"k_ESteamDeviceFormFactorPhone", "value":"1" },
         { "name":"k_ESteamDeviceFormFactorTablet", "value":"2" },
         { "name":"k_ESteamDeviceFormFactorComputer", "value":"3" },
-        { "name":"k_ESteamDeviceFormFactorTV", "value":"4" }
+        { "name":"k_ESteamDeviceFormFactorTV", "value":"4" },
+        { "name":"k_ESteamDeviceFormFactorVRHeadset", "value":"5" }
       ]
     },
     {
@@ -4053,7 +4129,6 @@
         { "name":"k_ESteamNetworkingIdentityType_SteamID", "value":"16" },
         { "name":"k_ESteamNetworkingIdentityType_XboxPairwiseID", "value":"17" },
         { "name":"k_ESteamNetworkingIdentityType_SonyPSN", "value":"18" },
-        { "name":"k_ESteamNetworkingIdentityType_GoogleStadia", "value":"19" },
         { "name":"k_ESteamNetworkingIdentityType_IPAddress", "value":"1" },
         { "name":"k_ESteamNetworkingIdentityType_GenericString", "value":"2" },
         { "name":"k_ESteamNetworkingIdentityType_GenericBytes", "value":"3" },
@@ -4152,11 +4227,16 @@
         { "name":"k_ESteamNetworkingConfig_TimeoutInitial", "value":"24" },
         { "name":"k_ESteamNetworkingConfig_TimeoutConnected", "value":"25" },
         { "name":"k_ESteamNetworkingConfig_SendBufferSize", "value":"9" },
+        { "name":"k_ESteamNetworkingConfig_RecvBufferSize", "value":"47" },
+        { "name":"k_ESteamNetworkingConfig_RecvBufferMessages", "value":"48" },
+        { "name":"k_ESteamNetworkingConfig_RecvMaxMessageSize", "value":"49" },
+        { "name":"k_ESteamNetworkingConfig_RecvMaxSegmentsPerPacket", "value":"50" },
         { "name":"k_ESteamNetworkingConfig_ConnectionUserData", "value":"40" },
         { "name":"k_ESteamNetworkingConfig_SendRateMin", "value":"10" },
         { "name":"k_ESteamNetworkingConfig_SendRateMax", "value":"11" },
         { "name":"k_ESteamNetworkingConfig_NagleTime", "value":"12" },
         { "name":"k_ESteamNetworkingConfig_IP_AllowWithoutAuth", "value":"23" },
+        { "name":"k_ESteamNetworkingConfig_IPLocalHost_AllowWithoutAuth", "value":"52" },
         { "name":"k_ESteamNetworkingConfig_MTU_PacketSize", "value":"32" },
         { "name":"k_ESteamNetworkingConfig_MTU_DataSize", "value":"33" },
         { "name":"k_ESteamNetworkingConfig_Unencrypted", "value":"34" },
@@ -4164,10 +4244,17 @@
         { "name":"k_ESteamNetworkingConfig_LocalVirtualPort", "value":"38" },
         { "name":"k_ESteamNetworkingConfig_DualWifi_Enable", "value":"39" },
         { "name":"k_ESteamNetworkingConfig_EnableDiagnosticsUI", "value":"46" },
+        { "name":"k_ESteamNetworkingConfig_SendTimeSincePreviousPacket", "value":"59" },
         { "name":"k_ESteamNetworkingConfig_FakePacketLoss_Send", "value":"2" },
         { "name":"k_ESteamNetworkingConfig_FakePacketLoss_Recv", "value":"3" },
         { "name":"k_ESteamNetworkingConfig_FakePacketLag_Send", "value":"4" },
         { "name":"k_ESteamNetworkingConfig_FakePacketLag_Recv", "value":"5" },
+        { "name":"k_ESteamNetworkingConfig_FakePacketJitter_Send_Avg", "value":"53" },
+        { "name":"k_ESteamNetworkingConfig_FakePacketJitter_Send_Max", "value":"54" },
+        { "name":"k_ESteamNetworkingConfig_FakePacketJitter_Send_Pct", "value":"55" },
+        { "name":"k_ESteamNetworkingConfig_FakePacketJitter_Recv_Avg", "value":"56" },
+        { "name":"k_ESteamNetworkingConfig_FakePacketJitter_Recv_Max", "value":"57" },
+        { "name":"k_ESteamNetworkingConfig_FakePacketJitter_Recv_Pct", "value":"58" },
         { "name":"k_ESteamNetworkingConfig_FakePacketReorder_Send", "value":"6" },
         { "name":"k_ESteamNetworkingConfig_FakePacketReorder_Recv", "value":"7" },
         { "name":"k_ESteamNetworkingConfig_FakePacketReorder_Time", "value":"8" },
@@ -4179,6 +4266,7 @@
         { "name":"k_ESteamNetworkingConfig_FakeRateLimit_Send_Burst", "value":"43" },
         { "name":"k_ESteamNetworkingConfig_FakeRateLimit_Recv_Rate", "value":"44" },
         { "name":"k_ESteamNetworkingConfig_FakeRateLimit_Recv_Burst", "value":"45" },
+        { "name":"k_ESteamNetworkingConfig_OutOfOrderCorrectionWindowMicroseconds", "value":"51" },
         { "name":"k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged", "value":"201" },
         { "name":"k_ESteamNetworkingConfig_Callback_AuthStatusChanged", "value":"202" },
         { "name":"k_ESteamNetworkingConfig_Callback_RelayNetworkStatusChanged", "value":"203" },
@@ -4199,15 +4287,17 @@
         { "name":"k_ESteamNetworkingConfig_SDRClient_MinPingsBeforePingAccurate", "value":"21" },
         { "name":"k_ESteamNetworkingConfig_SDRClient_SingleSocket", "value":"22" },
         { "name":"k_ESteamNetworkingConfig_SDRClient_ForceRelayCluster", "value":"29" },
-        { "name":"k_ESteamNetworkingConfig_SDRClient_DebugTicketAddress", "value":"30" },
+        { "name":"k_ESteamNetworkingConfig_SDRClient_DevTicket", "value":"30" },
         { "name":"k_ESteamNetworkingConfig_SDRClient_ForceProxyAddr", "value":"31" },
         { "name":"k_ESteamNetworkingConfig_SDRClient_FakeClusterPing", "value":"36" },
+        { "name":"k_ESteamNetworkingConfig_SDRClient_LimitPingProbesToNearestN", "value":"60" },
         { "name":"k_ESteamNetworkingConfig_LogLevel_AckRTT", "value":"13" },
         { "name":"k_ESteamNetworkingConfig_LogLevel_PacketDecode", "value":"14" },
         { "name":"k_ESteamNetworkingConfig_LogLevel_Message", "value":"15" },
         { "name":"k_ESteamNetworkingConfig_LogLevel_PacketGaps", "value":"16" },
         { "name":"k_ESteamNetworkingConfig_LogLevel_P2PRendezvous", "value":"17" },
         { "name":"k_ESteamNetworkingConfig_LogLevel_SDRRelayPings", "value":"18" },
+        { "name":"k_ESteamNetworkingConfig_ECN", "value":"999" },
         { "name":"k_ESteamNetworkingConfig_DELETED_EnumerateDevVars", "value":"35" },
         { "name":"k_ESteamNetworkingConfigValue__Force32Bit", "value":"2147483647" }
       ]
@@ -4238,6 +4328,15 @@
         { "name":"k_ESteamNetworkingSocketsDebugOutputType__Force32Bit", "value":"2147483647" }
       ]
     },
+    {
+      "enumname": "ESteamAPIInitResult",
+      "values": [
+        { "name":"k_ESteamAPIInitResult_OK", "value":"0" },
+        { "name":"k_ESteamAPIInitResult_FailedGeneric", "value":"1" },
+        { "name":"k_ESteamAPIInitResult_NoSteamClient", "value":"2" },
+        { "name":"k_ESteamAPIInitResult_VersionMismatch", "value":"3" }
+      ]
+    },
     {
       "enumname": "EServerMode",
       "values": [
@@ -4491,16 +4590,6 @@
           ],
           "returntype": "ISteamUGC *"
         },
-        {
-          "methodname": "GetISteamAppList",
-          "methodname_flat": "SteamAPI_ISteamClient_GetISteamAppList",
-          "params": [
-            { "paramname":"hSteamUser", "paramtype":"HSteamUser" },
-            { "paramname":"hSteamPipe", "paramtype":"HSteamPipe" },
-            { "paramname":"pchVersion", "paramtype":"const char *" }
-          ],
-          "returntype": "ISteamAppList *"
-        },
         {
           "methodname": "GetISteamMusic",
           "methodname_flat": "SteamAPI_ISteamClient_GetISteamMusic",
@@ -5882,6 +5971,12 @@
           "methodname_flat": "SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput",
           "params": [],
           "returntype": "bool"
+        },
+        {
+          "methodname": "DismissGamepadTextInput",
+          "methodname_flat": "SteamAPI_ISteamUtils_DismissGamepadTextInput",
+          "params": [],
+          "returntype": "bool"
         }
       ],
       "version_string": "SteamUtils010"
@@ -7407,19 +7502,12 @@
         {
           "kind": "user",
           "name": "SteamUserStats",
-          "name_flat": "SteamAPI_SteamUserStats_v012"
+          "name_flat": "SteamAPI_SteamUserStats_v013"
         }
       ],
       "classname": "ISteamUserStats",
       "fields": [],
       "methods": [
-        {
-          "callback": "UserStatsReceived_t",
-          "methodname": "RequestCurrentStats",
-          "methodname_flat": "SteamAPI_ISteamUserStats_RequestCurrentStats",
-          "params": [],
-          "returntype": "bool"
-        },
         {
           "methodname": "GetStat",
           "methodname_flat": "SteamAPI_ISteamUserStats_GetStatInt32",
@@ -7843,7 +7931,7 @@
           "returntype": "bool"
         }
       ],
-      "version_string": "STEAMUSERSTATS_INTERFACE_VERSION012"
+      "version_string": "STEAMUSERSTATS_INTERFACE_VERSION013"
     },
     {
       "accessors": [
@@ -8086,6 +8174,37 @@
             { "paramname":"nAppID", "paramtype":"AppId_t" }
           ],
           "returntype": "bool"
+        },
+        {
+          "methodname": "GetNumBetas",
+          "methodname_flat": "SteamAPI_ISteamApps_GetNumBetas",
+          "params": [
+            { "paramname":"pnAvailable", "paramtype":"int *" },
+            { "paramname":"pnPrivate", "paramtype":"int *" }
+          ],
+          "returntype": "int"
+        },
+        {
+          "methodname": "GetBetaInfo",
+          "methodname_flat": "SteamAPI_ISteamApps_GetBetaInfo",
+          "params": [
+            { "paramname":"iBetaIndex", "paramtype":"int" },
+            { "paramname":"punFlags", "paramtype":"uint32 *" },
+            { "paramname":"punBuildID", "paramtype":"uint32 *" },
+            { "paramname":"pchBetaName", "paramtype":"char *" },
+            { "paramname":"cchBetaName", "paramtype":"int" },
+            { "paramname":"pchDescription", "paramtype":"char *" },
+            { "paramname":"cchDescription", "paramtype":"int" }
+          ],
+          "returntype": "bool"
+        },
+        {
+          "methodname": "SetActiveBeta",
+          "methodname_flat": "SteamAPI_ISteamApps_SetActiveBeta",
+          "params": [
+            { "paramname":"pchBetaName", "paramtype":"const char *" }
+          ],
+          "returntype": "bool"
         }
       ],
       "version_string": "STEAMAPPS_INTERFACE_VERSION008"
@@ -9786,12 +9905,12 @@
         {
           "kind": "user",
           "name": "SteamUGC",
-          "name_flat": "SteamAPI_SteamUGC_v017"
+          "name_flat": "SteamAPI_SteamUGC_v020"
         },
         {
           "kind": "gameserver",
           "name": "SteamGameServerUGC",
-          "name_flat": "SteamAPI_SteamGameServerUGC_v017"
+          "name_flat": "SteamAPI_SteamGameServerUGC_v020"
         }
       ],
       "classname": "ISteamUGC",
@@ -9979,7 +10098,7 @@
             },
             { "paramname":"cchURLSize", "paramtype":"uint32" },
             {
-              "out_string_count": "cchURLSize",
+              "out_string_count": "cchOriginalFileNameSize",
               "paramname": "pchOriginalFileName",
               "paramtype": "char *"
             },
@@ -10035,6 +10154,36 @@
           ],
           "returntype": "bool"
         },
+        {
+          "methodname": "GetNumSupportedGameVersions",
+          "methodname_flat": "SteamAPI_ISteamUGC_GetNumSupportedGameVersions",
+          "params": [
+            { "paramname":"handle", "paramtype":"UGCQueryHandle_t" },
+            { "paramname":"index", "paramtype":"uint32" }
+          ],
+          "returntype": "uint32"
+        },
+        {
+          "methodname": "GetSupportedGameVersionData",
+          "methodname_flat": "SteamAPI_ISteamUGC_GetSupportedGameVersionData",
+          "params": [
+            { "paramname":"handle", "paramtype":"UGCQueryHandle_t" },
+            { "paramname":"index", "paramtype":"uint32" },
+            { "paramname":"versionIndex", "paramtype":"uint32" },
+            {
+              "out_string_count": "cchGameBranchSize",
+              "paramname": "pchGameBranchMin",
+              "paramtype": "char *"
+            },
+            {
+              "out_string_count": "cchGameBranchSize",
+              "paramname": "pchGameBranchMax",
+              "paramtype": "char *"
+            },
+            { "paramname":"cchGameBranchSize", "paramtype":"uint32" }
+          ],
+          "returntype": "bool"
+        },
         {
           "methodname": "GetQueryUGCContentDescriptors",
           "methodname_flat": "SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors",
@@ -10171,6 +10320,15 @@
           ],
           "returntype": "bool"
         },
+        {
+          "methodname": "SetAdminQuery",
+          "methodname_flat": "SteamAPI_ISteamUGC_SetAdminQuery",
+          "params": [
+            { "paramname":"handle", "paramtype":"UGCUpdateHandle_t" },
+            { "paramname":"bAdminQuery", "paramtype":"bool" }
+          ],
+          "returntype": "bool"
+        },
         {
           "methodname": "SetCloudFileNameFilter",
           "methodname_flat": "SteamAPI_ISteamUGC_SetCloudFileNameFilter",
@@ -10316,7 +10474,8 @@
           "methodname_flat": "SteamAPI_ISteamUGC_SetItemTags",
           "params": [
             { "paramname":"updateHandle", "paramtype":"UGCUpdateHandle_t" },
-            { "paramname":"pTags", "paramtype":"const SteamParamStringArray_t *" }
+            { "paramname":"pTags", "paramtype":"const SteamParamStringArray_t *" },
+            { "paramname":"bAllowAdminTags", "paramtype":"bool" }
           ],
           "returntype": "bool"
         },
@@ -10440,6 +10599,16 @@
           ],
           "returntype": "bool"
         },
+        {
+          "methodname": "SetRequiredGameVersions",
+          "methodname_flat": "SteamAPI_ISteamUGC_SetRequiredGameVersions",
+          "params": [
+            { "paramname":"handle", "paramtype":"UGCUpdateHandle_t" },
+            { "paramname":"pszGameBranchMin", "paramtype":"const char *" },
+            { "paramname":"pszGameBranchMax", "paramtype":"const char *" }
+          ],
+          "returntype": "bool"
+        },
         {
           "callresult": "SubmitItemUpdateResult_t",
           "methodname": "SubmitItemUpdate",
@@ -10689,70 +10858,18 @@
           "methodname_flat": "SteamAPI_ISteamUGC_GetWorkshopEULAStatus",
           "params": [],
           "returntype": "SteamAPICall_t"
-        }
-      ],
-      "version_string": "STEAMUGC_INTERFACE_VERSION017"
-    },
-    {
-      "accessors": [
-        {
-          "kind": "user",
-          "name": "SteamAppList",
-          "name_flat": "SteamAPI_SteamAppList_v001"
-        }
-      ],
-      "classname": "ISteamAppList",
-      "fields": [],
-      "methods": [
-        {
-          "methodname": "GetNumInstalledApps",
-          "methodname_flat": "SteamAPI_ISteamAppList_GetNumInstalledApps",
-          "params": [],
-          "returntype": "uint32"
         },
         {
-          "methodname": "GetInstalledApps",
+          "methodname": "GetUserContentDescriptorPreferences",
-          "methodname_flat": "SteamAPI_ISteamAppList_GetInstalledApps",
+          "methodname_flat": "SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences",
           "params": [
-            { "paramname":"pvecAppID", "paramtype":"AppId_t *" },
+            { "paramname":"pvecDescriptors", "paramtype":"EUGCContentDescriptorID *" },
-            { "paramname":"unMaxAppIDs", "paramtype":"uint32" }
+            { "paramname":"cMaxEntries", "paramtype":"uint32" }
           ],
           "returntype": "uint32"
-        },
-        {
-          "methodname": "GetAppName",
-          "methodname_flat": "SteamAPI_ISteamAppList_GetAppName",
-          "params": [
-            { "paramname":"nAppID", "paramtype":"AppId_t" },
-            {
-              "out_string": "",
-              "paramname": "pchName",
-              "paramtype": "char *"
-            },
-            { "paramname":"cchNameMax", "paramtype":"int" }
-          ],
-          "returntype": "int"
-        },
-        {
-          "methodname": "GetAppInstallDir",
-          "methodname_flat": "SteamAPI_ISteamAppList_GetAppInstallDir",
-          "params": [
-            { "paramname":"nAppID", "paramtype":"AppId_t" },
-            { "paramname":"pchDirectory", "paramtype":"char *" },
-            { "paramname":"cchNameMax", "paramtype":"int" }
-          ],
-          "returntype": "int"
-        },
-        {
-          "methodname": "GetAppBuildId",
-          "methodname_flat": "SteamAPI_ISteamAppList_GetAppBuildId",
-          "params": [
-            { "paramname":"nAppID", "paramtype":"AppId_t" }
-          ],
-          "returntype": "int"
         }
       ],
-      "version_string": "STEAMAPPLIST_INTERFACE_VERSION001"
+      "version_string": "STEAMUGC_INTERFACE_VERSION020"
     },
     {
       "accessors": [
@@ -11670,12 +11787,196 @@
       ],
       "version_string": "STEAMINVENTORY_INTERFACE_V003"
     },
+    {
+      "accessors": [
+        {
+          "kind": "user",
+          "name": "SteamTimeline",
+          "name_flat": "SteamAPI_SteamTimeline_v004"
+        }
+      ],
+      "classname": "ISteamTimeline",
+      "fields": [],
+      "methods": [
+        {
+          "methodname": "SetTimelineTooltip",
+          "methodname_flat": "SteamAPI_ISteamTimeline_SetTimelineTooltip",
+          "params": [
+            { "paramname":"pchDescription", "paramtype":"const char *" },
+            { "paramname":"flTimeDelta", "paramtype":"float" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "ClearTimelineTooltip",
+          "methodname_flat": "SteamAPI_ISteamTimeline_ClearTimelineTooltip",
+          "params": [
+            { "paramname":"flTimeDelta", "paramtype":"float" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "SetTimelineGameMode",
+          "methodname_flat": "SteamAPI_ISteamTimeline_SetTimelineGameMode",
+          "params": [
+            { "paramname":"eMode", "paramtype":"ETimelineGameMode" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "AddInstantaneousTimelineEvent",
+          "methodname_flat": "SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent",
+          "params": [
+            { "paramname":"pchTitle", "paramtype":"const char *" },
+            { "paramname":"pchDescription", "paramtype":"const char *" },
+            { "paramname":"pchIcon", "paramtype":"const char *" },
+            { "paramname":"unIconPriority", "paramtype":"uint32" },
+            { "paramname":"flStartOffsetSeconds", "paramtype":"float" },
+            { "paramname":"ePossibleClip", "paramtype":"ETimelineEventClipPriority" }
+          ],
+          "returntype": "TimelineEventHandle_t"
+        },
+        {
+          "methodname": "AddRangeTimelineEvent",
+          "methodname_flat": "SteamAPI_ISteamTimeline_AddRangeTimelineEvent",
+          "params": [
+            { "paramname":"pchTitle", "paramtype":"const char *" },
+            { "paramname":"pchDescription", "paramtype":"const char *" },
+            { "paramname":"pchIcon", "paramtype":"const char *" },
+            { "paramname":"unIconPriority", "paramtype":"uint32" },
+            { "paramname":"flStartOffsetSeconds", "paramtype":"float" },
+            { "paramname":"flDuration", "paramtype":"float" },
+            { "paramname":"ePossibleClip", "paramtype":"ETimelineEventClipPriority" }
+          ],
+          "returntype": "TimelineEventHandle_t"
+        },
+        {
+          "methodname": "StartRangeTimelineEvent",
+          "methodname_flat": "SteamAPI_ISteamTimeline_StartRangeTimelineEvent",
+          "params": [
+            { "paramname":"pchTitle", "paramtype":"const char *" },
+            { "paramname":"pchDescription", "paramtype":"const char *" },
+            { "paramname":"pchIcon", "paramtype":"const char *" },
+            { "paramname":"unPriority", "paramtype":"uint32" },
+            { "paramname":"flStartOffsetSeconds", "paramtype":"float" },
+            { "paramname":"ePossibleClip", "paramtype":"ETimelineEventClipPriority" }
+          ],
+          "returntype": "TimelineEventHandle_t"
+        },
+        {
+          "methodname": "UpdateRangeTimelineEvent",
+          "methodname_flat": "SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent",
+          "params": [
+            { "paramname":"ulEvent", "paramtype":"TimelineEventHandle_t" },
+            { "paramname":"pchTitle", "paramtype":"const char *" },
+            { "paramname":"pchDescription", "paramtype":"const char *" },
+            { "paramname":"pchIcon", "paramtype":"const char *" },
+            { "paramname":"unPriority", "paramtype":"uint32" },
+            { "paramname":"ePossibleClip", "paramtype":"ETimelineEventClipPriority" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "EndRangeTimelineEvent",
+          "methodname_flat": "SteamAPI_ISteamTimeline_EndRangeTimelineEvent",
+          "params": [
+            { "paramname":"ulEvent", "paramtype":"TimelineEventHandle_t" },
+            { "paramname":"flEndOffsetSeconds", "paramtype":"float" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "RemoveTimelineEvent",
+          "methodname_flat": "SteamAPI_ISteamTimeline_RemoveTimelineEvent",
+          "params": [
+            { "paramname":"ulEvent", "paramtype":"TimelineEventHandle_t" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "callresult": "SteamTimelineEventRecordingExists_t",
+          "methodname": "DoesEventRecordingExist",
+          "methodname_flat": "SteamAPI_ISteamTimeline_DoesEventRecordingExist",
+          "params": [
+            { "paramname":"ulEvent", "paramtype":"TimelineEventHandle_t" }
+          ],
+          "returntype": "SteamAPICall_t"
+        },
+        {
+          "methodname": "StartGamePhase",
+          "methodname_flat": "SteamAPI_ISteamTimeline_StartGamePhase",
+          "params": [],
+          "returntype": "void"
+        },
+        {
+          "methodname": "EndGamePhase",
+          "methodname_flat": "SteamAPI_ISteamTimeline_EndGamePhase",
+          "params": [],
+          "returntype": "void"
+        },
+        {
+          "methodname": "SetGamePhaseID",
+          "methodname_flat": "SteamAPI_ISteamTimeline_SetGamePhaseID",
+          "params": [
+            { "paramname":"pchPhaseID", "paramtype":"const char *" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "callresult": "SteamTimelineGamePhaseRecordingExists_t",
+          "methodname": "DoesGamePhaseRecordingExist",
+          "methodname_flat": "SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist",
+          "params": [
+            { "paramname":"pchPhaseID", "paramtype":"const char *" }
+          ],
+          "returntype": "SteamAPICall_t"
+        },
+        {
+          "methodname": "AddGamePhaseTag",
+          "methodname_flat": "SteamAPI_ISteamTimeline_AddGamePhaseTag",
+          "params": [
+            { "paramname":"pchTagName", "paramtype":"const char *" },
+            { "paramname":"pchTagIcon", "paramtype":"const char *" },
+            { "paramname":"pchTagGroup", "paramtype":"const char *" },
+            { "paramname":"unPriority", "paramtype":"uint32" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "SetGamePhaseAttribute",
+          "methodname_flat": "SteamAPI_ISteamTimeline_SetGamePhaseAttribute",
+          "params": [
+            { "paramname":"pchAttributeGroup", "paramtype":"const char *" },
+            { "paramname":"pchAttributeValue", "paramtype":"const char *" },
+            { "paramname":"unPriority", "paramtype":"uint32" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "OpenOverlayToGamePhase",
+          "methodname_flat": "SteamAPI_ISteamTimeline_OpenOverlayToGamePhase",
+          "params": [
+            { "paramname":"pchPhaseID", "paramtype":"const char *" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "OpenOverlayToTimelineEvent",
+          "methodname_flat": "SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent",
+          "params": [
+            { "paramname":"ulEvent", "paramtype":"const TimelineEventHandle_t" }
+          ],
+          "returntype": "void"
+        }
+      ],
+      "version_string": "STEAMTIMELINE_INTERFACE_V004"
+    },
     {
       "accessors": [
         {
           "kind": "user",
           "name": "SteamVideo",
-          "name_flat": "SteamAPI_SteamVideo_v002"
+          "name_flat": "SteamAPI_SteamVideo_v007"
         }
       ],
       "classname": "ISteamVideo",
@@ -11717,7 +12018,7 @@
           "returntype": "bool"
         }
       ],
-      "version_string": "STEAMVIDEO_INTERFACE_V002"
+      "version_string": "STEAMVIDEO_INTERFACE_V007"
     },
     {
       "accessors": [
@@ -11782,7 +12083,7 @@
         {
           "kind": "user",
           "name": "SteamRemotePlay",
-          "name_flat": "SteamAPI_SteamRemotePlay_v001"
+          "name_flat": "SteamAPI_SteamRemotePlay_v002"
         }
       ],
       "classname": "ISteamRemotePlay",
@@ -11837,6 +12138,14 @@
           ],
           "returntype": "bool"
         },
+        {
+          "methodname": "BStartRemotePlayTogether",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether",
+          "params": [
+            { "paramname":"bShowOverlay", "paramtype":"bool" }
+          ],
+          "returntype": "bool"
+        },
         {
           "methodname": "BSendRemotePlayTogetherInvite",
           "methodname_flat": "SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite",
@@ -11846,7 +12155,7 @@
           "returntype": "bool"
         }
       ],
-      "version_string": "STEAMREMOTEPLAY_INTERFACE_VERSION001"
+      "version_string": "STEAMREMOTEPLAY_INTERFACE_VERSION002"
     },
     {
       "accessors": [
@@ -13512,29 +13821,6 @@
       ],
       "struct": "InputMotionData_t"
     },
-    {
-      "fields": [
-        { "fieldname":"driftCorrectedQuatX", "fieldtype":"float" },
-        { "fieldname":"driftCorrectedQuatY", "fieldtype":"float" },
-        { "fieldname":"driftCorrectedQuatZ", "fieldtype":"float" },
-        { "fieldname":"driftCorrectedQuatW", "fieldtype":"float" },
-        { "fieldname":"sensorFusionQuatX", "fieldtype":"float" },
-        { "fieldname":"sensorFusionQuatY", "fieldtype":"float" },
-        { "fieldname":"sensorFusionQuatZ", "fieldtype":"float" },
-        { "fieldname":"sensorFusionQuatW", "fieldtype":"float" },
-        { "fieldname":"deferredSensorFusionQuatX", "fieldtype":"float" },
-        { "fieldname":"deferredSensorFusionQuatY", "fieldtype":"float" },
-        { "fieldname":"deferredSensorFusionQuatZ", "fieldtype":"float" },
-        { "fieldname":"deferredSensorFusionQuatW", "fieldtype":"float" },
-        { "fieldname":"gravityX", "fieldtype":"float" },
-        { "fieldname":"gravityY", "fieldtype":"float" },
-        { "fieldname":"gravityZ", "fieldtype":"float" },
-        { "fieldname":"degreesPerSecondX", "fieldtype":"float" },
-        { "fieldname":"degreesPerSecondY", "fieldtype":"float" },
-        { "fieldname":"degreesPerSecondZ", "fieldtype":"float" }
-      ],
-      "struct": "InputMotionDataV2_t"
-    },
     {
       "fields": [
         { "fieldname":"controllerHandle", "fieldtype":"InputHandle_t" },
@@ -13570,7 +13856,8 @@
         { "fieldname":"m_unVotesUp", "fieldtype":"uint32" },
         { "fieldname":"m_unVotesDown", "fieldtype":"uint32" },
         { "fieldname":"m_flScore", "fieldtype":"float" },
-        { "fieldname":"m_unNumChildren", "fieldtype":"uint32" }
+        { "fieldname":"m_unNumChildren", "fieldtype":"uint32" },
+        { "fieldname":"m_ulTotalFilesSize", "fieldtype":"uint64" }
       ],
       "struct": "SteamUGCDetails_t"
     },
@@ -13771,20 +14058,6 @@
           "params": [],
           "returntype": "uint64"
         },
-        {
-          "methodname": "SetStadiaID",
-          "methodname_flat": "SteamAPI_SteamNetworkingIdentity_SetStadiaID",
-          "params": [
-            { "paramname":"id", "paramtype":"uint64" }
-          ],
-          "returntype": "void"
-        },
-        {
-          "methodname": "GetStadiaID",
-          "methodname_flat": "SteamAPI_SteamNetworkingIdentity_GetStadiaID",
-          "params": [],
-          "returntype": "uint64"
-        },
         {
           "methodname": "SetIPAddr",
           "methodname_flat": "SteamAPI_SteamNetworkingIdentity_SetIPAddr",
@@ -14099,6 +14372,7 @@
     { "typedef":"PFNPreMinidumpCallback", "type":"void (*)(void *)" },
     { "typedef":"HSteamPipe", "type":"int" },
     { "typedef":"HSteamUser", "type":"int" },
+    { "typedef":"SteamErrMsg", "type":"char [1024]" },
     { "typedef":"FriendsGroupID_t", "type":"short" },
     { "typedef":"HServerListRequest", "type":"void *" },
     { "typedef":"HServerQuery", "type":"int" },
@@ -14129,6 +14403,7 @@
     { "typedef":"SteamItemDef_t", "type":"int" },
     { "typedef":"SteamInventoryResult_t", "type":"int" },
     { "typedef":"SteamInventoryUpdateHandle_t", "type":"unsigned long long" },
+    { "typedef":"TimelineEventHandle_t", "type":"unsigned long long" },
     { "typedef":"RemotePlaySessionID_t", "type":"unsigned int" },
     { "typedef":"FnSteamNetConnectionStatusChanged", "type":"void (*)(SteamNetConnectionStatusChangedCallback_t *)" },
     { "typedef":"FnSteamNetAuthenticationStatusChanged", "type":"void (*)(SteamNetAuthenticationStatus_t *)" },

Generator/steam_sdk/steam_api_common.h

@@ -36,6 +36,12 @@
 	#endif // STEAM_API_EXPORTS
 #endif
 
+#if defined( __cplusplus ) && ( __cplusplus >= 201103L )
+	#define S_OVERRIDE override
+#else
+	#define S_OVERRIDE
+#endif
+
 #if ( defined(STEAM_API_EXPORTS) || defined(STEAM_API_NODLL) ) && !defined(API_GEN)
 #define STEAM_PRIVATE_API( ... ) __VA_ARGS__
 #elif defined(STEAM_API_EXPORTS) && defined(API_GEN)
@@ -49,6 +55,11 @@ typedef int32 HSteamPipe;
 // handle to single instance of a steam user
 typedef int32 HSteamUser;
 
+// A fixed size buffer to receive an error message that is returned by some API
+// calls.
+const int k_cchMaxSteamErrMsg = 1024;
+typedef char SteamErrMsg[ k_cchMaxSteamErrMsg ];
+
 // #define away __cdecl on posix.
 // This is really, really bad.  We're sorry.  But it's been this way for
 // a long time now and it's scary to change it, as there may be others that
@@ -157,9 +168,9 @@ public:
 
 protected:
 	friend class CCallbackMgr;
-	virtual void Run( void *pvParam ) = 0;
+	virtual void Run( void *pvParam ) S_OVERRIDE = 0;
-	virtual void Run( void *pvParam, bool /*bIOFailure*/, SteamAPICall_t /*hSteamAPICall*/ ) { Run( pvParam ); }
+	virtual void Run( void *pvParam, bool /*bIOFailure*/, SteamAPICall_t /*hSteamAPICall*/ ) S_OVERRIDE { Run( pvParam ); }
-	virtual int GetCallbackSizeBytes() { return sizeof_P; }
+	virtual int GetCallbackSizeBytes() S_OVERRIDE { return sizeof_P; }
 };
 
 
@@ -182,9 +193,9 @@ public:
 
 	void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
 private:
-	virtual void Run( void *pvParam );
+	virtual void Run( void *pvParam ) S_OVERRIDE;
-	virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall );
+	virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall ) S_OVERRIDE;
-	virtual int GetCallbackSizeBytes() { return sizeof( P ); }
+	virtual int GetCallbackSizeBytes() S_OVERRIDE { return sizeof( P ); }
 
 	SteamAPICall_t m_hAPICall;
 	T *m_pObj;
@@ -212,7 +223,7 @@ public:
 	void Unregister();
 
 protected:
-	virtual void Run( void *pvParam );
+	virtual void Run( void *pvParam ) S_OVERRIDE;
 	
 	T *m_pObj;
 	func_t m_Func;

Generator/steam_sdk/steam_api_flat.h

@@ -44,7 +44,6 @@ S_API bool SteamAPI_ISteamClient_BShutdownIfAllPipesClosed( ISteamClient* self )
 S_API ISteamHTTP * SteamAPI_ISteamClient_GetISteamHTTP( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion );
 S_API ISteamController * SteamAPI_ISteamClient_GetISteamController( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion );
 S_API ISteamUGC * SteamAPI_ISteamClient_GetISteamUGC( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion );
-S_API ISteamAppList * SteamAPI_ISteamClient_GetISteamAppList( ISteamClient* self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char * pchVersion );
 S_API ISteamMusic * SteamAPI_ISteamClient_GetISteamMusic( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion );
 S_API ISteamMusicRemote * SteamAPI_ISteamClient_GetISteamMusicRemote( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion );
 S_API ISteamHTMLSurface * SteamAPI_ISteamClient_GetISteamHTMLSurface( ISteamClient* self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char * pchVersion );
@@ -229,6 +228,7 @@ S_API bool SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck( ISteamUtils* self );
 S_API bool SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput( ISteamUtils* self, EFloatingGamepadTextInputMode eKeyboardMode, int nTextFieldXPosition, int nTextFieldYPosition, int nTextFieldWidth, int nTextFieldHeight );
 S_API void SteamAPI_ISteamUtils_SetGameLauncherMode( ISteamUtils* self, bool bLauncherMode );
 S_API bool SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput( ISteamUtils* self );
+S_API bool SteamAPI_ISteamUtils_DismissGamepadTextInput( ISteamUtils* self );
 
 // ISteamMatchmaking
 
@@ -427,10 +427,9 @@ S_API bool SteamAPI_ISteamRemoteStorage_EndFileWriteBatch( ISteamRemoteStorage*
 // ISteamUserStats
 
 // A versioned accessor is exported by the library
-S_API ISteamUserStats *SteamAPI_SteamUserStats_v012();
+S_API ISteamUserStats *SteamAPI_SteamUserStats_v013();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamUserStats(), but using this ensures that you are using a matching library.
-inline ISteamUserStats *SteamAPI_SteamUserStats() { return SteamAPI_SteamUserStats_v012(); }
+inline ISteamUserStats *SteamAPI_SteamUserStats() { return SteamAPI_SteamUserStats_v013(); }
-S_API bool SteamAPI_ISteamUserStats_RequestCurrentStats( ISteamUserStats* self );
 S_API bool SteamAPI_ISteamUserStats_GetStatInt32( ISteamUserStats* self, const char * pchName, int32 * pData );
 S_API bool SteamAPI_ISteamUserStats_GetStatFloat( ISteamUserStats* self, const char * pchName, float * pData );
 S_API bool SteamAPI_ISteamUserStats_SetStatInt32( ISteamUserStats* self, const char * pchName, int32 nData );
@@ -512,6 +511,9 @@ S_API int SteamAPI_ISteamApps_GetLaunchCommandLine( ISteamApps* self, char * psz
 S_API bool SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing( ISteamApps* self );
 S_API bool SteamAPI_ISteamApps_BIsTimedTrial( ISteamApps* self, uint32 * punSecondsAllowed, uint32 * punSecondsPlayed );
 S_API bool SteamAPI_ISteamApps_SetDlcContext( ISteamApps* self, AppId_t nAppID );
+S_API int SteamAPI_ISteamApps_GetNumBetas( ISteamApps* self, int * pnAvailable, int * pnPrivate );
+S_API bool SteamAPI_ISteamApps_GetBetaInfo( ISteamApps* self, int iBetaIndex, uint32 * punFlags, uint32 * punBuildID, char * pchBetaName, int cchBetaName, char * pchDescription, int cchDescription );
+S_API bool SteamAPI_ISteamApps_SetActiveBeta( ISteamApps* self, const char * pchBetaName );
 
 // ISteamNetworking
 
@@ -754,14 +756,14 @@ S_API bool SteamAPI_ISteamController_GetControllerBindingRevision( ISteamControl
 // ISteamUGC
 
 // A versioned accessor is exported by the library
-S_API ISteamUGC *SteamAPI_SteamUGC_v017();
+S_API ISteamUGC *SteamAPI_SteamUGC_v020();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamUGC(), but using this ensures that you are using a matching library.
-inline ISteamUGC *SteamAPI_SteamUGC() { return SteamAPI_SteamUGC_v017(); }
+inline ISteamUGC *SteamAPI_SteamUGC() { return SteamAPI_SteamUGC_v020(); }
 
 // A versioned accessor is exported by the library
-S_API ISteamUGC *SteamAPI_SteamGameServerUGC_v017();
+S_API ISteamUGC *SteamAPI_SteamGameServerUGC_v020();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamGameServerUGC(), but using this ensures that you are using a matching library.
-inline ISteamUGC *SteamAPI_SteamGameServerUGC() { return SteamAPI_SteamGameServerUGC_v017(); }
+inline ISteamUGC *SteamAPI_SteamGameServerUGC() { return SteamAPI_SteamGameServerUGC_v020(); }
 S_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 );
 S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
 S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor );
@@ -780,6 +782,8 @@ S_API bool SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview( ISteamUGC* self, UGC
 S_API uint32 SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index );
 S_API bool SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, char * pchKey, uint32 cchKeySize, char * pchValue, uint32 cchValueSize );
 S_API bool SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, const char * pchKey, char * pchValue, uint32 cchValueSize );
+S_API uint32 SteamAPI_ISteamUGC_GetNumSupportedGameVersions( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index );
+S_API bool SteamAPI_ISteamUGC_GetSupportedGameVersionData( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 versionIndex, char * pchGameBranchMin, char * pchGameBranchMax, uint32 cchGameBranchSize );
 S_API uint32 SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, EUGCContentDescriptorID * pvecDescriptors, uint32 cMaxEntries );
 S_API bool SteamAPI_ISteamUGC_ReleaseQueryUGCRequest( ISteamUGC* self, UGCQueryHandle_t handle );
 S_API bool SteamAPI_ISteamUGC_AddRequiredTag( ISteamUGC* self, UGCQueryHandle_t handle, const char * pTagName );
@@ -795,6 +799,7 @@ S_API bool SteamAPI_ISteamUGC_SetReturnTotalOnly( ISteamUGC* self, UGCQueryHandl
 S_API bool SteamAPI_ISteamUGC_SetReturnPlaytimeStats( ISteamUGC* self, UGCQueryHandle_t handle, uint32 unDays );
 S_API bool SteamAPI_ISteamUGC_SetLanguage( ISteamUGC* self, UGCQueryHandle_t handle, const char * pchLanguage );
 S_API bool SteamAPI_ISteamUGC_SetAllowCachedResponse( ISteamUGC* self, UGCQueryHandle_t handle, uint32 unMaxAgeSeconds );
+S_API bool SteamAPI_ISteamUGC_SetAdminQuery( ISteamUGC* self, UGCUpdateHandle_t handle, bool bAdminQuery );
 S_API bool SteamAPI_ISteamUGC_SetCloudFileNameFilter( ISteamUGC* self, UGCQueryHandle_t handle, const char * pMatchCloudFileName );
 S_API bool SteamAPI_ISteamUGC_SetMatchAnyTag( ISteamUGC* self, UGCQueryHandle_t handle, bool bMatchAnyTag );
 S_API bool SteamAPI_ISteamUGC_SetSearchText( ISteamUGC* self, UGCQueryHandle_t handle, const char * pSearchText );
@@ -810,7 +815,7 @@ S_API bool SteamAPI_ISteamUGC_SetItemDescription( ISteamUGC* self, UGCUpdateHand
 S_API bool SteamAPI_ISteamUGC_SetItemUpdateLanguage( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchLanguage );
 S_API bool SteamAPI_ISteamUGC_SetItemMetadata( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchMetaData );
 S_API bool SteamAPI_ISteamUGC_SetItemVisibility( ISteamUGC* self, UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility );
-S_API bool SteamAPI_ISteamUGC_SetItemTags( ISteamUGC* self, UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t * pTags );
+S_API bool SteamAPI_ISteamUGC_SetItemTags( ISteamUGC* self, UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t * pTags, bool bAllowAdminTags );
 S_API bool SteamAPI_ISteamUGC_SetItemContent( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszContentFolder );
 S_API bool SteamAPI_ISteamUGC_SetItemPreview( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszPreviewFile );
 S_API bool SteamAPI_ISteamUGC_SetAllowLegacyUpload( ISteamUGC* self, UGCUpdateHandle_t handle, bool bAllowLegacyUpload );
@@ -824,6 +829,7 @@ S_API bool SteamAPI_ISteamUGC_UpdateItemPreviewVideo( ISteamUGC* self, UGCUpdate
 S_API bool SteamAPI_ISteamUGC_RemoveItemPreview( ISteamUGC* self, UGCUpdateHandle_t handle, uint32 index );
 S_API bool SteamAPI_ISteamUGC_AddContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid );
 S_API bool SteamAPI_ISteamUGC_RemoveContentDescriptor( ISteamUGC* self, UGCUpdateHandle_t handle, EUGCContentDescriptorID descid );
+S_API bool SteamAPI_ISteamUGC_SetRequiredGameVersions( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pszGameBranchMin, const char * pszGameBranchMax );
 S_API SteamAPICall_t SteamAPI_ISteamUGC_SubmitItemUpdate( ISteamUGC* self, UGCUpdateHandle_t handle, const char * pchChangeNote );
 S_API EItemUpdateStatus SteamAPI_ISteamUGC_GetItemUpdateProgress( ISteamUGC* self, UGCUpdateHandle_t handle, uint64 * punBytesProcessed, uint64 * punBytesTotal );
 S_API SteamAPICall_t SteamAPI_ISteamUGC_SetUserItemVote( ISteamUGC* self, PublishedFileId_t nPublishedFileID, bool bVoteUp );
@@ -851,18 +857,7 @@ S_API SteamAPICall_t SteamAPI_ISteamUGC_GetAppDependencies( ISteamUGC* self, Pub
 S_API SteamAPICall_t SteamAPI_ISteamUGC_DeleteItem( ISteamUGC* self, PublishedFileId_t nPublishedFileID );
 S_API bool SteamAPI_ISteamUGC_ShowWorkshopEULA( ISteamUGC* self );
 S_API SteamAPICall_t SteamAPI_ISteamUGC_GetWorkshopEULAStatus( ISteamUGC* self );
-
+S_API uint32 SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences( ISteamUGC* self, EUGCContentDescriptorID * pvecDescriptors, uint32 cMaxEntries );
-// ISteamAppList
-
-// A versioned accessor is exported by the library
-S_API ISteamAppList *SteamAPI_SteamAppList_v001();
-// Inline, unversioned accessor to get the current version.  Essentially the same as SteamAppList(), but using this ensures that you are using a matching library.
-inline ISteamAppList *SteamAPI_SteamAppList() { return SteamAPI_SteamAppList_v001(); }
-S_API uint32 SteamAPI_ISteamAppList_GetNumInstalledApps( ISteamAppList* self );
-S_API uint32 SteamAPI_ISteamAppList_GetInstalledApps( ISteamAppList* self, AppId_t * pvecAppID, uint32 unMaxAppIDs );
-S_API int SteamAPI_ISteamAppList_GetAppName( ISteamAppList* self, AppId_t nAppID, char * pchName, int cchNameMax );
-S_API int SteamAPI_ISteamAppList_GetAppInstallDir( ISteamAppList* self, AppId_t nAppID, char * pchDirectory, int cchNameMax );
-S_API int SteamAPI_ISteamAppList_GetAppBuildId( ISteamAppList* self, AppId_t nAppID );
 
 // ISteamHTMLSurface
 
@@ -958,12 +953,37 @@ S_API bool SteamAPI_ISteamInventory_SetPropertyFloat( ISteamInventory* self, Ste
 S_API bool SteamAPI_ISteamInventory_SubmitUpdateProperties( ISteamInventory* self, SteamInventoryUpdateHandle_t handle, SteamInventoryResult_t * pResultHandle );
 S_API bool SteamAPI_ISteamInventory_InspectItem( ISteamInventory* self, SteamInventoryResult_t * pResultHandle, const char * pchItemToken );
 
+// ISteamTimeline
+
+// A versioned accessor is exported by the library
+S_API ISteamTimeline *SteamAPI_SteamTimeline_v004();
+// Inline, unversioned accessor to get the current version.  Essentially the same as SteamTimeline(), but using this ensures that you are using a matching library.
+inline ISteamTimeline *SteamAPI_SteamTimeline() { return SteamAPI_SteamTimeline_v004(); }
+S_API void SteamAPI_ISteamTimeline_SetTimelineTooltip( ISteamTimeline* self, const char * pchDescription, float flTimeDelta );
+S_API void SteamAPI_ISteamTimeline_ClearTimelineTooltip( ISteamTimeline* self, float flTimeDelta );
+S_API void SteamAPI_ISteamTimeline_SetTimelineGameMode( ISteamTimeline* self, ETimelineGameMode eMode );
+S_API TimelineEventHandle_t SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent( ISteamTimeline* self, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip );
+S_API TimelineEventHandle_t SteamAPI_ISteamTimeline_AddRangeTimelineEvent( ISteamTimeline* self, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unIconPriority, float flStartOffsetSeconds, float flDuration, ETimelineEventClipPriority ePossibleClip );
+S_API TimelineEventHandle_t SteamAPI_ISteamTimeline_StartRangeTimelineEvent( ISteamTimeline* self, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unPriority, float flStartOffsetSeconds, ETimelineEventClipPriority ePossibleClip );
+S_API void SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent( ISteamTimeline* self, TimelineEventHandle_t ulEvent, const char * pchTitle, const char * pchDescription, const char * pchIcon, uint32 unPriority, ETimelineEventClipPriority ePossibleClip );
+S_API void SteamAPI_ISteamTimeline_EndRangeTimelineEvent( ISteamTimeline* self, TimelineEventHandle_t ulEvent, float flEndOffsetSeconds );
+S_API void SteamAPI_ISteamTimeline_RemoveTimelineEvent( ISteamTimeline* self, TimelineEventHandle_t ulEvent );
+S_API SteamAPICall_t SteamAPI_ISteamTimeline_DoesEventRecordingExist( ISteamTimeline* self, TimelineEventHandle_t ulEvent );
+S_API void SteamAPI_ISteamTimeline_StartGamePhase( ISteamTimeline* self );
+S_API void SteamAPI_ISteamTimeline_EndGamePhase( ISteamTimeline* self );
+S_API void SteamAPI_ISteamTimeline_SetGamePhaseID( ISteamTimeline* self, const char * pchPhaseID );
+S_API SteamAPICall_t SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist( ISteamTimeline* self, const char * pchPhaseID );
+S_API void SteamAPI_ISteamTimeline_AddGamePhaseTag( ISteamTimeline* self, const char * pchTagName, const char * pchTagIcon, const char * pchTagGroup, uint32 unPriority );
+S_API void SteamAPI_ISteamTimeline_SetGamePhaseAttribute( ISteamTimeline* self, const char * pchAttributeGroup, const char * pchAttributeValue, uint32 unPriority );
+S_API void SteamAPI_ISteamTimeline_OpenOverlayToGamePhase( ISteamTimeline* self, const char * pchPhaseID );
+S_API void SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent( ISteamTimeline* self, const TimelineEventHandle_t ulEvent );
+
 // ISteamVideo
 
 // A versioned accessor is exported by the library
-S_API ISteamVideo *SteamAPI_SteamVideo_v002();
+S_API ISteamVideo *SteamAPI_SteamVideo_v007();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamVideo(), but using this ensures that you are using a matching library.
-inline ISteamVideo *SteamAPI_SteamVideo() { return SteamAPI_SteamVideo_v002(); }
+inline ISteamVideo *SteamAPI_SteamVideo() { return SteamAPI_SteamVideo_v007(); }
 S_API void SteamAPI_ISteamVideo_GetVideoURL( ISteamVideo* self, AppId_t unVideoAppID );
 S_API bool SteamAPI_ISteamVideo_IsBroadcasting( ISteamVideo* self, int * pnNumViewers );
 S_API void SteamAPI_ISteamVideo_GetOPFSettings( ISteamVideo* self, AppId_t unVideoAppID );
@@ -985,15 +1005,16 @@ S_API bool SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList( ISteamParental
 // ISteamRemotePlay
 
 // A versioned accessor is exported by the library
-S_API ISteamRemotePlay *SteamAPI_SteamRemotePlay_v001();
+S_API ISteamRemotePlay *SteamAPI_SteamRemotePlay_v002();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamRemotePlay(), but using this ensures that you are using a matching library.
-inline ISteamRemotePlay *SteamAPI_SteamRemotePlay() { return SteamAPI_SteamRemotePlay_v001(); }
+inline ISteamRemotePlay *SteamAPI_SteamRemotePlay() { return SteamAPI_SteamRemotePlay_v002(); }
 S_API uint32 SteamAPI_ISteamRemotePlay_GetSessionCount( ISteamRemotePlay* self );
 S_API RemotePlaySessionID_t SteamAPI_ISteamRemotePlay_GetSessionID( ISteamRemotePlay* self, int iSessionIndex );
 S_API uint64_steamid SteamAPI_ISteamRemotePlay_GetSessionSteamID( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID );
 S_API const char * SteamAPI_ISteamRemotePlay_GetSessionClientName( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID );
 S_API ESteamDeviceFormFactor SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID );
 S_API bool SteamAPI_ISteamRemotePlay_BGetSessionClientResolution( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID, int * pnResolutionX, int * pnResolutionY );
+S_API bool SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether( ISteamRemotePlay* self, bool bShowOverlay );
 S_API bool SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite( ISteamRemotePlay* self, uint64_steamid steamIDFriend );
 
 // ISteamNetworkingMessages
@@ -1243,8 +1264,6 @@ S_API bool SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID( SteamNetworkingId
 S_API const char * SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID( SteamNetworkingIdentity* self );
 S_API void SteamAPI_SteamNetworkingIdentity_SetPSNID( SteamNetworkingIdentity* self, uint64 id );
 S_API uint64 SteamAPI_SteamNetworkingIdentity_GetPSNID( SteamNetworkingIdentity* self );
-S_API void SteamAPI_SteamNetworkingIdentity_SetStadiaID( SteamNetworkingIdentity* self, uint64 id );
-S_API uint64 SteamAPI_SteamNetworkingIdentity_GetStadiaID( SteamNetworkingIdentity* self );
 S_API void SteamAPI_SteamNetworkingIdentity_SetIPAddr( SteamNetworkingIdentity* self, const SteamNetworkingIPAddr & addr );
 S_API const SteamNetworkingIPAddr * SteamAPI_SteamNetworkingIdentity_GetIPAddr( SteamNetworkingIdentity* self );
 S_API void SteamAPI_SteamNetworkingIdentity_SetIPv4Addr( SteamNetworkingIdentity* self, uint32 nIPv4, uint16 nPort );

Generator/steam_sdk/steam_api_internal.h

@@ -54,6 +54,7 @@ S_API void S_CALLTYPE SteamAPI_UnregisterCallback( class CCallbackBase *pCallbac
 S_API void S_CALLTYPE SteamAPI_RegisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
 S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
 
+#define _STEAM_CALLBACK_OFFSETOF( type, member ) ( (size_t)( (char *)&( (type *)0 )->member ) )
 #define _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param )
 #define _STEAM_CALLBACK_HELPER( _1, _2, SELECTED, ... )		_STEAM_CALLBACK_##SELECTED
 #define _STEAM_CALLBACK_SELECT( X, Y )						_STEAM_CALLBACK_HELPER X Y
@@ -62,8 +63,8 @@ S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallb
 		CCallbackInternal_ ## func () { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \
 		CCallbackInternal_ ## func ( const CCallbackInternal_ ## func & ) { extra_code SteamAPI_RegisterCallback( this, param::k_iCallback ); } \
 		CCallbackInternal_ ## func & operator=( const CCallbackInternal_ ## func & ) { return *this; } \
-		private: virtual void Run( void *pvParam ) { _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) \
+		private: virtual void Run( void *pvParam ) S_OVERRIDE { _STEAM_CALLBACK_AUTO_HOOK( thisclass, func, param ) \
-			thisclass *pOuter = reinterpret_cast<thisclass*>( reinterpret_cast<char*>(this) - offsetof( thisclass, m_steamcallback_ ## func ) ); \
+			thisclass *pOuter = reinterpret_cast<thisclass*>( reinterpret_cast<char*>(this) - _STEAM_CALLBACK_OFFSETOF( thisclass, m_steamcallback_ ## func ) ); \
 			pOuter->func( reinterpret_cast<param*>( pvParam ) ); \
 		} \
 	} m_steamcallback_ ## func ; void func( param *pParam )
@@ -228,7 +229,6 @@ class ISteamPS3OverlayRender;
 class ISteamHTTP;
 class ISteamController;
 class ISteamUGC;
-class ISteamAppList;
 class ISteamHTMLSurface;
 class ISteamInventory;
 class ISteamVideo;
@@ -271,7 +271,6 @@ enum { k_iSteamStreamLauncherCallbacks = 2600 };
 enum { k_iSteamControllerCallbacks = 2800 };
 enum { k_iSteamUGCCallbacks = 3400 };
 enum { k_iSteamStreamClientCallbacks = 3500 };
-enum { k_iSteamAppListCallbacks = 3900 };
 enum { k_iSteamMusicCallbacks = 4000 };
 enum { k_iSteamMusicRemoteCallbacks = 4100 };
 enum { k_iSteamGameNotificationCallbacks = 4400 }; 
@@ -284,6 +283,7 @@ enum { k_iSteamPartiesCallbacks = 5300 };
 enum { k_iSteamSTARCallbacks = 5500 };
 enum { k_iSteamRemotePlayCallbacks = 5700 };
 enum { k_iSteamChatCallbacks = 5900 };
+enum { k_iSteamTimelineCallbacks = 6000 };
 // NOTE: Internal "IClientXxx" callback IDs go in clientenums.h
 
 // Macros used to annotate various Steamworks interfaces to generate the
@@ -307,93 +307,3 @@ enum { k_iSteamChatCallbacks = 5900 };
 #define STEAM_CALL_RESULT(RESULT_TYPE) STEAM_CLANG_ATTR("callresult:" #RESULT_TYPE ";")
 #define STEAM_CALL_BACK(RESULT_TYPE) STEAM_CLANG_ATTR("callback:" #RESULT_TYPE ";")
 #define STEAM_FLAT_NAME(NAME) STEAM_CLANG_ATTR("flat_name:" #NAME ";")
-
-// CSteamAPIContext encapsulates the Steamworks API global accessors into
-// a single object.
-//
-// DEPRECATED: Used the global interface accessors instead!
-//
-// This will be removed in a future iteration of the SDK
-class CSteamAPIContext
-{
-public:
-	CSteamAPIContext() { Clear(); }
-	inline void Clear() { memset( this, 0, sizeof(*this) ); }
-	inline bool Init(); // NOTE: This is defined in steam_api.h, to avoid this file having to include everything
-	ISteamClient*		SteamClient() const					{ return m_pSteamClient; }
-	ISteamUser*			SteamUser() const					{ return m_pSteamUser; }
-	ISteamFriends*		SteamFriends() const				{ return m_pSteamFriends; }
-	ISteamUtils*		SteamUtils() const					{ return m_pSteamUtils; }
-	ISteamMatchmaking*	SteamMatchmaking() const			{ return m_pSteamMatchmaking; }
-	ISteamGameSearch*	SteamGameSearch() const				{ return m_pSteamGameSearch; }
-	ISteamUserStats*	SteamUserStats() const				{ return m_pSteamUserStats; }
-	ISteamApps*			SteamApps() const					{ return m_pSteamApps; }
-	ISteamMatchmakingServers* SteamMatchmakingServers() const { return m_pSteamMatchmakingServers; }
-	ISteamNetworking*	SteamNetworking() const				{ return m_pSteamNetworking; }
-	ISteamRemoteStorage* SteamRemoteStorage() const			{ return m_pSteamRemoteStorage; }
-	ISteamScreenshots*	SteamScreenshots() const			{ return m_pSteamScreenshots; }
-	ISteamHTTP*			SteamHTTP() const					{ return m_pSteamHTTP; }
-	ISteamController*	SteamController() const				{ return m_pController; }
-	ISteamUGC*			SteamUGC() const					{ return m_pSteamUGC; }
-	ISteamAppList*		SteamAppList() const				{ return m_pSteamAppList; }
-	ISteamMusic*		SteamMusic() const					{ return m_pSteamMusic; }
-	ISteamMusicRemote*	SteamMusicRemote() const			{ return m_pSteamMusicRemote; }
-	ISteamHTMLSurface*	SteamHTMLSurface() const			{ return m_pSteamHTMLSurface; }
-	ISteamInventory*	SteamInventory() const				{ return m_pSteamInventory; }
-	ISteamVideo*		SteamVideo() const					{ return m_pSteamVideo; }
-	ISteamParentalSettings* SteamParentalSettings() const	{ return m_pSteamParentalSettings; }
-	ISteamInput*		SteamInput() const					{ return m_pSteamInput; }
-private:
-	ISteamClient		*m_pSteamClient;
-	ISteamUser			*m_pSteamUser;
-	ISteamFriends		*m_pSteamFriends;
-	ISteamUtils			*m_pSteamUtils;
-	ISteamMatchmaking	*m_pSteamMatchmaking;
-	ISteamGameSearch	*m_pSteamGameSearch;
-	ISteamUserStats		*m_pSteamUserStats;
-	ISteamApps			*m_pSteamApps;
-	ISteamMatchmakingServers *m_pSteamMatchmakingServers;
-	ISteamNetworking	*m_pSteamNetworking;
-	ISteamRemoteStorage *m_pSteamRemoteStorage;
-	ISteamScreenshots	*m_pSteamScreenshots;
-	ISteamHTTP			*m_pSteamHTTP;
-	ISteamController	*m_pController;
-	ISteamUGC			*m_pSteamUGC;
-	ISteamAppList		*m_pSteamAppList;
-	ISteamMusic			*m_pSteamMusic;
-	ISteamMusicRemote	*m_pSteamMusicRemote;
-	ISteamHTMLSurface	*m_pSteamHTMLSurface;
-	ISteamInventory		*m_pSteamInventory;
-	ISteamVideo			*m_pSteamVideo;
-	ISteamParentalSettings *m_pSteamParentalSettings;
-	ISteamInput			*m_pSteamInput;
-};
-
-class CSteamGameServerAPIContext
-{
-public:
-	CSteamGameServerAPIContext() { Clear(); }
-	inline void Clear() { memset( this, 0, sizeof(*this) ); }
-	inline bool Init(); // NOTE: This is defined in steam_gameserver.h, to avoid this file having to include everything
-
-	ISteamClient *SteamClient() const					{ return m_pSteamClient; }
-	ISteamGameServer *SteamGameServer() const			{ return m_pSteamGameServer; }
-	ISteamUtils *SteamGameServerUtils() const			{ return m_pSteamGameServerUtils; }
-	ISteamNetworking *SteamGameServerNetworking() const	{ return m_pSteamGameServerNetworking; }
-	ISteamGameServerStats *SteamGameServerStats() const	{ return m_pSteamGameServerStats; }
-	ISteamHTTP *SteamHTTP() const						{ return m_pSteamHTTP; }
-	ISteamInventory *SteamInventory() const				{ return m_pSteamInventory; }
-	ISteamUGC *SteamUGC() const							{ return m_pSteamUGC; }
-
-private:
-	ISteamClient				*m_pSteamClient;
-	ISteamGameServer			*m_pSteamGameServer;
-	ISteamUtils					*m_pSteamGameServerUtils;
-	ISteamNetworking			*m_pSteamGameServerNetworking;
-	ISteamGameServerStats		*m_pSteamGameServerStats;
-	ISteamHTTP					*m_pSteamHTTP;
-	ISteamInventory				*m_pSteamInventory;
-	ISteamUGC					*m_pSteamUGC;
-};
-
-

Generator/steam_sdk/steam_gameserver.h

@@ -48,7 +48,17 @@ const uint16 MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE = STEAMGAMESERVER_QUERY_
 //		ISteamGameServer::GetNextOutgoingPacket.)
 // - The version string should be in the form x.x.x.x, and is used by the master server to detect when the
 //		server is out of date.  (Only servers with the latest version will be listed.)
-inline bool SteamGameServer_Init( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
+//
+// On success k_ESteamAPIInitResult_OK is returned.  Otherwise, if pOutErrMsg is non-NULL,
+// it will receive a non-localized message that explains the reason for the failure
+inline ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg );
+
+// This function is included for compatibility with older SDK.
+// You can use it if you don't care about decent error handling
+inline bool SteamGameServer_Init( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString )
+{
+	return SteamGameServer_InitEx( unIP, usGamePort, usQueryPort, eServerMode, pchVersionString, NULL ) == k_ESteamAPIInitResult_OK;
+}
 
 // Shutdown SteamGameSeverXxx interfaces, log out, and free resources.
 S_API void SteamGameServer_Shutdown();
@@ -64,8 +74,8 @@ S_API bool SteamGameServer_BSecure();
 S_API uint64 SteamGameServer_GetSteamID();
 
 // Older SDKs exported this global pointer, but it is no longer supported.
-// You should use SteamGameServerClient() or CSteamGameServerAPIContext to
+// You should use SteamGameServerClient() to safely access the ISteamClient
-// safely access the ISteamClient APIs from your game server application.
+// APIs from your game server application.
 //S_API ISteamClient *g_pSteamClientGameServer;
 
 // SteamGameServer_InitSafe has been replaced with SteamGameServer_Init and
@@ -78,36 +88,23 @@ S_API uint64 SteamGameServer_GetSteamID();
 //
 //=============================================================================
 
-#ifndef STEAM_API_EXPORTS
+S_API ESteamAPIInitResult S_CALLTYPE SteamInternal_GameServer_Init_V2( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, const char *pszInternalCheckInterfaceVersions, SteamErrMsg *pOutErrMsg );
-// This function must be declared inline in the header so the module using steam_api.dll gets the version names they want.
+inline ESteamAPIInitResult SteamGameServer_InitEx( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString, SteamErrMsg *pOutErrMsg )
-inline bool CSteamGameServerAPIContext::Init()
 {
-	m_pSteamClient = ::SteamGameServerClient();
+	const char *pszInternalCheckInterfaceVersions = 
-	if ( !m_pSteamClient )
+		STEAMUTILS_INTERFACE_VERSION "\0"
-		return false;
+		STEAMNETWORKINGUTILS_INTERFACE_VERSION "\0"
 
-	m_pSteamGameServer = ::SteamGameServer();
+		STEAMGAMESERVER_INTERFACE_VERSION "\0"
-	m_pSteamGameServerUtils = ::SteamGameServerUtils();
+		STEAMGAMESERVERSTATS_INTERFACE_VERSION "\0"
-	m_pSteamGameServerNetworking = ::SteamGameServerNetworking();
+		STEAMHTTP_INTERFACE_VERSION "\0"
-	m_pSteamGameServerStats = ::SteamGameServerStats();
+		STEAMINVENTORY_INTERFACE_VERSION "\0"
-	m_pSteamHTTP = ::SteamGameServerHTTP();
+		STEAMNETWORKING_INTERFACE_VERSION "\0"
-	m_pSteamInventory = ::SteamGameServerInventory();
+		STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "\0"
-	m_pSteamUGC = ::SteamGameServerUGC();
+		STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "\0"
-	if ( !m_pSteamGameServer || !m_pSteamGameServerUtils || !m_pSteamGameServerNetworking || !m_pSteamGameServerStats
+		STEAMUGC_INTERFACE_VERSION "\0"
-		|| !m_pSteamHTTP || !m_pSteamInventory || !m_pSteamUGC )
+		"\0";
-		return false;
+	return SteamInternal_GameServer_Init_V2( unIP, usGamePort, usQueryPort, eServerMode, pchVersionString, pszInternalCheckInterfaceVersions, pOutErrMsg );
-
-	return true;
-}
-#endif
-
-S_API bool S_CALLTYPE SteamInternal_GameServer_Init( uint32 unIP, uint16 usLegacySteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );
-inline bool SteamGameServer_Init( uint32 unIP, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString )
-{
-	if ( !SteamInternal_GameServer_Init( unIP, 0, usGamePort, usQueryPort, eServerMode, pchVersionString ) )
-		return false;
-
-	return true;
 }
 inline void SteamGameServer_ReleaseCurrentThreadMemory()
 {

Generator/steam_sdk/steamclientpublic.h

@@ -141,6 +141,9 @@ enum EResult
 	k_EResultChargerRequired = 125,				// The operation requires a charger to be plugged in, which wasn't present
 	k_EResultCachedCredentialInvalid = 126,		// Cached credential was invalid - user must reauthenticate
 	K_EResultPhoneNumberIsVOIP = 127,			// The phone number provided is a Voice Over IP number
+	k_EResultNotSupported = 128,				// The data being accessed is not supported by this API
+	k_EResultFamilySizeLimitExceeded = 129,		// Reached the maximum size of the family
+	k_EResultOfflineAppCacheInvalid = 130,		// The local data for the offline mode cache is insufficient to login
 };
 
 // Error codes for use with the voice functions
@@ -459,6 +462,16 @@ enum EDurationControlOnlineState
 };
 
 
+enum EBetaBranchFlags
+{
+	k_EBetaBranch_None			= 0,
+	k_EBetaBranch_Default		= 1,	// this is the default branch ("public")
+	k_EBetaBranch_Available		= 2,	// this branch can be selected (available)
+	k_EBetaBranch_Private		= 4,	// this is a private branch (password protected)
+	k_EBetaBranch_Selected		= 8,	// this is the currently selected branch (active)
+	k_EBetaBranch_Installed		= 16,	// this is the currently installed branch (mounted)
+};
+
 #pragma pack( push, 1 )
 
 #define CSTEAMID_DEFINED

Generator/steam_sdk/steamhttpenums.h

@@ -97,4 +97,9 @@ enum EHTTPStatusCode
 	k_EHTTPStatusCode5xxUnknown =				599,
 };
 
+inline bool BIsHTTPStatusSuccess( EHTTPStatusCode eStatus )
+{
+	return eStatus >= 200 && eStatus <= 299;
+}
+
 #endif // STEAMHTTPENUMS_H

Generator/steam_sdk/steamnetworkingtypes.h

@@ -26,7 +26,7 @@
 #if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK )
 	#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C"
 #elif defined( STEAMNETWORKINGSOCKETS_FOREXPORT )
-	#ifdef _WIN32
+	#if defined( _WIN32 ) || defined( __ORBIS__ ) || defined( __PROSPERO__ )
 		#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __declspec( dllexport )
 	#else
 		#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __attribute__((visibility("default")))
@@ -143,10 +143,6 @@ enum ESteamNetworkingIdentityType
 	k_ESteamNetworkingIdentityType_SteamID = 16, // 64-bit CSteamID
 	k_ESteamNetworkingIdentityType_XboxPairwiseID = 17, // Publisher-specific user identity, as string
 	k_ESteamNetworkingIdentityType_SonyPSN = 18, // 64-bit ID
-	k_ESteamNetworkingIdentityType_GoogleStadia = 19, // 64-bit ID
-	//k_ESteamNetworkingIdentityType_NintendoNetworkServiceAccount,
-	//k_ESteamNetworkingIdentityType_EpicGameStore
-	//k_ESteamNetworkingIdentityType_WeGame
 
 	//
 	// Special identifiers.
@@ -281,9 +277,6 @@ struct SteamNetworkingIdentity
 	void SetPSNID( uint64 id );
 	uint64 GetPSNID() const; // Returns 0 if not PSN
 
-	void SetStadiaID( uint64 id );
-	uint64 GetStadiaID() const; // Returns 0 if not Stadia
-
 	void SetIPAddr( const SteamNetworkingIPAddr &addr ); // Set to specified IP:port
 	const SteamNetworkingIPAddr *GetIPAddr() const; // returns null if we are not an IP address.
 	void SetIPv4Addr( uint32 nIPv4, uint16 nPort ); // Set to specified IPv4:port
@@ -339,7 +332,6 @@ struct SteamNetworkingIdentity
 	union {
 		uint64 m_steamID64;
 		uint64 m_PSNID;
-		uint64 m_stadiaID;
 		char m_szGenericString[ k_cchMaxGenericString ];
 		char m_szXboxPairwiseID[ k_cchMaxXboxPairwiseID ];
 		uint8 m_genericBytes[ k_cbMaxGenericBytes ];
@@ -1152,6 +1144,42 @@ enum ESteamNetworkingConfigValue
 	/// Default is 512k (524288 bytes)
 	k_ESteamNetworkingConfig_SendBufferSize = 9,
 
+	/// [connection int32] Upper limit on total size (in bytes) of received messages
+	/// that will be buffered waiting to be processed by the application.  If this limit
+	/// is exceeded, packets will be dropped.  This is to protect us from a malicious
+	/// peer flooding us with messages faster than we can process them.
+	/// 
+	/// This must be bigger than k_ESteamNetworkingConfig_RecvMaxMessageSize
+	k_ESteamNetworkingConfig_RecvBufferSize = 47,
+
+	/// [connection int32] Upper limit on the number of received messages that will
+	/// that will be buffered waiting to be processed by the application.  If this limit
+	/// is exceeded, packets will be dropped.  This is to protect us from a malicious
+	/// peer flooding us with messages faster than we can pull them off the wire.
+	k_ESteamNetworkingConfig_RecvBufferMessages = 48,
+
+	/// [connection int32] Maximum message size that we are willing to receive.
+	/// if a client attempts to send us a message larger than this, the connection
+	/// will be immediately closed.
+	///
+	/// Default is 512k (524288 bytes).  Note that the peer needs to be able to
+	/// send a message this big.  (See k_cbMaxSteamNetworkingSocketsMessageSizeSend.)
+	k_ESteamNetworkingConfig_RecvMaxMessageSize = 49,
+
+	/// [connection int32] Max number of message segments that can be received
+	/// in a single UDP packet.  While decoding a packet, if the number of segments
+	/// exceeds this, we will abort further packet processing.
+	///
+	/// The default is effectively unlimited.  If you know that you very rarely
+	/// send small packets, you can protect yourself from malicious senders by
+	/// lowering this number.
+	/// 
+	/// In particular, if you are NOT using the reliability layer and are only using
+	/// SteamNetworkingSockets for datagram transport, setting this to a very low
+	/// number may be beneficial.  (We recommend a value of 2.)  Make sure your sender
+	/// disables Nagle!
+	k_ESteamNetworkingConfig_RecvMaxSegmentsPerPacket = 50,
+
 	/// [connection int64] Get/set userdata as a configuration option.
 	/// The default value is -1.   You may want to set the user data as
 	/// a config value, instead of using ISteamNetworkingSockets::SetConnectionUserData
@@ -1187,9 +1215,12 @@ enum ESteamNetworkingConfigValue
 	//    ensure you have the current value.
 	k_ESteamNetworkingConfig_ConnectionUserData = 40,
 
-	/// [connection int32] Minimum/maximum send rate clamp, 0 is no limit.
+	/// [connection int32] Minimum/maximum send rate clamp, in bytes/sec.
-	/// This value will control the min/max allowed sending rate that 
+	/// At the time of this writing these two options should always be set to
-	/// bandwidth estimation is allowed to reach.  Default is 0 (no-limit)
+	/// the same value, to manually configure a specific send rate.  The default
+	/// value is 256K.  Eventually we hope to have the library estimate the bandwidth
+	/// of the channel and set the send rate to that estimated bandwidth, and these
+	/// values will only set limits on that send rate.
 	k_ESteamNetworkingConfig_SendRateMin = 10,
 	k_ESteamNetworkingConfig_SendRateMax = 11,
 
@@ -1208,10 +1239,19 @@ enum ESteamNetworkingConfigValue
 	/// we won't automatically reject a connection due to a failure to authenticate.
 	/// (You can examine the incoming connection and decide whether to accept it.)
 	///
+	/// 0: Don't attempt or accept unauthorized connections
+	/// 1: Attempt authorization when connecting, and allow unauthorized peers, but emit warnings
+	/// 2: don't attempt authentication, or complain if peer is unauthenticated
+	///
 	/// This is a dev configuration value, and you should not let users modify it in
 	/// production.
 	k_ESteamNetworkingConfig_IP_AllowWithoutAuth = 23,
 
+	/// [connection int32] The same as IP_AllowWithoutAuth, but will only apply
+	/// for connections to/from localhost addresses.  Whichever value is larger
+	/// (more permissive) will be used.
+	k_ESteamNetworkingConfig_IPLocalHost_AllowWithoutAuth = 52,
+
 	/// [connection int32] Do not send UDP packets with a payload of
 	/// larger than N bytes.  If you set this, k_ESteamNetworkingConfig_MTU_DataSize
 	/// is automatically adjusted
@@ -1341,6 +1381,17 @@ enum ESteamNetworkingConfigValue
 	/// generic platform UI.  (Only available on Steam.)
 	k_ESteamNetworkingConfig_EnableDiagnosticsUI = 46,
 
+	/// [connection int32] Send of time-since-previous-packet values in each UDP packet.
+	/// This add a small amount of packet overhead but allows for detailed jitter measurements
+	/// to be made by the receiver.
+	/// 
+	/// -  0: disables the sending
+	/// -  1: enables sending
+	/// - -1: (the default) Use the default for the connection type.  For plain UDP connections,
+	///       this is disabled, and for relayed connections, it is enabled.  Note that relays
+	///       always send the value.
+	k_ESteamNetworkingConfig_SendTimeSincePreviousPacket = 59,
+
 //
 // Simulating network conditions
 //
@@ -1358,15 +1409,53 @@ enum ESteamNetworkingConfigValue
 	k_ESteamNetworkingConfig_FakePacketLag_Send = 4,
 	k_ESteamNetworkingConfig_FakePacketLag_Recv = 5,
 
-	/// [global float] 0-100 Percentage of packets we will add additional delay
+	/// Simulated jitter/clumping.
-	/// to (causing them to be reordered)
+	///
+	/// For each packet, a jitter value is determined (which may
+	/// be zero).  This amount is added as extra delay to the
+	/// packet.  When a subsequent packet is queued, it receives its
+	/// own random jitter amount from the current time.  if this would
+	/// result in the packets being delivered out of order, the later
+	/// packet queue time is adjusted to happen after the first packet.
+	/// Thus simulating jitter by itself will not reorder packets, but it
+	/// can "clump" them.
+	///
+	///	- Avg: A random jitter time is generated using an exponential
+	///   distribution using this value as the mean (ms).  The default
+	///   is zero, which disables random jitter.
+	/// - Max: Limit the random jitter time to this value (ms).
+	///	- Pct: odds (0-100) that a random jitter value for the packet
+	///   will be generated.  Otherwise, a jitter value of zero
+	///   is used, and the packet will only be delayed by the jitter
+	///   system if necessary to retain order, due to the jitter of a
+	///   previous packet.
+	///
+	/// All values are [global float]
+	///
+	/// Fake jitter is simulated after fake lag, but before reordering.
+	k_ESteamNetworkingConfig_FakePacketJitter_Send_Avg = 53,
+	k_ESteamNetworkingConfig_FakePacketJitter_Send_Max = 54,
+	k_ESteamNetworkingConfig_FakePacketJitter_Send_Pct = 55,
+	k_ESteamNetworkingConfig_FakePacketJitter_Recv_Avg = 56,
+	k_ESteamNetworkingConfig_FakePacketJitter_Recv_Max = 57,
+	k_ESteamNetworkingConfig_FakePacketJitter_Recv_Pct = 58,
+
+	/// [global float] 0-100 Percentage of packets we will add additional
+	/// delay to.  If other packet(s) are sent/received within this delay
+	/// window (that doesn't also randomly receive the same extra delay),
+	/// then the packets become reordered.
+	///
+	/// This mechanism is primarily intended to generate out-of-order
+	/// packets.  To simulate random jitter, use the FakePacketJitter.
+	/// Fake packet reordering is applied after fake lag and jitter
 	k_ESteamNetworkingConfig_FakePacketReorder_Send = 6,
 	k_ESteamNetworkingConfig_FakePacketReorder_Recv = 7,
 
-	/// [global int32] Extra delay, in ms, to apply to reordered packets.
+	/// [global int32] Extra delay, in ms, to apply to reordered
+	/// packets.  The same time value is used for sending and receiving.
 	k_ESteamNetworkingConfig_FakePacketReorder_Time = 8,
 
-	/// [global float 0--100] Globally duplicate some percentage of packets we send
+	/// [global float 0--100] Globally duplicate some percentage of packets.
 	k_ESteamNetworkingConfig_FakePacketDup_Send = 26,
 	k_ESteamNetworkingConfig_FakePacketDup_Recv = 27,
 
@@ -1393,6 +1482,32 @@ enum ESteamNetworkingConfigValue
 	k_ESteamNetworkingConfig_FakeRateLimit_Recv_Rate = 44,
 	k_ESteamNetworkingConfig_FakeRateLimit_Recv_Burst = 45,
 
+	// Timeout used for out-of-order correction.  This is used when we see a small
+	// gap in the sequence number on a packet flow.  For example let's say we are
+	// processing packet 105 when the most recent one was 103.  104 might have dropped,
+	// but there is also a chance that packets are simply being reordered.  It is very
+	// common on certain types of connections for packet 104 to arrive very soon after 105,
+	// especially if 104 was large and 104 was small.  In this case, when we see packet 105
+	// we will shunt it aside and pend it, in the hopes of seeing 104 soon after.  If 104
+	// arrives before the a timeout occurs, then we can deliver the packets in order to the
+	// remainder of packet processing, and we will record this as a "correctable" out-of-order
+	// situation.  If the timer expires, then we will process packet 105, and assume for now
+	// that 104 has dropped.  (If 104 later arrives, we will process it, but that will be
+	// accounted for as uncorrected.)
+	//
+	// The default value is 1000 microseconds.  Note that the Windows scheduler does not
+	// have microsecond precision.
+	//
+	// Set the value to 0 to disable out of order correction at the packet layer.
+	// In many cases we are still effectively able to correct the situation because
+	// reassembly of message fragments is tolerant of fragments packets arriving out of
+	// order.  Also, when messages are decoded and inserted into the queue for the app
+	// to receive them, we will correct out of order messages that have not been
+	// dequeued by the app yet.  However, when out-of-order packets are corrected
+	// at the packet layer, they will not reduce the connection quality measure.
+	// (E.g. SteamNetConnectionRealTimeStatus_t::m_flConnectionQualityLocal)
+	k_ESteamNetworkingConfig_OutOfOrderCorrectionWindowMicroseconds = 51,
+
 //
 // Callbacks
 //
@@ -1506,24 +1621,24 @@ enum ESteamNetworkingConfigValue
 // Settings for SDR relayed connections
 //
 
-	/// [int32 global] If the first N pings to a port all fail, mark that port as unavailable for
+	/// [global int32] If the first N pings to a port all fail, mark that port as unavailable for
 	/// a while, and try a different one.  Some ISPs and routers may drop the first
 	/// packet, so setting this to 1 may greatly disrupt communications.
 	k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFailInitial = 19,
 
-	/// [int32 global] If N consecutive pings to a port fail, after having received successful 
+	/// [global int32] If N consecutive pings to a port fail, after having received successful 
 	/// communication, mark that port as unavailable for a while, and try a 
 	/// different one.
 	k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFail = 20,
 
-	/// [int32 global] Minimum number of lifetime pings we need to send, before we think our estimate
+	/// [global int32] Minimum number of lifetime pings we need to send, before we think our estimate
 	/// is solid.  The first ping to each cluster is very often delayed because of NAT,
 	/// routers not having the best route, etc.  Until we've sent a sufficient number
 	/// of pings, our estimate is often inaccurate.  Keep pinging until we get this
 	/// many pings.
 	k_ESteamNetworkingConfig_SDRClient_MinPingsBeforePingAccurate = 21,
 
-	/// [int32 global] Set all steam datagram traffic to originate from the same
+	/// [global int32] Set all steam datagram traffic to originate from the same
 	/// local port. By default, we open up a new UDP socket (on a different local
 	/// port) for each relay.  This is slightly less optimal, but it works around
 	/// some routers that don't implement NAT properly.  If you have intermittent
@@ -1535,10 +1650,13 @@ enum ESteamNetworkingConfigValue
 	/// only use relays in that cluster.  E.g. 'iad'
 	k_ESteamNetworkingConfig_SDRClient_ForceRelayCluster = 29,
 
-	/// [connection string] For debugging, generate our own (unsigned) ticket, using
+	/// [connection string] For development, a base-64 encoded ticket generated
-	/// the specified  gameserver address.  Router must be configured to accept unsigned
+	/// using the cert tool.  This can be used to connect to a gameserver via SDR
-	/// tickets.
+	/// without a ticket generated using the game coordinator.  (You will still
-	k_ESteamNetworkingConfig_SDRClient_DebugTicketAddress = 30,
+	/// need a key that is trusted for your app, however.)
+	///
+	/// This can also be passed using the SDR_DEVTICKET environment variable
+	k_ESteamNetworkingConfig_SDRClient_DevTicket = 30,
 
 	/// [global string] For debugging.  Override list of relays from the config with
 	/// this set (maybe just one).  Comma-separated list.
@@ -1551,6 +1669,10 @@ enum ESteamNetworkingConfigValue
 	/// in production.
 	k_ESteamNetworkingConfig_SDRClient_FakeClusterPing = 36,
 
+	/// [global int32] When probing the SteamDatagram network, we limit exploration
+	/// to the closest N POPs, based on our current best approximated ping to that POP.
+	k_ESteamNetworkingConfig_SDRClient_LimitPingProbesToNearestN = 60,
+
 //
 // Log levels for debugging information of various subsystems.
 // Higher numeric values will cause more stuff to be printed.
@@ -1566,6 +1688,10 @@ enum ESteamNetworkingConfigValue
 	k_ESteamNetworkingConfig_LogLevel_P2PRendezvous = 17, // [connection int32] P2P rendezvous messages
 	k_ESteamNetworkingConfig_LogLevel_SDRRelayPings = 18, // [global int32] Ping relays
 
+	// Experimental.  Set the ECN header field on all outbound UDP packets
+	// -1 = the default, and means "don't set anything".
+	// 0..3 = set that value.  (Even though 0 is the default UDP ECN value, a 0 here means "explicitly set a 0".)
+	k_ESteamNetworkingConfig_ECN = 999,
 
 	// Deleted, do not use
 	k_ESteamNetworkingConfig_DELETED_EnumerateDevVars = 35,
@@ -1770,8 +1896,6 @@ inline bool SteamNetworkingIdentity::SetXboxPairwiseID( const char *pszString )
 inline const char *SteamNetworkingIdentity::GetXboxPairwiseID() const { return m_eType == k_ESteamNetworkingIdentityType_XboxPairwiseID ? m_szXboxPairwiseID : NULL; }
 inline void SteamNetworkingIdentity::SetPSNID( uint64 id ) { m_eType = k_ESteamNetworkingIdentityType_SonyPSN; m_cbSize = sizeof( m_PSNID ); m_PSNID = id; }
 inline uint64 SteamNetworkingIdentity::GetPSNID() const { return m_eType == k_ESteamNetworkingIdentityType_SonyPSN ? m_PSNID : 0; }
-inline void SteamNetworkingIdentity::SetStadiaID( uint64 id ) { m_eType = k_ESteamNetworkingIdentityType_GoogleStadia; m_cbSize = sizeof( m_stadiaID ); m_stadiaID = id; }
-inline uint64 SteamNetworkingIdentity::GetStadiaID() const { return m_eType == k_ESteamNetworkingIdentityType_GoogleStadia ? m_stadiaID : 0; }
 inline void SteamNetworkingIdentity::SetIPAddr( const SteamNetworkingIPAddr &addr ) { m_eType = k_ESteamNetworkingIdentityType_IPAddress; m_cbSize = (int)sizeof(m_ip); m_ip = addr; }
 inline const SteamNetworkingIPAddr *SteamNetworkingIdentity::GetIPAddr() const { return m_eType == k_ESteamNetworkingIdentityType_IPAddress ? &m_ip : NULL; }
 inline void SteamNetworkingIdentity::SetIPv4Addr( uint32 nIPv4, uint16 nPort ) { m_eType = k_ESteamNetworkingIdentityType_IPAddress; m_cbSize = (int)sizeof(m_ip); m_ip.SetIPv4( nIPv4, nPort ); }

Generator/steam_sdk/steamtypes.h

@@ -98,6 +98,7 @@ typedef uint64 SteamAPICall_t;
 const SteamAPICall_t k_uAPICallInvalid = 0x0;
 
 typedef uint32 AccountID_t;
+const AccountID_t k_uAccountIdInvalid = 0;
 
 // Party Beacon ID
 typedef uint64 PartyBeaconID_t;