Commits

Didrole committed 034c56b

Regenerated Steam4NET2

Comments (0)

Files changed (22)

Steam4NET2/Steam4NET2/Steam4NET.csproj

     <Compile Include="autogen\ISteamFriends010.cs" />
     <Compile Include="autogen\ISteamFriends011.cs" />
     <Compile Include="autogen\ISteamFriends012.cs" />
+    <Compile Include="autogen\ISteamFriends013.cs" />
     <Compile Include="autogen\ISteamGameCoordinator001.cs" />
     <Compile Include="autogen\ISteamGameServer002.cs" />
     <Compile Include="autogen\ISteamGameServer003.cs" />
     <Compile Include="autogen\ISteamRemoteStorage004.cs" />
     <Compile Include="autogen\ISteamRemoteStorage005.cs" />
     <Compile Include="autogen\ISteamRemoteStorage006.cs" />
+    <Compile Include="autogen\ISteamRemoteStorage007.cs" />
+    <Compile Include="autogen\ISteamRemoteStorage008.cs" />
     <Compile Include="autogen\ISteamScreenshots001.cs" />
     <Compile Include="autogen\ISteamUser004.cs" />
     <Compile Include="autogen\ISteamUser005.cs" />
     <Compile Include="autogen\ISteamUserStats008.cs" />
     <Compile Include="autogen\ISteamUserStats009.cs" />
     <Compile Include="autogen\ISteamUserStats010.cs" />
+    <Compile Include="autogen\ISteamUserStats011.cs" />
     <Compile Include="autogen\ISteamUtils001.cs" />
     <Compile Include="autogen\ISteamUtils002.cs" />
     <Compile Include="autogen\ISteamUtils003.cs" />

Steam4NET2/Steam4NET2/autogen/AppsCommon.cs

 		public UInt64 m_unBytesDownloaded;
 		public UInt64 m_unBytesToProcess;
 		public UInt64 m_unBytesProcessed;
+		public UInt32 m_uUnk;
 	};
 	
 	[StructLayout(LayoutKind.Sequential,Pack=8)]
 	public enum EAppDownloadPriority : int
 	{
 		k_EAppDownloadPriorityNone = 0,
-		k_EAppDownloadPriorityTop = 1,
+		k_EAppDownloadPriorityFirst = 1,
 		k_EAppDownloadPriorityUp = 2,
 		k_EAppDownloadPriorityDown = 3,
+		k_EAppDownloadPriorityLast = 4,
+		k_EAppDownloadPriorityPaused = 5,
 	};
 	
 	public enum EAppUpdateError : int
 		k_EAppErrorInvalidApplicationConfiguration = 22,
 		k_EAppErrorInvalidContentConfiguration = 23,
 		k_EAppErrorMissingManifest = 24,
+		k_EAppErrorNotReleased = 25,
+		k_EAppErrorRegionRestricted = 26,
 	};
 	
 	public enum ERegisterActivactionCodeResult : int
 		k_ERegisterActivactionCodeAlreadyOwned = 4,
 	};
 	
+	public enum EAppOwernshipFlags : int
+	{
+		k_EAppOwernshipFlagsNone = 0,
+		k_EAppOwernshipFlagsOwnsLicense = 1,
+		k_EAppOwernshipFlagsFreeLicense = 2,
+		k_EAppOwernshipFlagsRegionRestricted = 4,
+		k_EAppOwernshipFlagsLowViolence = 8,
+	};
+	
+	public enum EAppReleaseState : int
+	{
+		k_EAppReleaseStateUnknown = 0,
+		k_EAppReleaseStateUnavailable = 1,
+		k_EAppReleaseStatePrerelease = 2,
+		k_EAppReleaseStatePreloadonly = 3,
+		k_EAppReleaseStateReleased = 4,
+	};
+	
 	[StructLayout(LayoutKind.Sequential,Pack=8)]
 	public struct SHADigestWrapper_t
 	{

Steam4NET2/Steam4NET2/autogen/BillingCommon.cs

 	};
 	
 	[StructLayout(LayoutKind.Sequential,Pack=8)]
+	[InteropHelp.CallbackIdentity(412)]
+	public struct RequestFreeLicenseResponse_t
+	{
+		public const int k_iCallback = 412;
+		public EResult m_EResult;
+		public UInt32 m_uAppId;
+	};
+	
+	[StructLayout(LayoutKind.Sequential,Pack=8)]
 	[InteropHelp.CallbackIdentity(414)]
 	public struct OEMTicketActivationResponse_t
 	{

Steam4NET2/Steam4NET2/autogen/FriendsCommon.cs

 		k_nUserRestrictionRating = 16,
 	};
 	
+	public enum EOverlayToStoreFlag : int
+	{
+		k_EOverlayToStoreFlagNone = 0,
+		k_EOverlayToStoreFlagAddToCart = 1,
+	};
+	
 	[StructLayout(LayoutKind.Sequential,Pack=8)]
 	public struct FriendSessionStateInfo_t
 	{
 		public UInt32 m_nAppID;
 		[MarshalAs(UnmanagedType.I1)]
 		public bool m_bWebPage;
+		public EOverlayToStoreFlag m_eFlag;
 	};
 	
 	[StructLayout(LayoutKind.Sequential,Pack=8)]

Steam4NET2/Steam4NET2/autogen/IClientAppManager.cs

 		public IntPtr UninstallApp2;
 		public IntPtr LaunchApp3;
 		public IntPtr ShutdownApp4;
-		public IntPtr GetAppState5;
+		public IntPtr GetAppInstallState5;
 		public IntPtr GetAppSizeOnDisk6;
 		public IntPtr GetAppDir7;
 		public IntPtr GetAppDependency8;
 		public IntPtr GetDependentApps9;
-		public IntPtr GetUpdateInfo10;
-		public IntPtr SetContentLocked11;
-		public IntPtr StartValidatingApp12;
-		public IntPtr SetAppConfig13;
-		public IntPtr BIsAppUpToDate14;
-		public IntPtr BCheckBetaPassword15;
-		public IntPtr SetDownloadingEnabled16;
-		public IntPtr BIsDownloadingEnabled17;
-		public IntPtr GetDownloadStats18;
-		public IntPtr GetDownloadingAppID19;
-		public IntPtr ChangeAppPriority20;
-		public IntPtr AddSteam2Update21;
-		public IntPtr RemoveSteam2Update22;
-		public IntPtr StalledSteam2Update23;
-		public IntPtr BHasLocalContentServer24;
-		public IntPtr BuildBackup25;
-		public IntPtr BuildInstaller26;
-		public IntPtr CancelBackup27;
-		public IntPtr RestoreApp28;
-		public IntPtr BNeedsFile29;
-		public IntPtr BAddFileOnDisk30;
-		public IntPtr FinishAddingFiles31;
-		private IntPtr DTorIClientAppManager32;
+		public IntPtr RemoveAppDependencies10;
+		public IntPtr GetUpdateInfo11;
+		public IntPtr SetContentLocked12;
+		public IntPtr StartValidatingApp13;
+		public IntPtr SetAppConfig14;
+		public IntPtr BIsAppUpToDate15;
+		public IntPtr BCacheBetaPassword16;
+		public IntPtr BRequestBetaPasswords17;
+		public IntPtr BIsCachedBetaPasswordValid18;
+		public IntPtr SetDownloadingEnabled19;
+		public IntPtr BIsDownloadingEnabled20;
+		public IntPtr GetDownloadStats21;
+		public IntPtr GetDownloadingAppID22;
+		public IntPtr ChangeAppPriority23;
+		public IntPtr AddSteam2Update24;
+		public IntPtr RemoveSteam2Update25;
+		public IntPtr StalledSteam2Update26;
+		public IntPtr BHasLocalContentServer27;
+		public IntPtr BuildBackup28;
+		public IntPtr BuildInstaller29;
+		public IntPtr CancelBackup30;
+		public IntPtr RestoreApp31;
+		public IntPtr BNeedsFile32;
+		public IntPtr BAddFileOnDisk33;
+		public IntPtr FinishAddingFiles34;
+		public IntPtr GetAppStateInfo35;
+		private IntPtr DTorIClientAppManager36;
 	};
 	
 	[InteropHelp.InterfaceVersion("CLIENTAPPMANAGER_INTERFACE_VERSION001")]
 			return this.GetFunction<NativeShutdownAppUB>( this.Functions.ShutdownApp4 )( this.ObjectAddress, unAppID, bForce ); 
 		}
 		
-		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EAppState NativeGetAppStateU( IntPtr thisptr, UInt32 unAppID );
-		public EAppState GetAppState( UInt32 unAppID ) 
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EAppState NativeGetAppInstallStateU( IntPtr thisptr, UInt32 unAppID );
+		public EAppState GetAppInstallState( UInt32 unAppID ) 
 		{
-			return this.GetFunction<NativeGetAppStateU>( this.Functions.GetAppState5 )( this.ObjectAddress, unAppID ); 
+			return this.GetFunction<NativeGetAppInstallStateU>( this.Functions.GetAppInstallState5 )( this.ObjectAddress, unAppID ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 			return this.GetFunction<NativeGetDependentAppsUUI>( this.Functions.GetDependentApps9 )( this.ObjectAddress, unAppID, ref punAppIDs, cAppIDsMax ); 
 		}
 		
+		[return: MarshalAs(UnmanagedType.I1)]
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeRemoveAppDependenciesU( IntPtr thisptr, UInt32 unAppID );
+		public bool RemoveAppDependencies( UInt32 unAppID ) 
+		{
+			return this.GetFunction<NativeRemoveAppDependenciesU>( this.Functions.RemoveAppDependencies10 )( this.ObjectAddress, unAppID ); 
+		}
+		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetUpdateInfoUA( IntPtr thisptr, UInt32 unAppID, ref AppUpdateInfo_s pUpdateInfo );
 		public UInt32 GetUpdateInfo( UInt32 unAppID, ref AppUpdateInfo_s pUpdateInfo ) 
 		{
-			return this.GetFunction<NativeGetUpdateInfoUA>( this.Functions.GetUpdateInfo10 )( this.ObjectAddress, unAppID, ref pUpdateInfo ); 
+			return this.GetFunction<NativeGetUpdateInfoUA>( this.Functions.GetUpdateInfo11 )( this.ObjectAddress, unAppID, ref pUpdateInfo ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeSetContentLockedUB( IntPtr thisptr, UInt32 unAppID, [MarshalAs(UnmanagedType.I1)] bool bLockContent );
 		public bool SetContentLocked( UInt32 unAppID, bool bLockContent ) 
 		{
-			return this.GetFunction<NativeSetContentLockedUB>( this.Functions.SetContentLocked11 )( this.ObjectAddress, unAppID, bLockContent ); 
+			return this.GetFunction<NativeSetContentLockedUB>( this.Functions.SetContentLocked12 )( this.ObjectAddress, unAppID, bLockContent ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeStartValidatingAppU( IntPtr thisptr, UInt32 unAppID );
 		public bool StartValidatingApp( UInt32 unAppID ) 
 		{
-			return this.GetFunction<NativeStartValidatingAppU>( this.Functions.StartValidatingApp12 )( this.ObjectAddress, unAppID ); 
+			return this.GetFunction<NativeStartValidatingAppU>( this.Functions.StartValidatingApp13 )( this.ObjectAddress, unAppID ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeSetAppConfigUBIB( IntPtr thisptr, UInt32 unAppID, Byte[] pchBuffer, Int32 cbBuffer, [MarshalAs(UnmanagedType.I1)] bool bSharedKVSymbols );
 		public bool SetAppConfig( UInt32 unAppID, Byte[] pchBuffer, bool bSharedKVSymbols ) 
 		{
-			return this.GetFunction<NativeSetAppConfigUBIB>( this.Functions.SetAppConfig13 )( this.ObjectAddress, unAppID, pchBuffer, (Int32) pchBuffer.Length, bSharedKVSymbols ); 
+			return this.GetFunction<NativeSetAppConfigUBIB>( this.Functions.SetAppConfig14 )( this.ObjectAddress, unAppID, pchBuffer, (Int32) pchBuffer.Length, bSharedKVSymbols ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBIsAppUpToDateU( IntPtr thisptr, UInt32 unAppID );
 		public bool BIsAppUpToDate( UInt32 unAppID ) 
 		{
-			return this.GetFunction<NativeBIsAppUpToDateU>( this.Functions.BIsAppUpToDate14 )( this.ObjectAddress, unAppID ); 
+			return this.GetFunction<NativeBIsAppUpToDateU>( this.Functions.BIsAppUpToDate15 )( this.ObjectAddress, unAppID ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
-		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBCheckBetaPasswordUSS( IntPtr thisptr, UInt32 unAppID, string cszBetaKey, string cszBetaPassword );
-		public bool BCheckBetaPassword( UInt32 unAppID, string cszBetaKey, string cszBetaPassword ) 
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBCacheBetaPasswordUSS( IntPtr thisptr, UInt32 unAppID, string cszBetaKey, string cszBetaPassword );
+		public bool BCacheBetaPassword( UInt32 unAppID, string cszBetaKey, string cszBetaPassword ) 
 		{
-			return this.GetFunction<NativeBCheckBetaPasswordUSS>( this.Functions.BCheckBetaPassword15 )( this.ObjectAddress, unAppID, cszBetaKey, cszBetaPassword ); 
+			return this.GetFunction<NativeBCacheBetaPasswordUSS>( this.Functions.BCacheBetaPassword16 )( this.ObjectAddress, unAppID, cszBetaKey, cszBetaPassword ); 
+		}
+		
+		[return: MarshalAs(UnmanagedType.I1)]
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBRequestBetaPasswordsU( IntPtr thisptr, UInt32 unAppID );
+		public bool BRequestBetaPasswords( UInt32 unAppID ) 
+		{
+			return this.GetFunction<NativeBRequestBetaPasswordsU>( this.Functions.BRequestBetaPasswords17 )( this.ObjectAddress, unAppID ); 
+		}
+		
+		[return: MarshalAs(UnmanagedType.I1)]
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBIsCachedBetaPasswordValidUS( IntPtr thisptr, UInt32 unAppID, string cszBetaKey );
+		public bool BIsCachedBetaPasswordValid( UInt32 unAppID, string cszBetaKey ) 
+		{
+			return this.GetFunction<NativeBIsCachedBetaPasswordValidUS>( this.Functions.BIsCachedBetaPasswordValid18 )( this.ObjectAddress, unAppID, cszBetaKey ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeSetDownloadingEnabledB( IntPtr thisptr, [MarshalAs(UnmanagedType.I1)] bool bState );
 		public bool SetDownloadingEnabled( bool bState ) 
 		{
-			return this.GetFunction<NativeSetDownloadingEnabledB>( this.Functions.SetDownloadingEnabled16 )( this.ObjectAddress, bState ); 
+			return this.GetFunction<NativeSetDownloadingEnabledB>( this.Functions.SetDownloadingEnabled19 )( this.ObjectAddress, bState ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBIsDownloadingEnabled( IntPtr thisptr );
 		public bool BIsDownloadingEnabled(  ) 
 		{
-			return this.GetFunction<NativeBIsDownloadingEnabled>( this.Functions.BIsDownloadingEnabled17 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeBIsDownloadingEnabled>( this.Functions.BIsDownloadingEnabled20 )( this.ObjectAddress ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetDownloadStatsD( IntPtr thisptr, ref DownloadStats_s pDownloadStats );
 		public bool GetDownloadStats( ref DownloadStats_s pDownloadStats ) 
 		{
-			return this.GetFunction<NativeGetDownloadStatsD>( this.Functions.GetDownloadStats18 )( this.ObjectAddress, ref pDownloadStats ); 
+			return this.GetFunction<NativeGetDownloadStatsD>( this.Functions.GetDownloadStats21 )( this.ObjectAddress, ref pDownloadStats ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetDownloadingAppID( IntPtr thisptr );
 		public UInt32 GetDownloadingAppID(  ) 
 		{
-			return this.GetFunction<NativeGetDownloadingAppID>( this.Functions.GetDownloadingAppID19 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeGetDownloadingAppID>( this.Functions.GetDownloadingAppID22 )( this.ObjectAddress ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeChangeAppPriorityUE( IntPtr thisptr, UInt32 unAppID, EAppDownloadPriority ePriority );
 		public bool ChangeAppPriority( UInt32 unAppID, EAppDownloadPriority ePriority ) 
 		{
-			return this.GetFunction<NativeChangeAppPriorityUE>( this.Functions.ChangeAppPriority20 )( this.ObjectAddress, unAppID, ePriority ); 
+			return this.GetFunction<NativeChangeAppPriorityUE>( this.Functions.ChangeAppPriority23 )( this.ObjectAddress, unAppID, ePriority ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeAddSteam2UpdateU( IntPtr thisptr, UInt32 unAppID );
 		public bool AddSteam2Update( UInt32 unAppID ) 
 		{
-			return this.GetFunction<NativeAddSteam2UpdateU>( this.Functions.AddSteam2Update21 )( this.ObjectAddress, unAppID ); 
+			return this.GetFunction<NativeAddSteam2UpdateU>( this.Functions.AddSteam2Update24 )( this.ObjectAddress, unAppID ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeRemoveSteam2UpdateU( IntPtr thisptr, UInt32 unAppID );
 		public bool RemoveSteam2Update( UInt32 unAppID ) 
 		{
-			return this.GetFunction<NativeRemoveSteam2UpdateU>( this.Functions.RemoveSteam2Update22 )( this.ObjectAddress, unAppID ); 
+			return this.GetFunction<NativeRemoveSteam2UpdateU>( this.Functions.RemoveSteam2Update25 )( this.ObjectAddress, unAppID ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeStalledSteam2UpdateU( IntPtr thisptr, UInt32 unAppID );
 		public bool StalledSteam2Update( UInt32 unAppID ) 
 		{
-			return this.GetFunction<NativeStalledSteam2UpdateU>( this.Functions.StalledSteam2Update23 )( this.ObjectAddress, unAppID ); 
+			return this.GetFunction<NativeStalledSteam2UpdateU>( this.Functions.StalledSteam2Update26 )( this.ObjectAddress, unAppID ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBHasLocalContentServer( IntPtr thisptr );
 		public bool BHasLocalContentServer(  ) 
 		{
-			return this.GetFunction<NativeBHasLocalContentServer>( this.Functions.BHasLocalContentServer24 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeBHasLocalContentServer>( this.Functions.BHasLocalContentServer27 )( this.ObjectAddress ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBuildBackupUUS( IntPtr thisptr, UInt32 unAppID, UInt64 ullMaxFileSize, string cszBackupPath );
 		public bool BuildBackup( UInt32 unAppID, UInt64 ullMaxFileSize, string cszBackupPath ) 
 		{
-			return this.GetFunction<NativeBuildBackupUUS>( this.Functions.BuildBackup25 )( this.ObjectAddress, unAppID, ullMaxFileSize, cszBackupPath ); 
+			return this.GetFunction<NativeBuildBackupUUS>( this.Functions.BuildBackup28 )( this.ObjectAddress, unAppID, ullMaxFileSize, cszBackupPath ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBuildInstallerSSS( IntPtr thisptr, string cszProjectFile, string cszBackupPath, string arg2 );
 		public bool BuildInstaller( string cszProjectFile, string cszBackupPath, string arg2 ) 
 		{
-			return this.GetFunction<NativeBuildInstallerSSS>( this.Functions.BuildInstaller26 )( this.ObjectAddress, cszProjectFile, cszBackupPath, arg2 ); 
+			return this.GetFunction<NativeBuildInstallerSSS>( this.Functions.BuildInstaller29 )( this.ObjectAddress, cszProjectFile, cszBackupPath, arg2 ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeCancelBackup( IntPtr thisptr );
 		public bool CancelBackup(  ) 
 		{
-			return this.GetFunction<NativeCancelBackup>( this.Functions.CancelBackup27 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeCancelBackup>( this.Functions.CancelBackup30 )( this.ObjectAddress ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EAppUpdateError NativeRestoreAppUS( IntPtr thisptr, UInt32 unAppID, string cszBackupPath );
 		public EAppUpdateError RestoreApp( UInt32 unAppID, string cszBackupPath ) 
 		{
-			return this.GetFunction<NativeRestoreAppUS>( this.Functions.RestoreApp28 )( this.ObjectAddress, unAppID, cszBackupPath ); 
+			return this.GetFunction<NativeRestoreAppUS>( this.Functions.RestoreApp31 )( this.ObjectAddress, unAppID, cszBackupPath ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBNeedsFileUSUU( IntPtr thisptr, UInt32 unAppID, string cszFilePath, UInt64 ullFileSize, UInt32 uUnk );
 		public bool BNeedsFile( UInt32 unAppID, string cszFilePath, UInt64 ullFileSize, UInt32 uUnk ) 
 		{
-			return this.GetFunction<NativeBNeedsFileUSUU>( this.Functions.BNeedsFile29 )( this.ObjectAddress, unAppID, cszFilePath, ullFileSize, uUnk ); 
+			return this.GetFunction<NativeBNeedsFileUSUU>( this.Functions.BNeedsFile32 )( this.ObjectAddress, unAppID, cszFilePath, ullFileSize, uUnk ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBAddFileOnDiskUSUUS( IntPtr thisptr, UInt32 unAppID, string cszFilePath, UInt64 ullFileSize, UInt32 uUnk, SHADigestWrapper_t ubSha1 );
 		public bool BAddFileOnDisk( UInt32 unAppID, string cszFilePath, UInt64 ullFileSize, UInt32 uUnk, SHADigestWrapper_t ubSha1 ) 
 		{
-			return this.GetFunction<NativeBAddFileOnDiskUSUUS>( this.Functions.BAddFileOnDisk30 )( this.ObjectAddress, unAppID, cszFilePath, ullFileSize, uUnk, ubSha1 ); 
+			return this.GetFunction<NativeBAddFileOnDiskUSUUS>( this.Functions.BAddFileOnDisk33 )( this.ObjectAddress, unAppID, cszFilePath, ullFileSize, uUnk, ubSha1 ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeFinishAddingFilesU( IntPtr thisptr, UInt32 unAppID );
 		public UInt64 FinishAddingFiles( UInt32 unAppID ) 
 		{
-			return this.GetFunction<NativeFinishAddingFilesU>( this.Functions.FinishAddingFiles31 )( this.ObjectAddress, unAppID ); 
+			return this.GetFunction<NativeFinishAddingFilesU>( this.Functions.FinishAddingFiles34 )( this.ObjectAddress, unAppID ); 
+		}
+		
+		[return: MarshalAs(UnmanagedType.I1)]
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetAppStateInfoUEE( IntPtr thisptr, UInt32 unAppID, ref EAppReleaseState peReleaseState, ref EAppOwernshipFlags peOwernshipFlags );
+		public bool GetAppStateInfo( UInt32 unAppID, ref EAppReleaseState peReleaseState, ref EAppOwernshipFlags peOwernshipFlags ) 
+		{
+			return this.GetFunction<NativeGetAppStateInfoUEE>( this.Functions.GetAppStateInfo35 )( this.ObjectAddress, unAppID, ref peReleaseState, ref peOwernshipFlags ); 
 		}
 		
 	};

Steam4NET2/Steam4NET2/autogen/IClientBilling.cs

 		public IntPtr EnableTestLicense38;
 		public IntPtr DisableTestLicense39;
 		public IntPtr ActivateOEMTicket40;
-		public IntPtr GetLicenseForAppID41;
-		public IntPtr GetPackageName42;
-		public IntPtr GetPackageInfo43;
-		public IntPtr GetAppsInPackage44;
-		public IntPtr GetPackageExtendedInfo45;
-		public IntPtr RequestFreeLicenseForApp46;
-		private IntPtr DTorIClientBilling47;
+		public IntPtr GetPackageName41;
+		public IntPtr GetPackageInfo42;
+		public IntPtr GetAppsInPackage43;
+		public IntPtr GetPackageExtendedInfo44;
+		public IntPtr RequestFreeLicenseForApp45;
+		private IntPtr DTorIClientBilling46;
 	};
 	
 	[InteropHelp.InterfaceVersion("CLIENTBILLING_INTERFACE_VERSION001")]
 			return this.GetFunction<NativeActivateOEMTicketS>( this.Functions.ActivateOEMTicket40 )( this.ObjectAddress, pchOEMLicenseFile ); 
 		}
 		
-		[return: MarshalAs(UnmanagedType.I1)]
-		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetLicenseForAppIDUU( IntPtr thisptr, UInt32 unAppId, ref UInt32 punPackageID );
-		public bool GetLicenseForAppID( UInt32 unAppId, ref UInt32 punPackageID ) 
-		{
-			return this.GetFunction<NativeGetLicenseForAppIDUU>( this.Functions.GetLicenseForAppID41 )( this.ObjectAddress, unAppId, ref punPackageID ); 
-		}
-		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetPackageNameUSI( IntPtr thisptr, UInt32 unPackageID, StringBuilder pchName, Int32 cubName );
 		public UInt32 GetPackageName( UInt32 unPackageID, StringBuilder pchName ) 
 		{
-			return this.GetFunction<NativeGetPackageNameUSI>( this.Functions.GetPackageName42 )( this.ObjectAddress, unPackageID, pchName, (Int32) pchName.Capacity ); 
+			return this.GetFunction<NativeGetPackageNameUSI>( this.Functions.GetPackageName41 )( this.ObjectAddress, unPackageID, pchName, (Int32) pchName.Capacity ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetPackageInfoUUUEEEIIIBB( IntPtr thisptr, UInt32 unPackageID, ref UInt32 puNumAppIds, ref UInt32 puNumDepotIDs, ref EBillingType peBillingType, ref ELicenseType peLicenseType, ref EPackageStatus pePackageStatus, ref Int32 piCodeClass, ref Int32 piGameCode, ref Int32 piTerritoryCode, ref bool pbRequiresShipping, ref bool pbIsPreorder );
 		public bool GetPackageInfo( UInt32 unPackageID, ref UInt32 puNumAppIds, ref UInt32 puNumDepotIDs, ref EBillingType peBillingType, ref ELicenseType peLicenseType, ref EPackageStatus pePackageStatus, ref Int32 piCodeClass, ref Int32 piGameCode, ref Int32 piTerritoryCode, ref bool pbRequiresShipping, ref bool pbIsPreorder ) 
 		{
-			return this.GetFunction<NativeGetPackageInfoUUUEEEIIIBB>( this.Functions.GetPackageInfo43 )( this.ObjectAddress, unPackageID, ref puNumAppIds, ref puNumDepotIDs, ref peBillingType, ref peLicenseType, ref pePackageStatus, ref piCodeClass, ref piGameCode, ref piTerritoryCode, ref pbRequiresShipping, ref pbIsPreorder ); 
+			return this.GetFunction<NativeGetPackageInfoUUUEEEIIIBB>( this.Functions.GetPackageInfo42 )( this.ObjectAddress, unPackageID, ref puNumAppIds, ref puNumDepotIDs, ref peBillingType, ref peLicenseType, ref pePackageStatus, ref piCodeClass, ref piGameCode, ref piTerritoryCode, ref pbRequiresShipping, ref pbIsPreorder ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetAppsInPackageUUUBB( IntPtr thisptr, UInt32 unPackageID, ref UInt32 puIds, UInt32 uMaxIds, [MarshalAs(UnmanagedType.I1)] bool bExcludeDepots, [MarshalAs(UnmanagedType.I1)] bool bExcludeApps );
 		public UInt32 GetAppsInPackage( UInt32 unPackageID, ref UInt32 puIds, UInt32 uMaxIds, bool bExcludeDepots, bool bExcludeApps ) 
 		{
-			return this.GetFunction<NativeGetAppsInPackageUUUBB>( this.Functions.GetAppsInPackage44 )( this.ObjectAddress, unPackageID, ref puIds, uMaxIds, bExcludeDepots, bExcludeApps ); 
+			return this.GetFunction<NativeGetAppsInPackageUUUBB>( this.Functions.GetAppsInPackage43 )( this.ObjectAddress, unPackageID, ref puIds, uMaxIds, bExcludeDepots, bExcludeApps ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetPackageExtendedInfoUBIB( IntPtr thisptr, UInt32 unPackageID, Byte[] pubData, Int32 cubData, [MarshalAs(UnmanagedType.I1)] bool bSharedKVSymbols );
 		public UInt32 GetPackageExtendedInfo( UInt32 unPackageID, Byte[] pubData, bool bSharedKVSymbols ) 
 		{
-			return this.GetFunction<NativeGetPackageExtendedInfoUBIB>( this.Functions.GetPackageExtendedInfo45 )( this.ObjectAddress, unPackageID, pubData, (Int32) pubData.Length, bSharedKVSymbols ); 
+			return this.GetFunction<NativeGetPackageExtendedInfoUBIB>( this.Functions.GetPackageExtendedInfo44 )( this.ObjectAddress, unPackageID, pubData, (Int32) pubData.Length, bSharedKVSymbols ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeRequestFreeLicenseForAppU( IntPtr thisptr, UInt32 unAppId );
 		public UInt64 RequestFreeLicenseForApp( UInt32 unAppId ) 
 		{
-			return this.GetFunction<NativeRequestFreeLicenseForAppU>( this.Functions.RequestFreeLicenseForApp46 )( this.ObjectAddress, unAppId ); 
+			return this.GetFunction<NativeRequestFreeLicenseForAppU>( this.Functions.RequestFreeLicenseForApp45 )( this.ObjectAddress, unAppId ); 
 		}
 		
 	};

Steam4NET2/Steam4NET2/autogen/IClientDepotBuilder.cs

 		public IntPtr GetManifestGIDs8;
 		public IntPtr FinishAppBuild9;
 		public IntPtr VerifyChunkStore10;
-		private IntPtr DTorIClientDepotBuilder11;
+		public IntPtr StartUploadTest11;
+		private IntPtr DTorIClientDepotBuilder12;
 	};
 	
 	[InteropHelp.InterfaceVersion("CLIENTDEPOTBUILDER_INTERFACE_VERSION001")]
 			return this.GetFunction<NativeVerifyChunkStoreUUS>( this.Functions.VerifyChunkStore10 )( this.ObjectAddress, arg0, arg1, arg2 ); 
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeStartUploadTestUU( IntPtr thisptr, UInt32 arg0, UInt32 arg1 );
+		public UInt32 StartUploadTest( UInt32 arg0, UInt32 arg1 ) 
+		{
+			return this.GetFunction<NativeStartUploadTestUU>( this.Functions.StartUploadTest11 )( this.ObjectAddress, arg0, arg1 ); 
+		}
+		
 	};
 }

Steam4NET2/Steam4NET2/autogen/IClientEngine.cs

 		public IntPtr CreateGlobalUser2;
 		public IntPtr ConnectToGlobalUser3;
 		public IntPtr CreateLocalUser4;
-		public IntPtr ReleaseUser5;
-		public IntPtr IsValidHSteamUserPipe6;
-		public IntPtr GetIClientUser7;
-		public IntPtr GetIClientGameServer8;
-		public IntPtr SetLocalIPBinding9;
-		public IntPtr GetUniverseName10;
-		public IntPtr GetIClientFriends11;
-		public IntPtr GetIClientUtils12;
-		public IntPtr GetIClientBilling13;
-		public IntPtr GetIClientMatchmaking14;
-		public IntPtr GetIClientApps15;
-		public IntPtr GetIClientContentServer16;
-		public IntPtr GetIClientMatchmakingServers17;
-		public IntPtr RunFrame18;
-		public IntPtr GetIPCCallCount19;
-		public IntPtr GetIClientUserStats20;
-		public IntPtr GetIClientGameServerStats21;
-		public IntPtr GetIClientNetworking22;
-		public IntPtr GetIClientRemoteStorage23;
-		public IntPtr GetIClientScreenshots24;
-		public IntPtr SetWarningMessageHook25;
-		public IntPtr GetIClientGameCoordinator26;
-		public IntPtr SetOverlayNotificationPosition27;
-		public IntPtr HookScreenshots28;
-		public IntPtr IsOverlayEnabled29;
-		public IntPtr GetAPICallResult30;
-		public IntPtr GetIClientDepotBuilder31;
-		public IntPtr ConCommandInit32;
-		public IntPtr GetIClientAppManager33;
-		public IntPtr GetIClientConfigStore34;
-		public IntPtr BOverlayNeedsPresent35;
-		public IntPtr GetIClientGameStats36;
-		public IntPtr GetIClientHTTP37;
-		public IntPtr BShutdownIfAllPipesClosed38;
-		public IntPtr GetIClientAudio39;
-		private IntPtr DTorIClientEngine40;
+		public IntPtr CreatePipeToLocalUser5;
+		public IntPtr ReleaseUser6;
+		public IntPtr IsValidHSteamUserPipe7;
+		public IntPtr GetIClientUser8;
+		public IntPtr GetIClientGameServer9;
+		public IntPtr SetLocalIPBinding10;
+		public IntPtr GetUniverseName11;
+		public IntPtr GetIClientFriends12;
+		public IntPtr GetIClientUtils13;
+		public IntPtr GetIClientBilling14;
+		public IntPtr GetIClientMatchmaking15;
+		public IntPtr GetIClientApps16;
+		public IntPtr GetIClientContentServer17;
+		public IntPtr GetIClientMatchmakingServers18;
+		public IntPtr RunFrame19;
+		public IntPtr GetIPCCallCount20;
+		public IntPtr GetIClientUserStats21;
+		public IntPtr GetIClientGameServerStats22;
+		public IntPtr GetIClientNetworking23;
+		public IntPtr GetIClientRemoteStorage24;
+		public IntPtr GetIClientScreenshots25;
+		public IntPtr SetWarningMessageHook26;
+		public IntPtr GetIClientGameCoordinator27;
+		public IntPtr SetOverlayNotificationPosition28;
+		public IntPtr HookScreenshots29;
+		public IntPtr IsOverlayEnabled30;
+		public IntPtr GetAPICallResult31;
+		public IntPtr GetIClientDepotBuilder32;
+		public IntPtr ConCommandInit33;
+		public IntPtr GetIClientAppManager34;
+		public IntPtr GetIClientConfigStore35;
+		public IntPtr BOverlayNeedsPresent36;
+		public IntPtr GetIClientGameStats37;
+		public IntPtr GetIClientHTTP38;
+		public IntPtr BShutdownIfAllPipesClosed39;
+		public IntPtr GetIClientAudio40;
+		private IntPtr DTorIClientEngine41;
 	};
 	
 	[InteropHelp.InterfaceVersion("CLIENTENGINE_INTERFACE_VERSION002")]
 			return this.GetFunction<NativeCreateLocalUserIE>( this.Functions.CreateLocalUser4 )( this.ObjectAddress, ref phSteamPipe, eAccountType ); 
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeCreatePipeToLocalUserII( IntPtr thisptr, Int32 hSteamUser, ref Int32 phSteamPipe );
+		public void CreatePipeToLocalUser( Int32 hSteamUser, ref Int32 phSteamPipe ) 
+		{
+			this.GetFunction<NativeCreatePipeToLocalUserII>( this.Functions.CreatePipeToLocalUser5 )( this.ObjectAddress, hSteamUser, ref phSteamPipe ); 
+		}
+		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeReleaseUserII( IntPtr thisptr, Int32 hSteamPipe, Int32 hUser );
 		public void ReleaseUser( Int32 hSteamPipe, Int32 hUser ) 
 		{
-			this.GetFunction<NativeReleaseUserII>( this.Functions.ReleaseUser5 )( this.ObjectAddress, hSteamPipe, hUser ); 
+			this.GetFunction<NativeReleaseUserII>( this.Functions.ReleaseUser6 )( this.ObjectAddress, hSteamPipe, hUser ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeIsValidHSteamUserPipeII( IntPtr thisptr, Int32 hSteamPipe, Int32 hUser );
 		public bool IsValidHSteamUserPipe( Int32 hSteamPipe, Int32 hUser ) 
 		{
-			return this.GetFunction<NativeIsValidHSteamUserPipeII>( this.Functions.IsValidHSteamUserPipe6 )( this.ObjectAddress, hSteamPipe, hUser ); 
+			return this.GetFunction<NativeIsValidHSteamUserPipeII>( this.Functions.IsValidHSteamUserPipe7 )( this.ObjectAddress, hSteamPipe, hUser ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientUserIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientUser<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientUserIIS>( this.Functions.GetIClientUser7 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientUserIIS>( this.Functions.GetIClientUser8 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientGameServerIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientGameServer<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameServerIIS>( this.Functions.GetIClientGameServer8 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameServerIIS>( this.Functions.GetIClientGameServer9 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetLocalIPBindingUU( IntPtr thisptr, UInt32 unIP, UInt16 usPort );
 		public void SetLocalIPBinding( UInt32 unIP, UInt16 usPort ) 
 		{
-			this.GetFunction<NativeSetLocalIPBindingUU>( this.Functions.SetLocalIPBinding9 )( this.ObjectAddress, unIP, usPort ); 
+			this.GetFunction<NativeSetLocalIPBindingUU>( this.Functions.SetLocalIPBinding10 )( this.ObjectAddress, unIP, usPort ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate string NativeGetUniverseNameE( IntPtr thisptr, EUniverse eUniverse );
 		public string GetUniverseName( EUniverse eUniverse ) 
 		{
-			return InteropHelp.DecodeANSIReturn( this.GetFunction<NativeGetUniverseNameE>( this.Functions.GetUniverseName10 )( this.ObjectAddress, eUniverse ) ); 
+			return InteropHelp.DecodeANSIReturn( this.GetFunction<NativeGetUniverseNameE>( this.Functions.GetUniverseName11 )( this.ObjectAddress, eUniverse ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientFriendsIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientFriends<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientFriendsIIS>( this.Functions.GetIClientFriends11 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientFriendsIIS>( this.Functions.GetIClientFriends12 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientUtilsIS( IntPtr thisptr, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientUtils<TClass>( Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientUtilsIS>( this.Functions.GetIClientUtils12 )( this.ObjectAddress, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientUtilsIS>( this.Functions.GetIClientUtils13 )( this.ObjectAddress, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientBillingIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientBilling<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientBillingIIS>( this.Functions.GetIClientBilling13 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientBillingIIS>( this.Functions.GetIClientBilling14 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientMatchmakingIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientMatchmaking<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientMatchmakingIIS>( this.Functions.GetIClientMatchmaking14 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientMatchmakingIIS>( this.Functions.GetIClientMatchmaking15 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientAppsIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientApps<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientAppsIIS>( this.Functions.GetIClientApps15 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientAppsIIS>( this.Functions.GetIClientApps16 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientContentServerIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientContentServer<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientContentServerIIS>( this.Functions.GetIClientContentServer16 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientContentServerIIS>( this.Functions.GetIClientContentServer17 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientMatchmakingServersIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientMatchmakingServers<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientMatchmakingServersIIS>( this.Functions.GetIClientMatchmakingServers17 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientMatchmakingServersIIS>( this.Functions.GetIClientMatchmakingServers18 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeRunFrame( IntPtr thisptr );
 		public void RunFrame(  ) 
 		{
-			this.GetFunction<NativeRunFrame>( this.Functions.RunFrame18 )( this.ObjectAddress ); 
+			this.GetFunction<NativeRunFrame>( this.Functions.RunFrame19 )( this.ObjectAddress ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetIPCCallCount( IntPtr thisptr );
 		public UInt32 GetIPCCallCount(  ) 
 		{
-			return this.GetFunction<NativeGetIPCCallCount>( this.Functions.GetIPCCallCount19 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeGetIPCCallCount>( this.Functions.GetIPCCallCount20 )( this.ObjectAddress ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientUserStatsIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientUserStats<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientUserStatsIIS>( this.Functions.GetIClientUserStats20 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientUserStatsIIS>( this.Functions.GetIClientUserStats21 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientGameServerStatsIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientGameServerStats<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameServerStatsIIS>( this.Functions.GetIClientGameServerStats21 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameServerStatsIIS>( this.Functions.GetIClientGameServerStats22 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientNetworkingIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientNetworking<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientNetworkingIIS>( this.Functions.GetIClientNetworking22 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientNetworkingIIS>( this.Functions.GetIClientNetworking23 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientRemoteStorageIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientRemoteStorage<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientRemoteStorageIIS>( this.Functions.GetIClientRemoteStorage23 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientRemoteStorageIIS>( this.Functions.GetIClientRemoteStorage24 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientScreenshotsIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientScreenshots<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientScreenshotsIIS>( this.Functions.GetIClientScreenshots24 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientScreenshotsIIS>( this.Functions.GetIClientScreenshots25 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetWarningMessageHookI( IntPtr thisptr, ref IntPtr pFunction );
 		public void SetWarningMessageHook( ref IntPtr pFunction ) 
 		{
-			this.GetFunction<NativeSetWarningMessageHookI>( this.Functions.SetWarningMessageHook25 )( this.ObjectAddress, ref pFunction ); 
+			this.GetFunction<NativeSetWarningMessageHookI>( this.Functions.SetWarningMessageHook26 )( this.ObjectAddress, ref pFunction ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientGameCoordinatorIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientGameCoordinator<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameCoordinatorIIS>( this.Functions.GetIClientGameCoordinator26 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameCoordinatorIIS>( this.Functions.GetIClientGameCoordinator27 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetOverlayNotificationPositionE( IntPtr thisptr, ENotificationPosition eNotificationPosition );
 		public void SetOverlayNotificationPosition( ENotificationPosition eNotificationPosition ) 
 		{
-			this.GetFunction<NativeSetOverlayNotificationPositionE>( this.Functions.SetOverlayNotificationPosition27 )( this.ObjectAddress, eNotificationPosition ); 
+			this.GetFunction<NativeSetOverlayNotificationPositionE>( this.Functions.SetOverlayNotificationPosition28 )( this.ObjectAddress, eNotificationPosition ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeHookScreenshotsB( IntPtr thisptr, [MarshalAs(UnmanagedType.I1)] bool bHook );
 		public bool HookScreenshots( bool bHook ) 
 		{
-			return this.GetFunction<NativeHookScreenshotsB>( this.Functions.HookScreenshots28 )( this.ObjectAddress, bHook ); 
+			return this.GetFunction<NativeHookScreenshotsB>( this.Functions.HookScreenshots29 )( this.ObjectAddress, bHook ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeIsOverlayEnabled( IntPtr thisptr );
 		public bool IsOverlayEnabled(  ) 
 		{
-			return this.GetFunction<NativeIsOverlayEnabled>( this.Functions.IsOverlayEnabled29 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeIsOverlayEnabled>( this.Functions.IsOverlayEnabled30 )( this.ObjectAddress ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetAPICallResultIUBIIB( IntPtr thisptr, Int32 hSteamPipe, UInt64 hSteamAPICall, Byte[] pCallback, Int32 cubCallback, Int32 iCallbackExpected, ref bool pbFailed );
 		public bool GetAPICallResult( Int32 hSteamPipe, UInt64 hSteamAPICall, Byte[] pCallback, Int32 iCallbackExpected, ref bool pbFailed ) 
 		{
-			return this.GetFunction<NativeGetAPICallResultIUBIIB>( this.Functions.GetAPICallResult30 )( this.ObjectAddress, hSteamPipe, hSteamAPICall, pCallback, (Int32) pCallback.Length, iCallbackExpected, ref pbFailed ); 
+			return this.GetFunction<NativeGetAPICallResultIUBIIB>( this.Functions.GetAPICallResult31 )( this.ObjectAddress, hSteamPipe, hSteamAPICall, pCallback, (Int32) pCallback.Length, iCallbackExpected, ref pbFailed ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientDepotBuilderIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientDepotBuilder<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientDepotBuilderIIS>( this.Functions.GetIClientDepotBuilder31 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientDepotBuilderIIS>( this.Functions.GetIClientDepotBuilder32 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeConCommandInitI( IntPtr thisptr, ref IntPtr pAccessor );
 		public void ConCommandInit( ref IntPtr pAccessor ) 
 		{
-			this.GetFunction<NativeConCommandInitI>( this.Functions.ConCommandInit32 )( this.ObjectAddress, ref pAccessor ); 
+			this.GetFunction<NativeConCommandInitI>( this.Functions.ConCommandInit33 )( this.ObjectAddress, ref pAccessor ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientAppManagerIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientAppManager<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientAppManagerIIS>( this.Functions.GetIClientAppManager33 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientAppManagerIIS>( this.Functions.GetIClientAppManager34 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientConfigStoreIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientConfigStore<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientConfigStoreIIS>( this.Functions.GetIClientConfigStore34 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientConfigStoreIIS>( this.Functions.GetIClientConfigStore35 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBOverlayNeedsPresent( IntPtr thisptr );
 		public bool BOverlayNeedsPresent(  ) 
 		{
-			return this.GetFunction<NativeBOverlayNeedsPresent>( this.Functions.BOverlayNeedsPresent35 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeBOverlayNeedsPresent>( this.Functions.BOverlayNeedsPresent36 )( this.ObjectAddress ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientGameStatsIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientGameStats<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameStatsIIS>( this.Functions.GetIClientGameStats36 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientGameStatsIIS>( this.Functions.GetIClientGameStats37 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientHTTPIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientHTTP<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientHTTPIIS>( this.Functions.GetIClientHTTP37 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientHTTPIIS>( this.Functions.GetIClientHTTP38 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBShutdownIfAllPipesClosed( IntPtr thisptr );
 		public bool BShutdownIfAllPipesClosed(  ) 
 		{
-			return this.GetFunction<NativeBShutdownIfAllPipesClosed>( this.Functions.BShutdownIfAllPipesClosed38 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeBShutdownIfAllPipesClosed>( this.Functions.BShutdownIfAllPipesClosed39 )( this.ObjectAddress ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate IntPtr NativeGetIClientAudioIIS( IntPtr thisptr, Int32 hSteamUser, Int32 hSteamPipe, string pchVersion );
 		public TClass GetIClientAudio<TClass>( Int32 hSteamUser, Int32 hSteamPipe ) where TClass : InteropHelp.INativeWrapper, new()
 		{
-			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientAudioIIS>( this.Functions.GetIClientAudio39 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
+			return InteropHelp.CastInterface<TClass>( this.GetFunction<NativeGetIClientAudioIIS>( this.Functions.GetIClientAudio40 )( this.ObjectAddress, hSteamUser, hSteamPipe, InterfaceVersions.GetInterfaceIdentifier( typeof( TClass ) ) ) ); 
 		}
 		
 	};

Steam4NET2/Steam4NET2/autogen/IClientFriends.cs

 			this.GetFunction<NativeActivateGameOverlayToWebPageS>( this.Functions.ActivateGameOverlayToWebPage180 )( this.ObjectAddress, pchURL ); 
 		}
 		
-		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeActivateGameOverlayToStoreU( IntPtr thisptr, UInt32 nAppId );
-		public void ActivateGameOverlayToStore( UInt32 nAppId ) 
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeActivateGameOverlayToStoreUE( IntPtr thisptr, UInt32 nAppId, EOverlayToStoreFlag eFlag );
+		public void ActivateGameOverlayToStore( UInt32 nAppId, EOverlayToStoreFlag eFlag ) 
 		{
-			this.GetFunction<NativeActivateGameOverlayToStoreU>( this.Functions.ActivateGameOverlayToStore181 )( this.ObjectAddress, nAppId ); 
+			this.GetFunction<NativeActivateGameOverlayToStoreUE>( this.Functions.ActivateGameOverlayToStore181 )( this.ObjectAddress, nAppId, eFlag ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeActivateGameOverlayInviteDialogC( IntPtr thisptr, UInt64 steamIDLobby );

Steam4NET2/Steam4NET2/autogen/IClientRemoteStorage.cs

 		public IntPtr GetFileTimestamp8;
 		public IntPtr SetSyncPlatforms9;
 		public IntPtr GetSyncPlatforms10;
-		public IntPtr GetFileCount11;
-		public IntPtr GetFileNameAndSize12;
-		public IntPtr GetQuota13;
-		public IntPtr IsCloudEnabledForAccount14;
-		public IntPtr IsCloudEnabledForApp15;
-		public IntPtr SetCloudEnabledForApp16;
-		public IntPtr UGCDownload17;
-		public IntPtr GetUGCDownloadProgress18;
-		public IntPtr GetUGCDetails19;
-		public IntPtr UGCRead20;
-		public IntPtr GetCachedUGCCount21;
-		public IntPtr GetCachedUGCHandle22;
-		public IntPtr PublishFile23;
-		public IntPtr PublishVideo24;
-		public IntPtr CreatePublishedFileUpdateRequest25;
-		public IntPtr UpdatePublishedFileFile26;
-		public IntPtr UpdatePublishedFilePreviewFile27;
-		public IntPtr UpdatePublishedFileTitle28;
-		public IntPtr UpdatePublishedFileDescription29;
-		public IntPtr UpdatePublishedFileSetChangeDescription30;
-		public IntPtr UpdatePublishedFileVisibility31;
-		public IntPtr UpdatePublishedFileTags32;
-		public IntPtr UpdatePublishedFileURL33;
-		public IntPtr CommitPublishedFileUpdate34;
-		public IntPtr GetPublishedFileDetails35;
-		public IntPtr DeletePublishedFile36;
-		public IntPtr EnumerateUserPublishedFiles37;
-		public IntPtr SubscribePublishedFile38;
-		public IntPtr EnumerateUserSubscribedFiles39;
-		public IntPtr UnsubscribePublishedFile40;
-		public IntPtr SetUserPublishedFileAction41;
-		public IntPtr EnumeratePublishedFilesByUserAction42;
-		public IntPtr GetCREItemVoteSummary43;
-		public IntPtr UpdateUserPublishedItemVote44;
-		public IntPtr GetUserPublishedItemVoteDetails45;
-		public IntPtr EnumerateUserSharedWorkshopFiles46;
-		public IntPtr EnumeratePublishedWorkshopFiles47;
-		public IntPtr EGetFileSyncState48;
-		public IntPtr BIsFileSyncing49;
-		public IntPtr FilePersist50;
-		public IntPtr FileFetch51;
-		public IntPtr ResolvePath52;
-		public IntPtr FileTouch53;
-		public IntPtr SetCloudEnabledForAccount54;
-		public IntPtr LoadLocalFileInfoCache55;
-		public IntPtr EvaluateRemoteStorageSyncState56;
-		public IntPtr GetRemoteStorageSyncState57;
-		public IntPtr HaveLatestFilesLocally58;
-		public IntPtr GetConflictingFileTimestamps59;
-		public IntPtr ResolveSyncConflict60;
-		public IntPtr SynchronizeApp61;
-		public IntPtr IsAppSyncInProgress62;
-		public IntPtr ERemoteStorageFileRootFromName63;
-		public IntPtr PchNameFromERemoteStorageFileRoot64;
-		public IntPtr ResetFileRequestState65;
-		public IntPtr ClearPublishFileUpdateRequests66;
-		private IntPtr DTorIClientRemoteStorage67;
+		public IntPtr FileWriteStreamOpen11;
+		public IntPtr FileWriteStreamClose12;
+		public IntPtr FileWriteStreamCancel13;
+		public IntPtr FileWriteStreamWriteChunk14;
+		public IntPtr GetFileCount15;
+		public IntPtr GetFileNameAndSize16;
+		public IntPtr GetQuota17;
+		public IntPtr IsCloudEnabledForAccount18;
+		public IntPtr IsCloudEnabledForApp19;
+		public IntPtr SetCloudEnabledForApp20;
+		public IntPtr UGCDownload21;
+		public IntPtr GetUGCDownloadProgress22;
+		public IntPtr GetUGCDetails23;
+		public IntPtr UGCRead24;
+		public IntPtr GetCachedUGCCount25;
+		public IntPtr GetCachedUGCHandle26;
+		public IntPtr PublishFile27;
+		public IntPtr PublishVideo28;
+		public IntPtr PublishVideoFromURL29;
+		public IntPtr CreatePublishedFileUpdateRequest30;
+		public IntPtr UpdatePublishedFileFile31;
+		public IntPtr UpdatePublishedFilePreviewFile32;
+		public IntPtr UpdatePublishedFileTitle33;
+		public IntPtr UpdatePublishedFileDescription34;
+		public IntPtr UpdatePublishedFileSetChangeDescription35;
+		public IntPtr UpdatePublishedFileVisibility36;
+		public IntPtr UpdatePublishedFileTags37;
+		public IntPtr UpdatePublishedFileURL38;
+		public IntPtr CommitPublishedFileUpdate39;
+		public IntPtr GetPublishedFileDetails40;
+		public IntPtr DeletePublishedFile41;
+		public IntPtr EnumerateUserPublishedFiles42;
+		public IntPtr SubscribePublishedFile43;
+		public IntPtr EnumerateUserSubscribedFiles44;
+		public IntPtr UnsubscribePublishedFile45;
+		public IntPtr SetUserPublishedFileAction46;
+		public IntPtr EnumeratePublishedFilesByUserAction47;
+		public IntPtr GetCREItemVoteSummary48;
+		public IntPtr UpdateUserPublishedItemVote49;
+		public IntPtr GetUserPublishedItemVoteDetails50;
+		public IntPtr EnumerateUserSharedWorkshopFiles51;
+		public IntPtr EnumeratePublishedWorkshopFiles52;
+		public IntPtr EGetFileSyncState53;
+		public IntPtr BIsFileSyncing54;
+		public IntPtr FilePersist55;
+		public IntPtr FileFetch56;
+		public IntPtr ResolvePath57;
+		public IntPtr FileTouch58;
+		public IntPtr SetCloudEnabledForAccount59;
+		public IntPtr LoadLocalFileInfoCache60;
+		public IntPtr EvaluateRemoteStorageSyncState61;
+		public IntPtr GetRemoteStorageSyncState62;
+		public IntPtr HaveLatestFilesLocally63;
+		public IntPtr GetConflictingFileTimestamps64;
+		public IntPtr ResolveSyncConflict65;
+		public IntPtr SynchronizeApp66;
+		public IntPtr IsAppSyncInProgress67;
+		public IntPtr ERemoteStorageFileRootFromName68;
+		public IntPtr PchNameFromERemoteStorageFileRoot69;
+		public IntPtr ResetFileRequestState70;
+		public IntPtr ClearPublishFileUpdateRequests71;
+		private IntPtr DTorIClientRemoteStorage72;
 	};
 	
 	[InteropHelp.InterfaceVersion("CLIENTREMOTESTORAGE_INTERFACE_VERSION001")]
 			return this.GetFunction<NativeGetSyncPlatformsUES>( this.Functions.GetSyncPlatforms10 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
 		}
 		
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeFileWriteStreamOpenUES( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile );
+		public UInt64 FileWriteStreamOpen( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile ) 
+		{
+			return this.GetFunction<NativeFileWriteStreamOpenUES>( this.Functions.FileWriteStreamOpen11 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
+		}
+		
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFileWriteStreamCloseU( IntPtr thisptr, UInt64 hStream );
+		public EResult FileWriteStreamClose( UInt64 hStream ) 
+		{
+			return this.GetFunction<NativeFileWriteStreamCloseU>( this.Functions.FileWriteStreamClose12 )( this.ObjectAddress, hStream ); 
+		}
+		
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFileWriteStreamCancelU( IntPtr thisptr, UInt64 hStream );
+		public EResult FileWriteStreamCancel( UInt64 hStream ) 
+		{
+			return this.GetFunction<NativeFileWriteStreamCancelU>( this.Functions.FileWriteStreamCancel13 )( this.ObjectAddress, hStream ); 
+		}
+		
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFileWriteStreamWriteChunkUBI( IntPtr thisptr, UInt64 hStream, Byte[] pvData, Int32 cubData );
+		public EResult FileWriteStreamWriteChunk( UInt64 hStream, Byte[] pvData ) 
+		{
+			return this.GetFunction<NativeFileWriteStreamWriteChunkUBI>( this.Functions.FileWriteStreamWriteChunk14 )( this.ObjectAddress, hStream, pvData, (Int32) pvData.Length ); 
+		}
+		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeGetFileCountUB( IntPtr thisptr, UInt32 nAppId, [MarshalAs(UnmanagedType.I1)] bool bFromExternalAPI );
 		public Int32 GetFileCount( UInt32 nAppId, bool bFromExternalAPI ) 
 		{
-			return this.GetFunction<NativeGetFileCountUB>( this.Functions.GetFileCount11 )( this.ObjectAddress, nAppId, bFromExternalAPI ); 
+			return this.GetFunction<NativeGetFileCountUB>( this.Functions.GetFileCount15 )( this.ObjectAddress, nAppId, bFromExternalAPI ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate string NativeGetFileNameAndSizeUIEIB( IntPtr thisptr, UInt32 nAppId, Int32 iFile, ref ERemoteStorageFileRoot peRemoteStorageFileRoot, ref Int32 pnFileSizeInBytes, [MarshalAs(UnmanagedType.I1)] bool bFromExternalAPI );
 		public string GetFileNameAndSize( UInt32 nAppId, Int32 iFile, ref ERemoteStorageFileRoot peRemoteStorageFileRoot, ref Int32 pnFileSizeInBytes, bool bFromExternalAPI ) 
 		{
-			return InteropHelp.DecodeANSIReturn( this.GetFunction<NativeGetFileNameAndSizeUIEIB>( this.Functions.GetFileNameAndSize12 )( this.ObjectAddress, nAppId, iFile, ref peRemoteStorageFileRoot, ref pnFileSizeInBytes, bFromExternalAPI ) ); 
+			return InteropHelp.DecodeANSIReturn( this.GetFunction<NativeGetFileNameAndSizeUIEIB>( this.Functions.GetFileNameAndSize16 )( this.ObjectAddress, nAppId, iFile, ref peRemoteStorageFileRoot, ref pnFileSizeInBytes, bFromExternalAPI ) ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetQuotaUII( IntPtr thisptr, UInt32 nAppId, ref Int32 pnTotalBytes, ref Int32 pnAvailableBytes );
 		public bool GetQuota( UInt32 nAppId, ref Int32 pnTotalBytes, ref Int32 pnAvailableBytes ) 
 		{
-			return this.GetFunction<NativeGetQuotaUII>( this.Functions.GetQuota13 )( this.ObjectAddress, nAppId, ref pnTotalBytes, ref pnAvailableBytes ); 
+			return this.GetFunction<NativeGetQuotaUII>( this.Functions.GetQuota17 )( this.ObjectAddress, nAppId, ref pnTotalBytes, ref pnAvailableBytes ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeIsCloudEnabledForAccount( IntPtr thisptr );
 		public bool IsCloudEnabledForAccount(  ) 
 		{
-			return this.GetFunction<NativeIsCloudEnabledForAccount>( this.Functions.IsCloudEnabledForAccount14 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeIsCloudEnabledForAccount>( this.Functions.IsCloudEnabledForAccount18 )( this.ObjectAddress ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeIsCloudEnabledForAppU( IntPtr thisptr, UInt32 nAppId );
 		public bool IsCloudEnabledForApp( UInt32 nAppId ) 
 		{
-			return this.GetFunction<NativeIsCloudEnabledForAppU>( this.Functions.IsCloudEnabledForApp15 )( this.ObjectAddress, nAppId ); 
+			return this.GetFunction<NativeIsCloudEnabledForAppU>( this.Functions.IsCloudEnabledForApp19 )( this.ObjectAddress, nAppId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetCloudEnabledForAppUB( IntPtr thisptr, UInt32 nAppId, [MarshalAs(UnmanagedType.I1)] bool bEnable );
 		public void SetCloudEnabledForApp( UInt32 nAppId, bool bEnable ) 
 		{
-			this.GetFunction<NativeSetCloudEnabledForAppUB>( this.Functions.SetCloudEnabledForApp16 )( this.ObjectAddress, nAppId, bEnable ); 
+			this.GetFunction<NativeSetCloudEnabledForAppUB>( this.Functions.SetCloudEnabledForApp20 )( this.ObjectAddress, nAppId, bEnable ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeUGCDownloadUB( IntPtr thisptr, UInt64 hContent, [MarshalAs(UnmanagedType.I1)] bool bUseNewCallback );
 		public UInt64 UGCDownload( UInt64 hContent, bool bUseNewCallback ) 
 		{
-			return this.GetFunction<NativeUGCDownloadUB>( this.Functions.UGCDownload17 )( this.ObjectAddress, hContent, bUseNewCallback ); 
+			return this.GetFunction<NativeUGCDownloadUB>( this.Functions.UGCDownload21 )( this.ObjectAddress, hContent, bUseNewCallback ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetUGCDownloadProgressUUU( IntPtr thisptr, UInt64 hContent, ref UInt32 puDownloadedBytes, ref UInt32 puTotalBytes );
 		public bool GetUGCDownloadProgress( UInt64 hContent, ref UInt32 puDownloadedBytes, ref UInt32 puTotalBytes ) 
 		{
-			return this.GetFunction<NativeGetUGCDownloadProgressUUU>( this.Functions.GetUGCDownloadProgress18 )( this.ObjectAddress, hContent, ref puDownloadedBytes, ref puTotalBytes ); 
+			return this.GetFunction<NativeGetUGCDownloadProgressUUU>( this.Functions.GetUGCDownloadProgress22 )( this.ObjectAddress, hContent, ref puDownloadedBytes, ref puTotalBytes ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetUGCDetailsUUSIC( IntPtr thisptr, UInt64 hContent, ref UInt32 pnAppID, StringBuilder ppchName, ref Int32 pnFileSizeInBytes, ref UInt64 pSteamIDOwner );
 		public bool GetUGCDetails( UInt64 hContent, ref UInt32 pnAppID, StringBuilder ppchName, ref Int32 pnFileSizeInBytes, ref CSteamID pSteamIDOwner ) 
 		{
-			UInt64 s0 = 0; var result = this.GetFunction<NativeGetUGCDetailsUUSIC>( this.Functions.GetUGCDetails19 )( this.ObjectAddress, hContent, ref pnAppID, ppchName, ref pnFileSizeInBytes, ref s0 ); pSteamIDOwner = new CSteamID(s0); return result;
+			UInt64 s0 = 0; var result = this.GetFunction<NativeGetUGCDetailsUUSIC>( this.Functions.GetUGCDetails23 )( this.ObjectAddress, hContent, ref pnAppID, ppchName, ref pnFileSizeInBytes, ref s0 ); pSteamIDOwner = new CSteamID(s0); return result;
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeUGCReadUBI( IntPtr thisptr, UInt64 hContent, Byte[] pubDest, Int32 nDestBufferSize );
 		public Int32 UGCRead( UInt64 hContent, Byte[] pubDest, Int32 nDestBufferSize ) 
 		{
-			return this.GetFunction<NativeUGCReadUBI>( this.Functions.UGCRead20 )( this.ObjectAddress, hContent, pubDest, nDestBufferSize ); 
+			return this.GetFunction<NativeUGCReadUBI>( this.Functions.UGCRead24 )( this.ObjectAddress, hContent, pubDest, nDestBufferSize ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate Int32 NativeGetCachedUGCCount( IntPtr thisptr );
 		public Int32 GetCachedUGCCount(  ) 
 		{
-			return this.GetFunction<NativeGetCachedUGCCount>( this.Functions.GetCachedUGCCount21 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeGetCachedUGCCount>( this.Functions.GetCachedUGCCount25 )( this.ObjectAddress ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetCachedUGCHandleI( IntPtr thisptr, Int32 iCachedContent );
 		public UInt64 GetCachedUGCHandle( Int32 iCachedContent ) 
 		{
-			return this.GetFunction<NativeGetCachedUGCHandleI>( this.Functions.GetCachedUGCHandle22 )( this.ObjectAddress, iCachedContent ); 
+			return this.GetFunction<NativeGetCachedUGCHandleI>( this.Functions.GetCachedUGCHandle26 )( this.ObjectAddress, iCachedContent ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativePublishFileUESSUSSEBSE( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszFileName, string cszPreviewFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, [MarshalAs(UnmanagedType.I1)] bool bOverwrite, ref SteamParamStringArray_t pTags, EWorkshopFileType eType );
 		public UInt64 PublishFile( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszFileName, string cszPreviewFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, bool bOverwrite, ref SteamParamStringArray_t pTags, EWorkshopFileType eType ) 
 		{
-			return this.GetFunction<NativePublishFileUESSUSSEBSE>( this.Functions.PublishFile23 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, cszFileName, cszPreviewFileName, nConsumerAppId, cszTitle, cszDescription, eVisibility, bOverwrite, ref pTags, eType ); 
+			return this.GetFunction<NativePublishFileUESSUSSEBSE>( this.Functions.PublishFile27 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, cszFileName, cszPreviewFileName, nConsumerAppId, cszTitle, cszDescription, eVisibility, bOverwrite, ref pTags, eType ); 
 		}
 		
-		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativePublishVideoUESSUSSEBS( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszFileName, string cszPreviewFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, [MarshalAs(UnmanagedType.I1)] bool bOverwrite, ref SteamParamStringArray_t pTags );
-		public UInt64 PublishVideo( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszFileName, string cszPreviewFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, bool bOverwrite, ref SteamParamStringArray_t pTags ) 
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativePublishVideoUESSESUSSES( IntPtr thisptr, UInt32 nAppId, EWorkshopVideoProvider eVideoProvider, string cszVideoAccountName, string cszVideoIdentifier, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags );
+		public UInt64 PublishVideo( UInt32 nAppId, EWorkshopVideoProvider eVideoProvider, string cszVideoAccountName, string cszVideoIdentifier, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags ) 
 		{
-			return this.GetFunction<NativePublishVideoUESSUSSEBS>( this.Functions.PublishVideo24 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, cszFileName, cszPreviewFileName, nConsumerAppId, cszTitle, cszDescription, eVisibility, bOverwrite, ref pTags ); 
+			return this.GetFunction<NativePublishVideoUESSESUSSES>( this.Functions.PublishVideo28 )( this.ObjectAddress, nAppId, eVideoProvider, cszVideoAccountName, cszVideoIdentifier, eRemoteStorageFileRoot, cszFileName, nConsumerAppId, cszTitle, cszDescription, eVisibility, ref pTags ); 
+		}
+		
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativePublishVideoFromURLUESSUSSES( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszVideoURL, string cszFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags );
+		public UInt64 PublishVideoFromURL( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string cszVideoURL, string cszFileName, UInt32 nConsumerAppId, string cszTitle, string cszDescription, ERemoteStoragePublishedFileVisibility eVisibility, ref SteamParamStringArray_t pTags ) 
+		{
+			return this.GetFunction<NativePublishVideoFromURLUESSUSSES>( this.Functions.PublishVideoFromURL29 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, cszVideoURL, cszFileName, nConsumerAppId, cszTitle, cszDescription, eVisibility, ref pTags ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeCreatePublishedFileUpdateRequestUU( IntPtr thisptr, UInt32 nAppId, UInt64 unPublishedFileId );
 		public UInt64 CreatePublishedFileUpdateRequest( UInt32 nAppId, UInt64 unPublishedFileId ) 
 		{
-			return this.GetFunction<NativeCreatePublishedFileUpdateRequestUU>( this.Functions.CreatePublishedFileUpdateRequest25 )( this.ObjectAddress, nAppId, unPublishedFileId ); 
+			return this.GetFunction<NativeCreatePublishedFileUpdateRequestUU>( this.Functions.CreatePublishedFileUpdateRequest30 )( this.ObjectAddress, nAppId, unPublishedFileId ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileFileUS( IntPtr thisptr, UInt64 hUpdateRequest, string cszFile );
 		public bool UpdatePublishedFileFile( UInt64 hUpdateRequest, string cszFile ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFileFileUS>( this.Functions.UpdatePublishedFileFile26 )( this.ObjectAddress, hUpdateRequest, cszFile ); 
+			return this.GetFunction<NativeUpdatePublishedFileFileUS>( this.Functions.UpdatePublishedFileFile31 )( this.ObjectAddress, hUpdateRequest, cszFile ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFilePreviewFileUS( IntPtr thisptr, UInt64 hUpdateRequest, string cszPreviewFile );
 		public bool UpdatePublishedFilePreviewFile( UInt64 hUpdateRequest, string cszPreviewFile ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFilePreviewFileUS>( this.Functions.UpdatePublishedFilePreviewFile27 )( this.ObjectAddress, hUpdateRequest, cszPreviewFile ); 
+			return this.GetFunction<NativeUpdatePublishedFilePreviewFileUS>( this.Functions.UpdatePublishedFilePreviewFile32 )( this.ObjectAddress, hUpdateRequest, cszPreviewFile ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileTitleUS( IntPtr thisptr, UInt64 hUpdateRequest, string cszTitle );
 		public bool UpdatePublishedFileTitle( UInt64 hUpdateRequest, string cszTitle ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFileTitleUS>( this.Functions.UpdatePublishedFileTitle28 )( this.ObjectAddress, hUpdateRequest, cszTitle ); 
+			return this.GetFunction<NativeUpdatePublishedFileTitleUS>( this.Functions.UpdatePublishedFileTitle33 )( this.ObjectAddress, hUpdateRequest, cszTitle ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileDescriptionUS( IntPtr thisptr, UInt64 hUpdateRequest, string cszDescription );
 		public bool UpdatePublishedFileDescription( UInt64 hUpdateRequest, string cszDescription ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFileDescriptionUS>( this.Functions.UpdatePublishedFileDescription29 )( this.ObjectAddress, hUpdateRequest, cszDescription ); 
+			return this.GetFunction<NativeUpdatePublishedFileDescriptionUS>( this.Functions.UpdatePublishedFileDescription34 )( this.ObjectAddress, hUpdateRequest, cszDescription ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileSetChangeDescriptionUS( IntPtr thisptr, UInt64 hUpdateRequest, string cszDescription );
 		public bool UpdatePublishedFileSetChangeDescription( UInt64 hUpdateRequest, string cszDescription ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFileSetChangeDescriptionUS>( this.Functions.UpdatePublishedFileSetChangeDescription30 )( this.ObjectAddress, hUpdateRequest, cszDescription ); 
+			return this.GetFunction<NativeUpdatePublishedFileSetChangeDescriptionUS>( this.Functions.UpdatePublishedFileSetChangeDescription35 )( this.ObjectAddress, hUpdateRequest, cszDescription ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileVisibilityUE( IntPtr thisptr, UInt64 hUpdateRequest, ERemoteStoragePublishedFileVisibility eVisibility );
 		public bool UpdatePublishedFileVisibility( UInt64 hUpdateRequest, ERemoteStoragePublishedFileVisibility eVisibility ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFileVisibilityUE>( this.Functions.UpdatePublishedFileVisibility31 )( this.ObjectAddress, hUpdateRequest, eVisibility ); 
+			return this.GetFunction<NativeUpdatePublishedFileVisibilityUE>( this.Functions.UpdatePublishedFileVisibility36 )( this.ObjectAddress, hUpdateRequest, eVisibility ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileTagsUS( IntPtr thisptr, UInt64 hUpdateRequest, ref SteamParamStringArray_t pTags );
 		public bool UpdatePublishedFileTags( UInt64 hUpdateRequest, ref SteamParamStringArray_t pTags ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFileTagsUS>( this.Functions.UpdatePublishedFileTags32 )( this.ObjectAddress, hUpdateRequest, ref pTags ); 
+			return this.GetFunction<NativeUpdatePublishedFileTagsUS>( this.Functions.UpdatePublishedFileTags37 )( this.ObjectAddress, hUpdateRequest, ref pTags ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeUpdatePublishedFileURLUS( IntPtr thisptr, UInt64 hUpdateRequest, string cszURL );
 		public bool UpdatePublishedFileURL( UInt64 hUpdateRequest, string cszURL ) 
 		{
-			return this.GetFunction<NativeUpdatePublishedFileURLUS>( this.Functions.UpdatePublishedFileURL33 )( this.ObjectAddress, hUpdateRequest, cszURL ); 
+			return this.GetFunction<NativeUpdatePublishedFileURLUS>( this.Functions.UpdatePublishedFileURL38 )( this.ObjectAddress, hUpdateRequest, cszURL ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeCommitPublishedFileUpdateUEU( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, UInt64 hUpdateRequest );
 		public UInt64 CommitPublishedFileUpdate( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, UInt64 hUpdateRequest ) 
 		{
-			return this.GetFunction<NativeCommitPublishedFileUpdateUEU>( this.Functions.CommitPublishedFileUpdate34 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, hUpdateRequest ); 
+			return this.GetFunction<NativeCommitPublishedFileUpdateUEU>( this.Functions.CommitPublishedFileUpdate39 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, hUpdateRequest ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetPublishedFileDetailsUB( IntPtr thisptr, UInt64 unPublishedFileId, [MarshalAs(UnmanagedType.I1)] bool bUseNewCallback );
 		public UInt64 GetPublishedFileDetails( UInt64 unPublishedFileId, bool bUseNewCallback ) 
 		{
-			return this.GetFunction<NativeGetPublishedFileDetailsUB>( this.Functions.GetPublishedFileDetails35 )( this.ObjectAddress, unPublishedFileId, bUseNewCallback ); 
+			return this.GetFunction<NativeGetPublishedFileDetailsUB>( this.Functions.GetPublishedFileDetails40 )( this.ObjectAddress, unPublishedFileId, bUseNewCallback ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeDeletePublishedFileU( IntPtr thisptr, UInt64 unPublishedFileId );
 		public UInt64 DeletePublishedFile( UInt64 unPublishedFileId ) 
 		{
-			return this.GetFunction<NativeDeletePublishedFileU>( this.Functions.DeletePublishedFile36 )( this.ObjectAddress, unPublishedFileId ); 
+			return this.GetFunction<NativeDeletePublishedFileU>( this.Functions.DeletePublishedFile41 )( this.ObjectAddress, unPublishedFileId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumerateUserPublishedFilesUUE( IntPtr thisptr, UInt32 nAppId, UInt32 uStartIndex, ERemoteStoragePublishedFileSortOrder eOrder );
 		public UInt64 EnumerateUserPublishedFiles( UInt32 nAppId, UInt32 uStartIndex, ERemoteStoragePublishedFileSortOrder eOrder ) 
 		{
-			return this.GetFunction<NativeEnumerateUserPublishedFilesUUE>( this.Functions.EnumerateUserPublishedFiles37 )( this.ObjectAddress, nAppId, uStartIndex, eOrder ); 
+			return this.GetFunction<NativeEnumerateUserPublishedFilesUUE>( this.Functions.EnumerateUserPublishedFiles42 )( this.ObjectAddress, nAppId, uStartIndex, eOrder ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeSubscribePublishedFileUU( IntPtr thisptr, UInt32 nAppId, UInt64 unPublishedFileId );
 		public UInt64 SubscribePublishedFile( UInt32 nAppId, UInt64 unPublishedFileId ) 
 		{
-			return this.GetFunction<NativeSubscribePublishedFileUU>( this.Functions.SubscribePublishedFile38 )( this.ObjectAddress, nAppId, unPublishedFileId ); 
+			return this.GetFunction<NativeSubscribePublishedFileUU>( this.Functions.SubscribePublishedFile43 )( this.ObjectAddress, nAppId, unPublishedFileId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumerateUserSubscribedFilesUU( IntPtr thisptr, UInt32 nAppId, UInt32 uStartIndex );
 		public UInt64 EnumerateUserSubscribedFiles( UInt32 nAppId, UInt32 uStartIndex ) 
 		{
-			return this.GetFunction<NativeEnumerateUserSubscribedFilesUU>( this.Functions.EnumerateUserSubscribedFiles39 )( this.ObjectAddress, nAppId, uStartIndex ); 
+			return this.GetFunction<NativeEnumerateUserSubscribedFilesUU>( this.Functions.EnumerateUserSubscribedFiles44 )( this.ObjectAddress, nAppId, uStartIndex ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeUnsubscribePublishedFileUU( IntPtr thisptr, UInt32 nAppId, UInt64 unPublishedFileId );
 		public UInt64 UnsubscribePublishedFile( UInt32 nAppId, UInt64 unPublishedFileId ) 
 		{
-			return this.GetFunction<NativeUnsubscribePublishedFileUU>( this.Functions.UnsubscribePublishedFile40 )( this.ObjectAddress, nAppId, unPublishedFileId ); 
+			return this.GetFunction<NativeUnsubscribePublishedFileUU>( this.Functions.UnsubscribePublishedFile45 )( this.ObjectAddress, nAppId, unPublishedFileId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeSetUserPublishedFileActionUUE( IntPtr thisptr, UInt32 nAppId, UInt64 unPublishedFileId, EWorkshopFileAction eAction );
 		public UInt64 SetUserPublishedFileAction( UInt32 nAppId, UInt64 unPublishedFileId, EWorkshopFileAction eAction ) 
 		{
-			return this.GetFunction<NativeSetUserPublishedFileActionUUE>( this.Functions.SetUserPublishedFileAction41 )( this.ObjectAddress, nAppId, unPublishedFileId, eAction ); 
+			return this.GetFunction<NativeSetUserPublishedFileActionUUE>( this.Functions.SetUserPublishedFileAction46 )( this.ObjectAddress, nAppId, unPublishedFileId, eAction ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumeratePublishedFilesByUserActionUEU( IntPtr thisptr, UInt32 nAppId, EWorkshopFileAction eAction, UInt32 uStartIndex );
 		public UInt64 EnumeratePublishedFilesByUserAction( UInt32 nAppId, EWorkshopFileAction eAction, UInt32 uStartIndex ) 
 		{
-			return this.GetFunction<NativeEnumeratePublishedFilesByUserActionUEU>( this.Functions.EnumeratePublishedFilesByUserAction42 )( this.ObjectAddress, nAppId, eAction, uStartIndex ); 
+			return this.GetFunction<NativeEnumeratePublishedFilesByUserActionUEU>( this.Functions.EnumeratePublishedFilesByUserAction47 )( this.ObjectAddress, nAppId, eAction, uStartIndex ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetCREItemVoteSummaryU( IntPtr thisptr, UInt64 unPublishedFileId );
 		public UInt64 GetCREItemVoteSummary( UInt64 unPublishedFileId ) 
 		{
-			return this.GetFunction<NativeGetCREItemVoteSummaryU>( this.Functions.GetCREItemVoteSummary43 )( this.ObjectAddress, unPublishedFileId ); 
+			return this.GetFunction<NativeGetCREItemVoteSummaryU>( this.Functions.GetCREItemVoteSummary48 )( this.ObjectAddress, unPublishedFileId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeUpdateUserPublishedItemVoteUB( IntPtr thisptr, UInt64 unPublishedFileId, [MarshalAs(UnmanagedType.I1)] bool bVoteUp );
 		public UInt64 UpdateUserPublishedItemVote( UInt64 unPublishedFileId, bool bVoteUp ) 
 		{
-			return this.GetFunction<NativeUpdateUserPublishedItemVoteUB>( this.Functions.UpdateUserPublishedItemVote44 )( this.ObjectAddress, unPublishedFileId, bVoteUp ); 
+			return this.GetFunction<NativeUpdateUserPublishedItemVoteUB>( this.Functions.UpdateUserPublishedItemVote49 )( this.ObjectAddress, unPublishedFileId, bVoteUp ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetUserPublishedItemVoteDetailsU( IntPtr thisptr, UInt64 unPublishedFileId );
 		public UInt64 GetUserPublishedItemVoteDetails( UInt64 unPublishedFileId ) 
 		{
-			return this.GetFunction<NativeGetUserPublishedItemVoteDetailsU>( this.Functions.GetUserPublishedItemVoteDetails45 )( this.ObjectAddress, unPublishedFileId ); 
+			return this.GetFunction<NativeGetUserPublishedItemVoteDetailsU>( this.Functions.GetUserPublishedItemVoteDetails50 )( this.ObjectAddress, unPublishedFileId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumerateUserSharedWorkshopFilesUCUSS( IntPtr thisptr, UInt32 nAppId, UInt64 creatorSteamID, UInt32 uStartIndex, ref SteamParamStringArray_t pRequiredTags, ref SteamParamStringArray_t pExcludedTags );
 		public UInt64 EnumerateUserSharedWorkshopFiles( UInt32 nAppId, CSteamID creatorSteamID, UInt32 uStartIndex, ref SteamParamStringArray_t pRequiredTags, ref SteamParamStringArray_t pExcludedTags ) 
 		{
-			return this.GetFunction<NativeEnumerateUserSharedWorkshopFilesUCUSS>( this.Functions.EnumerateUserSharedWorkshopFiles46 )( this.ObjectAddress, nAppId, creatorSteamID.ConvertToUint64(), uStartIndex, ref pRequiredTags, ref pExcludedTags ); 
+			return this.GetFunction<NativeEnumerateUserSharedWorkshopFilesUCUSS>( this.Functions.EnumerateUserSharedWorkshopFiles51 )( this.ObjectAddress, nAppId, creatorSteamID.ConvertToUint64(), uStartIndex, ref pRequiredTags, ref pExcludedTags ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeEnumeratePublishedWorkshopFilesUEUUUSS( IntPtr thisptr, UInt32 nAppId, EWorkshopEnumerationType eType, UInt32 uStartIndex, UInt32 cDays, UInt32 cCount, ref SteamParamStringArray_t pTags, ref SteamParamStringArray_t pUserTags );
 		public UInt64 EnumeratePublishedWorkshopFiles( UInt32 nAppId, EWorkshopEnumerationType eType, UInt32 uStartIndex, UInt32 cDays, UInt32 cCount, ref SteamParamStringArray_t pTags, ref SteamParamStringArray_t pUserTags ) 
 		{
-			return this.GetFunction<NativeEnumeratePublishedWorkshopFilesUEUUUSS>( this.Functions.EnumeratePublishedWorkshopFiles47 )( this.ObjectAddress, nAppId, eType, uStartIndex, cDays, cCount, ref pTags, ref pUserTags ); 
+			return this.GetFunction<NativeEnumeratePublishedWorkshopFilesUEUUUSS>( this.Functions.EnumeratePublishedWorkshopFiles52 )( this.ObjectAddress, nAppId, eType, uStartIndex, cDays, cCount, ref pTags, ref pUserTags ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EFileRemoteStorageSyncState NativeEGetFileSyncStateUES( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile );
 		public EFileRemoteStorageSyncState EGetFileSyncState( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile ) 
 		{
-			return this.GetFunction<NativeEGetFileSyncStateUES>( this.Functions.EGetFileSyncState48 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
+			return this.GetFunction<NativeEGetFileSyncStateUES>( this.Functions.EGetFileSyncState53 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBIsFileSyncingUES( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile );
 		public bool BIsFileSyncing( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile ) 
 		{
-			return this.GetFunction<NativeBIsFileSyncingUES>( this.Functions.BIsFileSyncing49 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
+			return this.GetFunction<NativeBIsFileSyncingUES>( this.Functions.BIsFileSyncing54 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFilePersistUES( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile );
 		public EResult FilePersist( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile ) 
 		{
-			return this.GetFunction<NativeFilePersistUES>( this.Functions.FilePersist50 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
+			return this.GetFunction<NativeFilePersistUES>( this.Functions.FilePersist55 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeFileFetchUES( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile );
 		public bool FileFetch( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile ) 
 		{
-			return this.GetFunction<NativeFileFetchUES>( this.Functions.FileFetch51 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
+			return this.GetFunction<NativeFileFetchUES>( this.Functions.FileFetch56 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeResolvePathUESSU( IntPtr thisptr, UInt32 nAppID, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchRelPath, StringBuilder pchDest, UInt32 cchDest );
 		public bool ResolvePath( UInt32 nAppID, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchRelPath, StringBuilder pchDest ) 
 		{
-			return this.GetFunction<NativeResolvePathUESSU>( this.Functions.ResolvePath52 )( this.ObjectAddress, nAppID, eRemoteStorageFileRoot, pchRelPath, pchDest, (UInt32) pchDest.Capacity ); 
+			return this.GetFunction<NativeResolvePathUESSU>( this.Functions.ResolvePath57 )( this.ObjectAddress, nAppID, eRemoteStorageFileRoot, pchRelPath, pchDest, (UInt32) pchDest.Capacity ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate EResult NativeFileTouchUESB( IntPtr thisptr, UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile, [MarshalAs(UnmanagedType.I1)] bool arg3 );
 		public EResult FileTouch( UInt32 nAppId, ERemoteStorageFileRoot eRemoteStorageFileRoot, string pchFile, bool arg3 ) 
 		{
-			return this.GetFunction<NativeFileTouchUESB>( this.Functions.FileTouch53 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile, arg3 ); 
+			return this.GetFunction<NativeFileTouchUESB>( this.Functions.FileTouch58 )( this.ObjectAddress, nAppId, eRemoteStorageFileRoot, pchFile, arg3 ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetCloudEnabledForAccountB( IntPtr thisptr, [MarshalAs(UnmanagedType.I1)] bool bEnabled );
 		public void SetCloudEnabledForAccount( bool bEnabled ) 
 		{
-			this.GetFunction<NativeSetCloudEnabledForAccountB>( this.Functions.SetCloudEnabledForAccount54 )( this.ObjectAddress, bEnabled ); 
+			this.GetFunction<NativeSetCloudEnabledForAccountB>( this.Functions.SetCloudEnabledForAccount59 )( this.ObjectAddress, bEnabled ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeLoadLocalFileInfoCacheU( IntPtr thisptr, UInt32 nAppId );
 		public void LoadLocalFileInfoCache( UInt32 nAppId ) 
 		{
-			this.GetFunction<NativeLoadLocalFileInfoCacheU>( this.Functions.LoadLocalFileInfoCache55 )( this.ObjectAddress, nAppId ); 
+			this.GetFunction<NativeLoadLocalFileInfoCacheU>( this.Functions.LoadLocalFileInfoCache60 )( this.ObjectAddress, nAppId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeEvaluateRemoteStorageSyncStateU( IntPtr thisptr, UInt32 nAppId );
 		public void EvaluateRemoteStorageSyncState( UInt32 nAppId ) 
 		{
-			this.GetFunction<NativeEvaluateRemoteStorageSyncStateU>( this.Functions.EvaluateRemoteStorageSyncState56 )( this.ObjectAddress, nAppId ); 
+			this.GetFunction<NativeEvaluateRemoteStorageSyncStateU>( this.Functions.EvaluateRemoteStorageSyncState61 )( this.ObjectAddress, nAppId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate ERemoteStorageSyncState NativeGetRemoteStorageSyncStateU( IntPtr thisptr, UInt32 nAppId );
 		public ERemoteStorageSyncState GetRemoteStorageSyncState( UInt32 nAppId ) 
 		{
-			return this.GetFunction<NativeGetRemoteStorageSyncStateU>( this.Functions.GetRemoteStorageSyncState57 )( this.ObjectAddress, nAppId ); 
+			return this.GetFunction<NativeGetRemoteStorageSyncStateU>( this.Functions.GetRemoteStorageSyncState62 )( this.ObjectAddress, nAppId ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeHaveLatestFilesLocallyU( IntPtr thisptr, UInt32 nAppId );
 		public bool HaveLatestFilesLocally( UInt32 nAppId ) 
 		{
-			return this.GetFunction<NativeHaveLatestFilesLocallyU>( this.Functions.HaveLatestFilesLocally58 )( this.ObjectAddress, nAppId ); 
+			return this.GetFunction<NativeHaveLatestFilesLocallyU>( this.Functions.HaveLatestFilesLocally63 )( this.ObjectAddress, nAppId ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeGetConflictingFileTimestampsUUU( IntPtr thisptr, UInt32 nAppId, ref UInt32 pnTimestampLocal, ref UInt32 pnTimestampRemote );
 		public bool GetConflictingFileTimestamps( UInt32 nAppId, ref UInt32 pnTimestampLocal, ref UInt32 pnTimestampRemote ) 
 		{
-			return this.GetFunction<NativeGetConflictingFileTimestampsUUU>( this.Functions.GetConflictingFileTimestamps59 )( this.ObjectAddress, nAppId, ref pnTimestampLocal, ref pnTimestampRemote ); 
+			return this.GetFunction<NativeGetConflictingFileTimestampsUUU>( this.Functions.GetConflictingFileTimestamps64 )( this.ObjectAddress, nAppId, ref pnTimestampLocal, ref pnTimestampRemote ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeResolveSyncConflictUB( IntPtr thisptr, UInt32 nAppId, [MarshalAs(UnmanagedType.I1)] bool bAcceptLocalFiles );
 		public bool ResolveSyncConflict( UInt32 nAppId, bool bAcceptLocalFiles ) 
 		{
-			return this.GetFunction<NativeResolveSyncConflictUB>( this.Functions.ResolveSyncConflict60 )( this.ObjectAddress, nAppId, bAcceptLocalFiles ); 
+			return this.GetFunction<NativeResolveSyncConflictUB>( this.Functions.ResolveSyncConflict65 )( this.ObjectAddress, nAppId, bAcceptLocalFiles ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeSynchronizeAppUBB( IntPtr thisptr, UInt32 nAppId, [MarshalAs(UnmanagedType.I1)] bool bSyncClient, [MarshalAs(UnmanagedType.I1)] bool bSyncServer );
 		public bool SynchronizeApp( UInt32 nAppId, bool bSyncClient, bool bSyncServer ) 
 		{
-			return this.GetFunction<NativeSynchronizeAppUBB>( this.Functions.SynchronizeApp61 )( this.ObjectAddress, nAppId, bSyncClient, bSyncServer ); 
+			return this.GetFunction<NativeSynchronizeAppUBB>( this.Functions.SynchronizeApp66 )( this.ObjectAddress, nAppId, bSyncClient, bSyncServer ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeIsAppSyncInProgressU( IntPtr thisptr, UInt32 nAppId );
 		public bool IsAppSyncInProgress( UInt32 nAppId ) 
 		{
-			return this.GetFunction<NativeIsAppSyncInProgressU>( this.Functions.IsAppSyncInProgress62 )( this.ObjectAddress, nAppId ); 
+			return this.GetFunction<NativeIsAppSyncInProgressU>( this.Functions.IsAppSyncInProgress67 )( this.ObjectAddress, nAppId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate ERemoteStorageFileRoot NativeERemoteStorageFileRootFromNameS( IntPtr thisptr, string pchName );
 		public ERemoteStorageFileRoot ERemoteStorageFileRootFromName( string pchName ) 
 		{
-			return this.GetFunction<NativeERemoteStorageFileRootFromNameS>( this.Functions.ERemoteStorageFileRootFromName63 )( this.ObjectAddress, pchName ); 
+			return this.GetFunction<NativeERemoteStorageFileRootFromNameS>( this.Functions.ERemoteStorageFileRootFromName68 )( this.ObjectAddress, pchName ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate string NativePchNameFromERemoteStorageFileRootE( IntPtr thisptr, ERemoteStorageFileRoot eRemoteStorageFileRoot );
 		public string PchNameFromERemoteStorageFileRoot( ERemoteStorageFileRoot eRemoteStorageFileRoot ) 
 		{
-			return InteropHelp.DecodeANSIReturn( this.GetFunction<NativePchNameFromERemoteStorageFileRootE>( this.Functions.PchNameFromERemoteStorageFileRoot64 )( this.ObjectAddress, eRemoteStorageFileRoot ) ); 
+			return InteropHelp.DecodeANSIReturn( this.GetFunction<NativePchNameFromERemoteStorageFileRootE>( this.Functions.PchNameFromERemoteStorageFileRoot69 )( this.ObjectAddress, eRemoteStorageFileRoot ) ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeResetFileRequestStateU( IntPtr thisptr, UInt32 nAppId );
 		public bool ResetFileRequestState( UInt32 nAppId ) 
 		{
-			return this.GetFunction<NativeResetFileRequestStateU>( this.Functions.ResetFileRequestState65 )( this.ObjectAddress, nAppId ); 
+			return this.GetFunction<NativeResetFileRequestStateU>( this.Functions.ResetFileRequestState70 )( this.ObjectAddress, nAppId ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeClearPublishFileUpdateRequestsU( IntPtr thisptr, UInt32 nAppId );
 		public void ClearPublishFileUpdateRequests( UInt32 nAppId ) 
 		{
-			this.GetFunction<NativeClearPublishFileUpdateRequestsU>( this.Functions.ClearPublishFileUpdateRequests66 )( this.ObjectAddress, nAppId ); 
+			this.GetFunction<NativeClearPublishFileUpdateRequestsU>( this.Functions.ClearPublishFileUpdateRequests71 )( this.ObjectAddress, nAppId ); 
 		}
 		
 	};

Steam4NET2/Steam4NET2/autogen/IClientUser.cs

 		public IntPtr RequestWebAuthToken52;
 		public IntPtr GetCurrentWebAuthToken53;
 		public IntPtr GetLanguage54;
-		public IntPtr SetCyberCafe55;
-		public IntPtr CreateAccount56;
-		public IntPtr ResetPassword57;
-		public IntPtr TrackNatTraversalStat58;
-		public IntPtr GetPackageIDForGuestPassToRedeemByGID59;
-		public IntPtr TrackSteamUsageEvent60;
-		public IntPtr TrackSteamGUIUsage61;
-		public IntPtr SetComputerInUse62;
-		public IntPtr BIsGameRunning63;
-		public IntPtr GetCurrentSessionToken64;
-		public IntPtr BUpdateAppOwnershipTicket65;
-		public IntPtr RequestCustomBinary66;
-		public IntPtr GetCustomBinariesState67;
-		public IntPtr RequestCustomBinaries68;
-		public IntPtr SetCellID69;
-		public IntPtr SetWinningPingTimeForCellID70;
-		public IntPtr GetUserBaseFolder71;
-		public IntPtr GetUserDataFolder72;
-		public IntPtr GetUserConfigFolder73;
-		public IntPtr GetAccountName74;
-		public IntPtr IsPasswordRemembered75;
-		public IntPtr RequiresLegacyCDKey76;
-		public IntPtr GetLegacyCDKey77;
-		public IntPtr HasLegacyCDKey78;
-		public IntPtr SetLegacyCDKey79;
-		public IntPtr RemoveLegacyCDKey80;
-		public IntPtr RequestLegacyCDKeyFromApp81;
-		public IntPtr BIsAnyGameRunning82;
-		public IntPtr ChangePassword83;
-		public IntPtr ChangeEmail84;
-		public IntPtr ChangeSecretQuestionAndAnswer85;
-		public IntPtr SetSteam2FullASTicket86;
-		public IntPtr GetSteam2FullASTicket87;
-		public IntPtr GetEmail88;
-		public IntPtr RequestForgottenPasswordEmail89;
-		public IntPtr FindAccountsByEmailAddress90;
-		public IntPtr FindAccountsByCdKey91;
-		public IntPtr GetNumAccountsWithEmailAddress92;
-		public IntPtr IsAccountNameInUse93;
-		public IntPtr Test_FakeConnectionTimeout94;
-		public IntPtr RunInstallScript95;
-		public IntPtr IsInstallScriptRunning96;
-		public IntPtr GetInstallScriptString97;
-		public IntPtr GetInstallScriptState98;
-		public IntPtr SpawnProcess99;
-		public IntPtr GetAppOwnershipTicketLength100;
-		public IntPtr GetAppOwnershipTicketData101;
-		public IntPtr GetAppOwnershipTicketExtendedData102;
-		public IntPtr GetAppDecryptionKey103;
-		public IntPtr GetMarketingMessageCount104;
-		public IntPtr GetMarketingMessage105;
-		public IntPtr GetAuthSessionTicket106;
-		public IntPtr BeginAuthSession107;
-		public IntPtr EndAuthSession108;
-		public IntPtr CancelAuthTicket109;
-		public IntPtr IsUserSubscribedAppInTicket110;
-		public IntPtr AdvertiseGame111;
-		public IntPtr RequestEncryptedAppTicket112;
-		public IntPtr GetEncryptedAppTicket113;
-		public IntPtr RequestOAuthTokenForApp114;
-		public IntPtr GetOAuthTokenForApp115;
-		public IntPtr InvalidateOAuthTokenForApp116;
-		public IntPtr SetAccountLimited117;
-		public IntPtr BIsAccountLimited118;
-		public IntPtr SetAccountCommunityBanned119;
-		public IntPtr BIsAccountCommunityBanned120;
-		public IntPtr SendValidationEmail121;
-		public IntPtr BGameConnectTokensAvailable122;
-		public IntPtr NumGamesRunning123;
-		public IntPtr GetRunningGameID124;
-		public IntPtr GetAccountSecurityPolicyFlags125;
-		public IntPtr RequestChangeEmail126;
-		public IntPtr ChangePasswordWithCode127;
-		public IntPtr ChangeEmailWithCode128;
-		public IntPtr ChangeSecretQuestionAndAnswerWithCode129;
-		public IntPtr SetClientStat130;
-		public IntPtr VerifyPassword131;
-		public IntPtr BSupportUser132;
-		public IntPtr BIsAppOverlayEnabled133;
-		public IntPtr BIsBehindNAT134;
-		public IntPtr GetMicroTxnAppID135;
-		public IntPtr GetMicroTxnOrderID136;
-		public IntPtr BGetMicroTxnPrice137;
-		public IntPtr GetMicroTxnLineItemCount138;
-		public IntPtr BGetMicroTxnLineItem139;
-		public IntPtr BIsSandboxMicroTxn140;
-		public IntPtr AuthorizeMicroTxn141;
-		public IntPtr NotifyAppMicroTxnAuthResponse142;
-		public IntPtr BGetWalletBalance143;
-		public IntPtr RequestMicroTxnInfo144;
-		public IntPtr BGetAppMinutesPlayed145;
-		public IntPtr BGetGuideURL146;
-		public IntPtr GetClientAppListResponse_AddApp147;
-		public IntPtr GetClientAppListResponse_AddDLC148;
-		public IntPtr GetClientAppListResponse_Done149;
-		public IntPtr PostUIResultToClientJob150;
-		public IntPtr BPromptToVerifyEmail151;
-		public IntPtr BPromptToChangePassword152;
-		public IntPtr BAccountLocked153;
-		public IntPtr BAccountShouldShowLockUI154;
-		public IntPtr BAccountLockedByIPT155;
-		public IntPtr GetCountAuthedComputers156;
-		public IntPtr GetSteamGuardProvider157;
-		public IntPtr GetSteamGuardRequireCodeByDefault158;
-		public IntPtr ShowSteamGuardProviderOptions159;
-		public IntPtr SteamGuardProviderMobileIsOption160;
-		public IntPtr BAccountCanUseIPT161;
-		public IntPtr ChangeTwoFactorAuthOptions162;
-		public IntPtr ChangeSteamGuardOptions163;
-		public IntPtr Set2ndFactorAuthCode164;
-		public IntPtr BAccountHasIPTConfig165;
-		public IntPtr GetEmailDomainFromLogonFailure166;
-		public IntPtr BIsSubscribedApp167;
-		public IntPtr RegisterActivationCode168;
-		public IntPtr OptionalDLCInstallation169;
-		public IntPtr AckSystemIM170;
-		public IntPtr RequestSpecialSurvey171;
-		public IntPtr SendSpecialSurveyResponse172;
-		public IntPtr RequestNotifications173;
-		private IntPtr DTorIClientUser174;
+		public IntPtr BIsCyberCafe55;
+		public IntPtr BIsAcademicAccount56;
+		public IntPtr CreateAccount57;
+		public IntPtr ResetPassword58;
+		public IntPtr TrackNatTraversalStat59;
+		public IntPtr GetPackageIDForGuestPassToRedeemByGID60;
+		public IntPtr TrackSteamUsageEvent61;
+		public IntPtr TrackSteamGUIUsage62;
+		public IntPtr SetComputerInUse63;
+		public IntPtr BIsGameRunning64;
+		public IntPtr GetCurrentSessionToken65;
+		public IntPtr BUpdateAppOwnershipTicket66;
+		public IntPtr RequestCustomBinary67;
+		public IntPtr GetCustomBinariesState68;
+		public IntPtr RequestCustomBinaries69;
+		public IntPtr SetCellID70;
+		public IntPtr SetWinningPingTimeForCellID71;
+		public IntPtr GetUserBaseFolder72;
+		public IntPtr GetUserDataFolder73;
+		public IntPtr GetUserConfigFolder74;
+		public IntPtr GetAccountName75;
+		public IntPtr IsPasswordRemembered76;
+		public IntPtr RequiresLegacyCDKey77;
+		public IntPtr GetLegacyCDKey78;
+		public IntPtr HasLegacyCDKey79;
+		public IntPtr SetLegacyCDKey80;
+		public IntPtr RemoveLegacyCDKey81;
+		public IntPtr RequestLegacyCDKeyFromApp82;
+		public IntPtr BIsAnyGameRunning83;
+		public IntPtr ChangePassword84;
+		public IntPtr ChangeEmail85;
+		public IntPtr ChangeSecretQuestionAndAnswer86;
+		public IntPtr SetSteam2FullASTicket87;
+		public IntPtr GetSteam2FullASTicket88;
+		public IntPtr GetEmail89;
+		public IntPtr RequestForgottenPasswordEmail90;
+		public IntPtr FindAccountsByEmailAddress91;
+		public IntPtr FindAccountsByCdKey92;
+		public IntPtr GetNumAccountsWithEmailAddress93;
+		public IntPtr IsAccountNameInUse94;
+		public IntPtr Test_FakeConnectionTimeout95;
+		public IntPtr RunInstallScript96;
+		public IntPtr IsInstallScriptRunning97;
+		public IntPtr GetInstallScriptString98;
+		public IntPtr GetInstallScriptState99;
+		public IntPtr SpawnProcess100;
+		public IntPtr GetAppOwnershipTicketLength101;
+		public IntPtr GetAppOwnershipTicketData102;
+		public IntPtr GetAppOwnershipTicketExtendedData103;
+		public IntPtr GetAppDecryptionKey104;
+		public IntPtr GetMarketingMessageCount105;
+		public IntPtr GetMarketingMessage106;
+		public IntPtr GetAuthSessionTicket107;
+		public IntPtr BeginAuthSession108;
+		public IntPtr EndAuthSession109;
+		public IntPtr CancelAuthTicket110;
+		public IntPtr IsUserSubscribedAppInTicket111;
+		public IntPtr AdvertiseGame112;
+		public IntPtr RequestEncryptedAppTicket113;
+		public IntPtr GetEncryptedAppTicket114;
+		public IntPtr RequestOAuthTokenForApp115;
+		public IntPtr GetOAuthTokenForApp116;
+		public IntPtr InvalidateOAuthTokenForApp117;
+		public IntPtr SetAccountLimited118;
+		public IntPtr BIsAccountLimited119;
+		public IntPtr SetAccountCommunityBanned120;
+		public IntPtr BIsAccountCommunityBanned121;
+		public IntPtr SendValidationEmail122;
+		public IntPtr BGameConnectTokensAvailable123;
+		public IntPtr NumGamesRunning124;
+		public IntPtr GetRunningGameID125;
+		public IntPtr GetAccountSecurityPolicyFlags126;
+		public IntPtr RequestChangeEmail127;
+		public IntPtr ChangePasswordWithCode128;
+		public IntPtr ChangeEmailWithCode129;
+		public IntPtr ChangeSecretQuestionAndAnswerWithCode130;
+		public IntPtr SetClientStat131;
+		public IntPtr VerifyPassword132;
+		public IntPtr BSupportUser133;
+		public IntPtr BIsAppOverlayEnabled134;
+		public IntPtr BIsBehindNAT135;
+		public IntPtr GetMicroTxnAppID136;
+		public IntPtr GetMicroTxnOrderID137;
+		public IntPtr BGetMicroTxnPrice138;
+		public IntPtr GetMicroTxnLineItemCount139;
+		public IntPtr BGetMicroTxnLineItem140;
+		public IntPtr BIsSandboxMicroTxn141;
+		public IntPtr AuthorizeMicroTxn142;
+		public IntPtr NotifyAppMicroTxnAuthResponse143;
+		public IntPtr BGetWalletBalance144;
+		public IntPtr RequestMicroTxnInfo145;
+		public IntPtr BGetAppMinutesPlayed146;
+		public IntPtr BGetGuideURL147;
+		public IntPtr GetClientAppListResponse_AddApp148;
+		public IntPtr GetClientAppListResponse_AddDLC149;
+		public IntPtr GetClientAppListResponse_Done150;
+		public IntPtr PostUIResultToClientJob151;
+		public IntPtr BPromptToVerifyEmail152;
+		public IntPtr BPromptToChangePassword153;
+		public IntPtr BAccountLocked154;
+		public IntPtr BAccountShouldShowLockUI155;
+		public IntPtr BAccountLockedByIPT156;
+		public IntPtr GetCountAuthedComputers157;
+		public IntPtr GetSteamGuardProvider158;
+		public IntPtr GetSteamGuardRequireCodeByDefault159;
+		public IntPtr ShowSteamGuardProviderOptions160;
+		public IntPtr SteamGuardProviderMobileIsOption161;
+		public IntPtr BAccountCanUseIPT162;
+		public IntPtr ChangeTwoFactorAuthOptions163;
+		public IntPtr ChangeSteamGuardOptions164;
+		public IntPtr Set2ndFactorAuthCode165;
+		public IntPtr BAccountHasIPTConfig166;
+		public IntPtr GetEmailDomainFromLogonFailure167;
+		public IntPtr BIsSubscribedApp168;
+		public IntPtr RegisterActivationCode169;
+		public IntPtr OptionalDLCInstallation170;
+		public IntPtr AckSystemIM171;
+		public IntPtr RequestSpecialSurvey172;
+		public IntPtr SendSpecialSurveyResponse173;
+		public IntPtr RequestNotifications174;
+		public IntPtr InCommunityBeta175;
+		public IntPtr SetInCommunityBeta176;
+		public IntPtr GetAppOwnershipInfo177;
+		private IntPtr DTorIClientUser178;
 	};
 	
 	[InteropHelp.InterfaceVersion("CLIENTUSER_INTERFACE_VERSION001")]
 			return this.GetFunction<NativeGetLanguageSI>( this.Functions.GetLanguage54 )( this.ObjectAddress, pchLanguage, (Int32) pchLanguage.Capacity ); 
 		}
 		
-		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetCyberCafeB( IntPtr thisptr, [MarshalAs(UnmanagedType.I1)] bool bCyberCafe );
-		public void SetCyberCafe( bool bCyberCafe ) 
+		[return: MarshalAs(UnmanagedType.I1)]
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBIsCyberCafe( IntPtr thisptr );
+		public bool BIsCyberCafe(  ) 
 		{
-			this.GetFunction<NativeSetCyberCafeB>( this.Functions.SetCyberCafe55 )( this.ObjectAddress, bCyberCafe ); 
+			return this.GetFunction<NativeBIsCyberCafe>( this.Functions.BIsCyberCafe55 )( this.ObjectAddress ); 
+		}
+		
+		[return: MarshalAs(UnmanagedType.I1)]
+		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBIsAcademicAccount( IntPtr thisptr );
+		public bool BIsAcademicAccount(  ) 
+		{
+			return this.GetFunction<NativeBIsAcademicAccount>( this.Functions.BIsAcademicAccount56 )( this.ObjectAddress ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeCreateAccountSSSISS( IntPtr thisptr, string pchAccountName, string pchNewPassword, string pchNewEmail, Int32 iQuestion, string pchNewQuestion, string pchNewAnswer );
 		public void CreateAccount( string pchAccountName, string pchNewPassword, string pchNewEmail, Int32 iQuestion, string pchNewQuestion, string pchNewAnswer ) 
 		{
-			this.GetFunction<NativeCreateAccountSSSISS>( this.Functions.CreateAccount56 )( this.ObjectAddress, pchAccountName, pchNewPassword, pchNewEmail, iQuestion, pchNewQuestion, pchNewAnswer ); 
+			this.GetFunction<NativeCreateAccountSSSISS>( this.Functions.CreateAccount57 )( this.ObjectAddress, pchAccountName, pchNewPassword, pchNewEmail, iQuestion, pchNewQuestion, pchNewAnswer ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeResetPasswordSSSSS( IntPtr thisptr, string pchAccountName, string pchOldPassword, string pchNewPassword, string pchValidationCode, string pchAnswer );
 		public UInt64 ResetPassword( string pchAccountName, string pchOldPassword, string pchNewPassword, string pchValidationCode, string pchAnswer ) 
 		{
-			return this.GetFunction<NativeResetPasswordSSSSS>( this.Functions.ResetPassword57 )( this.ObjectAddress, pchAccountName, pchOldPassword, pchNewPassword, pchValidationCode, pchAnswer ); 
+			return this.GetFunction<NativeResetPasswordSSSSS>( this.Functions.ResetPassword58 )( this.ObjectAddress, pchAccountName, pchOldPassword, pchNewPassword, pchValidationCode, pchAnswer ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeTrackNatTraversalStatC( IntPtr thisptr, ref CNatTraversalStat pNatStat );
 		public void TrackNatTraversalStat( ref CNatTraversalStat pNatStat ) 
 		{
-			this.GetFunction<NativeTrackNatTraversalStatC>( this.Functions.TrackNatTraversalStat58 )( this.ObjectAddress, ref pNatStat ); 
+			this.GetFunction<NativeTrackNatTraversalStatC>( this.Functions.TrackNatTraversalStat59 )( this.ObjectAddress, ref pNatStat ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt32 NativeGetPackageIDForGuestPassToRedeemByGIDU( IntPtr thisptr, UInt64 gid );
 		public UInt32 GetPackageIDForGuestPassToRedeemByGID( UInt64 gid ) 
 		{
-			return this.GetFunction<NativeGetPackageIDForGuestPassToRedeemByGIDU>( this.Functions.GetPackageIDForGuestPassToRedeemByGID59 )( this.ObjectAddress, gid ); 
+			return this.GetFunction<NativeGetPackageIDForGuestPassToRedeemByGIDU>( this.Functions.GetPackageIDForGuestPassToRedeemByGID60 )( this.ObjectAddress, gid ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeTrackSteamUsageEventEBU( IntPtr thisptr, ESteamUsageEvent eSteamUsageEvent, Byte[] pubKV, UInt32 cubKV );
 		public void TrackSteamUsageEvent( ESteamUsageEvent eSteamUsageEvent, Byte[] pubKV ) 
 		{
-			this.GetFunction<NativeTrackSteamUsageEventEBU>( this.Functions.TrackSteamUsageEvent60 )( this.ObjectAddress, eSteamUsageEvent, pubKV, (UInt32) pubKV.Length ); 
+			this.GetFunction<NativeTrackSteamUsageEventEBU>( this.Functions.TrackSteamUsageEvent61 )( this.ObjectAddress, eSteamUsageEvent, pubKV, (UInt32) pubKV.Length ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeTrackSteamGUIUsageS( IntPtr thisptr, string arg0 );
 		public void TrackSteamGUIUsage( string arg0 ) 
 		{
-			this.GetFunction<NativeTrackSteamGUIUsageS>( this.Functions.TrackSteamGUIUsage61 )( this.ObjectAddress, arg0 ); 
+			this.GetFunction<NativeTrackSteamGUIUsageS>( this.Functions.TrackSteamGUIUsage62 )( this.ObjectAddress, arg0 ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate void NativeSetComputerInUse( IntPtr thisptr );
 		public void SetComputerInUse(  ) 
 		{
-			this.GetFunction<NativeSetComputerInUse>( this.Functions.SetComputerInUse62 )( this.ObjectAddress ); 
+			this.GetFunction<NativeSetComputerInUse>( this.Functions.SetComputerInUse63 )( this.ObjectAddress ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBIsGameRunningC( IntPtr thisptr, UInt64 gameID );
 		public bool BIsGameRunning( CGameID gameID ) 
 		{
-			return this.GetFunction<NativeBIsGameRunningC>( this.Functions.BIsGameRunning63 )( this.ObjectAddress, gameID.ConvertToUint64() ); 
+			return this.GetFunction<NativeBIsGameRunningC>( this.Functions.BIsGameRunning64 )( this.ObjectAddress, gameID.ConvertToUint64() ); 
 		}
 		
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate UInt64 NativeGetCurrentSessionToken( IntPtr thisptr );
 		public UInt64 GetCurrentSessionToken(  ) 
 		{
-			return this.GetFunction<NativeGetCurrentSessionToken>( this.Functions.GetCurrentSessionToken64 )( this.ObjectAddress ); 
+			return this.GetFunction<NativeGetCurrentSessionToken>( this.Functions.GetCurrentSessionToken65 )( this.ObjectAddress ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeBUpdateAppOwnershipTicketUBB( IntPtr thisptr, UInt32 nAppID, [MarshalAs(UnmanagedType.I1)] bool bOnlyUpdateIfStale, [MarshalAs(UnmanagedType.I1)] bool bIsDepot );
 		public bool BUpdateAppOwnershipTicket( UInt32 nAppID, bool bOnlyUpdateIfStale, bool bIsDepot ) 
 		{
-			return this.GetFunction<NativeBUpdateAppOwnershipTicketUBB>( this.Functions.BUpdateAppOwnershipTicket65 )( this.ObjectAddress, nAppID, bOnlyUpdateIfStale, bIsDepot ); 
+			return this.GetFunction<NativeBUpdateAppOwnershipTicketUBB>( this.Functions.BUpdateAppOwnershipTicket66 )( this.ObjectAddress, nAppID, bOnlyUpdateIfStale, bIsDepot ); 
 		}
 		
 		[return: MarshalAs(UnmanagedType.I1)]
 		[UnmanagedFunctionPointer(CallingConvention.ThisCall)] private delegate bool NativeRequestCustomBinarySUBB( IntPtr thisptr, string pszAbsolutePath, UInt32 nAppID, [MarshalAs(UnmanagedType.I1)] bool bForceUpdate, [MarshalAs(UnmanagedType.I1)] bool bAppLaunchRequest );
 		public bool RequestCustomBinary( string pszAbsolutePath, UInt32 nAppID, bool bForceUpdate, bool bAppLaunchRequest ) 
 		{
-			return this.GetFunction<NativeRequestCustomBinarySUBB>( this.Functions.Re