Merge branch 'steamworks144' of https://github.com/Facepunch/Facepunch.Steamworks into steamworks144

Facepunch.Steamworks.Test/Facepunch.Steamworks.Test.csproj

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.props" Condition="Exists('..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.props')" />
+  <Import Project="..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.props" Condition="Exists('..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -29,6 +29,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <PlatformTarget>x64</PlatformTarget>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -76,10 +77,10 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\MSTest.TestFramework.1.4.0\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.dll</HintPath>
+      <HintPath>..\packages\MSTest.TestFramework.2.0.0-beta4\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
-      <HintPath>..\packages\MSTest.TestFramework.1.4.0\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll</HintPath>
+      <HintPath>..\packages\MSTest.TestFramework.2.0.0-beta4\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll</HintPath>
     </Reference>
     <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <HintPath>..\packages\Newtonsoft.Json.9.0.2-beta1\lib\net45\Newtonsoft.Json.dll</HintPath>
@@ -89,8 +90,11 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="FriendsTest.cs" />
+    <Compile Include="UgcTest.cs" />
+    <Compile Include="UgcEditor.cs" />
     <Compile Include="UserTest.cs" />
     <Compile Include="UserStatsTest.cs" />
+    <Compile Include="UgcQuery.cs" />
     <Compile Include="UtilsTest.cs" />
     <Compile Include="AppTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -115,10 +119,10 @@
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.props'))" />
+    <Error Condition="!Exists('..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.props'))" />
-    <Error Condition="!Exists('..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.targets'))" />
+    <Error Condition="!Exists('..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.targets'))" />
   </Target>
-  <Import Project="..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.targets" Condition="Exists('..\packages\MSTest.TestAdapter.1.4.0\build\net45\MSTest.TestAdapter.targets')" />
+  <Import Project="..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.targets" Condition="Exists('..\packages\MSTest.TestAdapter.2.0.0-beta4\build\net45\MSTest.TestAdapter.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">

Facepunch.Steamworks.Test/UgcEditor.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Steamworks.Data;
+
+namespace Steamworks
+{
+    [TestClass]
+    [DeploymentItem( "steam_api64.dll" )]
+    public class UgcEditor
+    {
+		[TestMethod]
+        public async Task CreateFile()
+        {
+			var result = await Ugc.Editor.NewCommunityFile
+							  .WithTitle( "Unit Test Created Item" )
+							  .WithDescription( "This item was created by Facepunch Steamworks unit tests.\n\n" +
+												"It should have technically been deleted so you should never get to " +
+												"read this unless something terrible has happened." )
+							  .SubmitAsync();
+
+			Assert.IsTrue( result.Success );
+			Assert.AreNotEqual( result.FileId.Value, 0 );
+
+			var deleted = await SteamUGC.DeleteFileAsync( result.FileId );
+			Assert.IsTrue( deleted );
+
+		}
+
+		class ProgressBar : IProgress<float>
+		{
+			float Value = 0;
+
+			public void Report( float value )
+			{
+				if ( Value >= value ) return;
+
+				Value = value;
+
+				Console.WriteLine( value );
+			}
+		}
+
+		[TestMethod]
+        public async Task UploadBigFile()
+        {
+			var created = Ugc.Editor.NewCommunityFile
+							.WithTitle( "Unit Test Upload Item" )
+							.WithDescription( "This item was created by Facepunch Steamworks unit tests.\n\n" +
+									"It should have technically been deleted so you should never get to " +
+									"read this unless something terrible has happened." )
+							//.WithTag( "Apple" )
+							//.WithTag( "Banana" )
+							;
+
+
+			// Make a folder
+			var testFolder = new System.IO.DirectoryInfo( "WorkshopUpload" );
+			if ( !testFolder.Exists ) testFolder.Create();
+
+			created = created.WithContent( testFolder.FullName );
+
+			// Upload a file of random bytes
+			var rand = new Random();
+			var testFile = new byte[1024 * 1024 * 256];
+			rand.NextBytes( testFile );
+			System.IO.File.WriteAllBytes( testFolder.FullName + "/testfile1.bin", testFile );
+
+			Console.WriteLine( testFolder.FullName );
+
+			try
+			{
+				var done = await created.SubmitAsync( new ProgressBar() );
+
+				Assert.IsTrue( done.Success );
+				Console.WriteLine( "item.Id: {0}", done.FileId );
+
+				var deleted = await SteamUGC.DeleteFileAsync( done.FileId );
+				Assert.IsTrue( deleted );
+			}
+			finally
+			{
+				System.IO.File.Delete( testFolder.FullName + "/testfile.bin" );
+			}
+
+		}
+	}
+
+}

Facepunch.Steamworks.Test/UgcQuery.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Steamworks.Data;
+
+namespace Steamworks
+{
+    [TestClass]
+    [DeploymentItem( "steam_api64.dll" )]
+    public class UgcQueryTests
+    {
+		[TestMethod]
+        public async Task QueryAll()
+        {
+			var q = Ugc.Query.All;
+
+			var result = await q.GetPageAsync( 1 );
+			Assert.IsNotNull( result );
+
+			Console.WriteLine( $"ResultCount: {result?.ResultCount}" );
+			Console.WriteLine( $"TotalCount: {result?.TotalCount}" );
+		}
+
+		[TestMethod]
+		public async Task QueryWithTags()
+		{
+			var q = Ugc.Query.All
+							.WithTag( "Fun" )
+							.WithTag( "Movie" )
+							.MatchAllTags();
+
+			var result = await q.GetPageAsync( 1 );
+			Assert.IsNotNull( result );
+
+			Console.WriteLine( $"ResultCount: {result?.ResultCount}" );
+			Console.WriteLine( $"TotalCount: {result?.TotalCount}" );
+
+			foreach ( var entry in result.Value.Entries )
+			{
+				Assert.IsTrue( entry.HasTag( "Fun" ) );
+				Assert.IsTrue( entry.HasTag( "Movie" ) );
+
+			}
+		}
+
+		[TestMethod]
+		public async Task QueryAllFromFriends()
+		{
+			var q = Ugc.Query.All
+						.CreatedByFriends();
+
+			var result = await q.GetPageAsync( 1 );
+			Assert.IsNotNull( result );
+
+			Console.WriteLine( $"ResultCount: {result?.ResultCount}" );
+			Console.WriteLine( $"TotalCount: {result?.TotalCount}" );
+
+			foreach ( var entry in result.Value.Entries )
+			{
+				Console.WriteLine( $" {entry.Title}" );
+			}
+		}
+
+		[TestMethod]
+		public async Task QueryUserOwn()
+		{
+			var q = Ugc.UserQuery.All
+								.FromSelf();
+
+			var result = await q.GetPageAsync( 1 );
+			Assert.IsNotNull( result );
+
+			Console.WriteLine( $"ResultCount: {result?.ResultCount}" );
+			Console.WriteLine( $"TotalCount: {result?.TotalCount}" );
+
+			foreach ( var entry in result.Value.Entries )
+			{
+				Console.WriteLine( $" {entry.Title}" );
+			}
+		}
+
+		[TestMethod]
+		public async Task QueryFoohy()
+		{
+			var q = Ugc.UserQuery.All
+								.FromUser( 76561197997689747 );
+
+			var result = await q.GetPageAsync( 1 );
+			Assert.IsNotNull( result );
+
+			Console.WriteLine( $"ResultCount: {result?.ResultCount}" );
+			Console.WriteLine( $"TotalCount: {result?.TotalCount}" );
+
+			foreach ( var entry in result.Value.Entries )
+			{
+				Console.WriteLine( $" {entry.Title}" );
+			}
+		}
+	}
+
+}

Facepunch.Steamworks.Test/UgcTest.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Steamworks.Data;
+
+namespace Steamworks
+{
+    [TestClass]
+    [DeploymentItem( "steam_api64.dll" )]
+    public class UgcTest
+    {
+		[TestMethod]
+        public async Task Download()
+        {
+			SteamUGC.Download( 1717844711 );
+		}
+
+		[TestMethod]
+        public async Task GetInformation()
+        {
+			var itemInfo = await Ugc.Item.Get( 1720164672 );
+
+			Assert.IsTrue( itemInfo.HasValue );
+
+			Console.WriteLine( $"Title: {itemInfo?.Title}" );
+			Console.WriteLine( $"IsInstalled: {itemInfo?.IsInstalled}" );
+			Console.WriteLine( $"IsDownloading: {itemInfo?.IsDownloading}" );
+			Console.WriteLine( $"IsDownloadPending: {itemInfo?.IsDownloadPending}" );
+			Console.WriteLine( $"IsSubscribed: {itemInfo?.IsSubscribed}" );
+			Console.WriteLine( $"NeedsUpdate: {itemInfo?.NeedsUpdate}" );
+			Console.WriteLine( $"Description: {itemInfo?.Description}" );
+		}
+	}
+}

Facepunch.Steamworks.Test/UserStatsTest.cs

@@ -4,11 +4,13 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Steamworks.Data;
 
 namespace Steamworks
 {
     [TestClass]
     [DeploymentItem( "steam_api64.dll" )]
+    [DeploymentItem( "steam_appid.txt" )]
     public class UserStatsTest
 	{
 		[TestMethod]
@@ -37,6 +39,164 @@ public async Task PlayerCountAsync()
 			Console.WriteLine( $"players:	{players}" );
 		}
 		
+		public async Task StoreStats()
+		{
+			var result = Result.NotSettled;
+
+			SteamUserStats.OnUserStatsStored += ( r ) =>
+			{
+				result = r;
+			};
+
+			SteamUserStats.StoreStats();
+
+			while ( result  == Result.NotSettled )
+			{
+				await Task.Delay( 10 );
+			}
+
+			Assert.AreEqual( result, Result.OK );
+
+		}
+
+		[TestMethod]
+		public async Task CreateLeaderboard()
+		{
+			var leaderboard = await SteamUserStats.FindOrCreateLeaderboard( "Testleaderboard", Data.LeaderboardSort.Ascending, Data.LeaderboardDisplay.Numeric );
+			
+			Assert.IsTrue( leaderboard.HasValue );
+		}
+
+		[TestMethod]
+		public async Task FindLeaderboard()
+		{
+			var leaderboard = await SteamUserStats.FindLeaderboard( "Testleaderboard" );
+			Assert.IsTrue( leaderboard.HasValue );
+		}
+
+		[TestMethod]
+		public async Task SubmitScore()
+		{
+			var leaderboard = await SteamUserStats.FindLeaderboard( "Testleaderboard" );
+			Assert.IsTrue( leaderboard.HasValue );
+
+			var result = await leaderboard.Value.SubmitScore( 576 );
+			Assert.IsTrue( result.HasValue );
+
+			Console.WriteLine( $"result.Changed: {result?.Changed}" );
+			Console.WriteLine( $"result.OldGlobalRank: {result?.OldGlobalRank}" );
+			Console.WriteLine( $"result.NewGlobalRank: {result?.NewGlobalRank}" );
+			Console.WriteLine( $"result.RankChange: {result?.RankChange}" );
+			Console.WriteLine( $"result.Score: {result?.Score}" );
+		}
+
+		[TestMethod]
+		public async Task ReplaceScore()
+		{
+			var leaderboard = await SteamUserStats.FindLeaderboard( "Testleaderboard" );
+			Assert.IsTrue( leaderboard.HasValue );
+
+			var result = await leaderboard.Value.ReplaceScore( 576 );
+			Assert.IsTrue( result.HasValue );
+
+			Console.WriteLine( $"result.Changed: {result?.Changed}" );
+			Console.WriteLine( $"result.OldGlobalRank: {result?.OldGlobalRank}" );
+			Console.WriteLine( $"result.NewGlobalRank: {result?.NewGlobalRank}" );
+			Console.WriteLine( $"result.RankChange: {result?.RankChange}" );
+			Console.WriteLine( $"result.Score: {result?.Score}" );
+		}
+
+		[TestMethod]
+		public async Task GetScoresFromFriends()
+		{
+			var leaderboard = await SteamUserStats.FindLeaderboard( "Testleaderboard" );
+			Assert.IsTrue( leaderboard.HasValue );
+
+			// Get entries around user
+			var friendScores = await leaderboard.Value.GetScoresFromFriends();
+			Assert.IsNotNull( friendScores );
+
+			Console.WriteLine( $"" );
+			Console.WriteLine( $"Friend Scores:" );
+			foreach ( var e in friendScores )
+			{
+				Console.WriteLine( $"{e.GlobalRank}: {e.Score} {e.User}" );
+			}
+		}
+
+		[TestMethod]
+		public async Task GetScoresAroundUserAsync()
+		{
+			var leaderboard = await SteamUserStats.FindLeaderboard( "Testleaderboard" );
+			Assert.IsTrue( leaderboard.HasValue );
+
+			// Get entries around user
+			var relativeScores = await leaderboard.Value.GetScoresAroundUserAsync( -5, 5 );
+			Assert.IsNotNull( relativeScores );
+
+			Console.WriteLine( $"" );
+			Console.WriteLine( $"Relative Scores:" );
+			foreach ( var e in relativeScores )
+			{
+				Console.WriteLine( $"{e.GlobalRank}: {e.Score} {e.User}" );
+			}
+		}
+
+		[TestMethod]
+		public async Task GetScoresAsync()
+		{
+			var leaderboard = await SteamUserStats.FindLeaderboard( "Testleaderboard" );
+			Assert.IsTrue( leaderboard.HasValue );
+
+			// Get top 20 global scores
+			var globalsScores = await leaderboard.Value.GetScoresAsync( 20 );
+			Assert.IsNotNull( globalsScores );
+
+			Console.WriteLine( $"" );
+			Console.WriteLine( $"Global Scores:" );
+			foreach ( var e in globalsScores )
+			{
+				Console.WriteLine( $"{e.GlobalRank}: {e.Score} {e.User}" );
+			}
+		}
+
+		[TestMethod]
+		public void GetStatInt()
+		{
+			var startups = new Stat( "GMA_X_STARTUPS_STAT" );
+			Console.WriteLine( $"{startups.Name} {startups.GetInt()} times" );
+			Console.WriteLine( $"{startups.Name} {startups.GetFloat()} times" );
+
+			Assert.AreNotEqual( 0, startups.GetInt() );
+		}
+
+		[TestMethod]
+		public async Task GetStatGlobalInt()
+		{
+			var startups = new Stat( "GMA_X_STARTUPS_STAT" );
+			await startups.GetGlobalIntDays( 5 );
+
+			await Task.Delay( 3000 );
+
+			var totalStartups = startups.GetGlobalInt();
+			Assert.AreNotEqual( 0, totalStartups );
+			Console.WriteLine( $"Garry's Mod has been started {totalStartups} times" );
+		}
+
+		[TestMethod]
+		public async Task GetStatGlobalHistoryInt()
+		{
+			var startups = new Stat( "GMA_X_STARTUPS_STAT" );
+
+			var history = await startups.GetGlobalIntDays( 60 );
+			Assert.AreNotEqual( 0, history.Length );
+
+			for ( int i=0; i< history.Length; i++ )
+			{
+				Console.WriteLine( $"{i} : {history[i]}" );
+			}
+		}
+
 	}
 
 }

Facepunch.Steamworks.Test/UtilsTest.cs

@@ -63,7 +63,7 @@ public void CurrentBatteryPower()
 		[TestMethod]
 		public void AppId()
 		{
-			var cnt = SteamUtils.AppId;
+			var cnt = SteamClient.AppId;
 
 			Assert.IsTrue( cnt.Value > 0 );
 

Facepunch.Steamworks.Test/packages.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="MSTest.TestAdapter" version="1.4.0" targetFramework="net46" />
+  <package id="MSTest.TestAdapter" version="2.0.0-beta4" targetFramework="net46" />
-  <package id="MSTest.TestFramework" version="1.4.0" targetFramework="net46" />
+  <package id="MSTest.TestFramework" version="2.0.0-beta4" targetFramework="net46" />
   <package id="Newtonsoft.Json" version="9.0.2-beta1" targetFramework="net452" />
 </packages>

Facepunch.Steamworks/Enum/LeaderboardDisplay.cs

@@ -0,0 +1,20 @@
+namespace Steamworks.Data
+{
+	public enum LeaderboardDisplay : int
+	{
+		/// <summary>
+		/// The score is just a simple numerical value
+		/// </summary>
+		Numeric = 1,
+
+		/// <summary>
+		/// The score represents a time, in seconds
+		/// </summary>
+		TimeSeconds = 2,
+
+		/// <summary>
+		/// The score represents a time, in milliseconds
+		/// </summary>
+		TimeMilliSeconds = 3,
+	}
+}

Facepunch.Steamworks/Enum/LeaderboardSort.cs

@@ -0,0 +1,15 @@
+namespace Steamworks.Data
+{
+	public enum LeaderboardSort : int
+	{
+		/// <summary>
+		/// The top-score is the lowest number
+		/// </summary>
+		Ascending = 1,
+
+		/// <summary>
+		/// The top-score is the highest number
+		/// </summary>
+		Descending = 2,
+	}
+}

Facepunch.Steamworks/Facepunch.Steamworks.csproj

@@ -50,6 +50,7 @@
 	<PackageIconUrl>https://avatars2.githubusercontent.com/u/3371040</PackageIconUrl>
 	<PackageTags>facepunch;steam;unity;steamworks;valve</PackageTags>
 	<PackageVersion>0.7.5</PackageVersion>
+	<LangVersion>latest</LangVersion>
  </PropertyGroup>
   
  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Debug|netstandard2.0|AnyCPU'">

Facepunch.Steamworks/Generated/Interfaces/ISteamApps.cs

@@ -17,357 +17,357 @@ public ISteamApps( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			BIsSubscribedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_BIsSubscribed = Marshal.GetDelegateForFunctionPointer<FBIsSubscribed>( Marshal.ReadIntPtr( VTable, 0) );
-			BIsLowViolenceDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsLowViolenceDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_BIsLowViolence = Marshal.GetDelegateForFunctionPointer<FBIsLowViolence>( Marshal.ReadIntPtr( VTable, 8) );
-			BIsCybercafeDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsCybercafeDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_BIsCybercafe = Marshal.GetDelegateForFunctionPointer<FBIsCybercafe>( Marshal.ReadIntPtr( VTable, 16) );
-			BIsVACBannedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsVACBannedDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_BIsVACBanned = Marshal.GetDelegateForFunctionPointer<FBIsVACBanned>( Marshal.ReadIntPtr( VTable, 24) );
-			GetCurrentGameLanguageDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCurrentGameLanguageDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_GetCurrentGameLanguage = Marshal.GetDelegateForFunctionPointer<FGetCurrentGameLanguage>( Marshal.ReadIntPtr( VTable, 32) );
-			GetAvailableGameLanguagesDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAvailableGameLanguagesDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_GetAvailableGameLanguages = Marshal.GetDelegateForFunctionPointer<FGetAvailableGameLanguages>( Marshal.ReadIntPtr( VTable, 40) );
-			BIsSubscribedAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedAppDelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_BIsSubscribedApp = Marshal.GetDelegateForFunctionPointer<FBIsSubscribedApp>( Marshal.ReadIntPtr( VTable, 48) );
-			BIsDlcInstalledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsDlcInstalledDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_BIsDlcInstalled = Marshal.GetDelegateForFunctionPointer<FBIsDlcInstalled>( Marshal.ReadIntPtr( VTable, 56) );
-			GetEarliestPurchaseUnixTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEarliestPurchaseUnixTimeDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_GetEarliestPurchaseUnixTime = Marshal.GetDelegateForFunctionPointer<FGetEarliestPurchaseUnixTime>( Marshal.ReadIntPtr( VTable, 64) );
-			BIsSubscribedFromFreeWeekendDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedFromFreeWeekendDelegate>( Marshal.ReadIntPtr( VTable, 72) );
+			_BIsSubscribedFromFreeWeekend = Marshal.GetDelegateForFunctionPointer<FBIsSubscribedFromFreeWeekend>( Marshal.ReadIntPtr( VTable, 72) );
-			GetDLCCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetDLCCountDelegate>( Marshal.ReadIntPtr( VTable, 80) );
+			_GetDLCCount = Marshal.GetDelegateForFunctionPointer<FGetDLCCount>( Marshal.ReadIntPtr( VTable, 80) );
-			BGetDLCDataByIndexDelegatePointer = Marshal.GetDelegateForFunctionPointer<BGetDLCDataByIndexDelegate>( Marshal.ReadIntPtr( VTable, 88) );
+			_BGetDLCDataByIndex = Marshal.GetDelegateForFunctionPointer<FBGetDLCDataByIndex>( Marshal.ReadIntPtr( VTable, 88) );
-			InstallDLCDelegatePointer = Marshal.GetDelegateForFunctionPointer<InstallDLCDelegate>( Marshal.ReadIntPtr( VTable, 96) );
+			_InstallDLC = Marshal.GetDelegateForFunctionPointer<FInstallDLC>( Marshal.ReadIntPtr( VTable, 96) );
-			UninstallDLCDelegatePointer = Marshal.GetDelegateForFunctionPointer<UninstallDLCDelegate>( Marshal.ReadIntPtr( VTable, 104) );
+			_UninstallDLC = Marshal.GetDelegateForFunctionPointer<FUninstallDLC>( Marshal.ReadIntPtr( VTable, 104) );
-			RequestAppProofOfPurchaseKeyDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestAppProofOfPurchaseKeyDelegate>( Marshal.ReadIntPtr( VTable, 112) );
+			_RequestAppProofOfPurchaseKey = Marshal.GetDelegateForFunctionPointer<FRequestAppProofOfPurchaseKey>( Marshal.ReadIntPtr( VTable, 112) );
-			GetCurrentBetaNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCurrentBetaNameDelegate>( Marshal.ReadIntPtr( VTable, 120) );
+			_GetCurrentBetaName = Marshal.GetDelegateForFunctionPointer<FGetCurrentBetaName>( Marshal.ReadIntPtr( VTable, 120) );
-			MarkContentCorruptDelegatePointer = Marshal.GetDelegateForFunctionPointer<MarkContentCorruptDelegate>( Marshal.ReadIntPtr( VTable, 128) );
+			_MarkContentCorrupt = Marshal.GetDelegateForFunctionPointer<FMarkContentCorrupt>( Marshal.ReadIntPtr( VTable, 128) );
-			GetInstalledDepotsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetInstalledDepotsDelegate>( Marshal.ReadIntPtr( VTable, 136) );
+			_GetInstalledDepots = Marshal.GetDelegateForFunctionPointer<FGetInstalledDepots>( Marshal.ReadIntPtr( VTable, 136) );
-			GetAppInstallDirDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppInstallDirDelegate>( Marshal.ReadIntPtr( VTable, 144) );
+			_GetAppInstallDir = Marshal.GetDelegateForFunctionPointer<FGetAppInstallDir>( Marshal.ReadIntPtr( VTable, 144) );
-			BIsAppInstalledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsAppInstalledDelegate>( Marshal.ReadIntPtr( VTable, 152) );
+			_BIsAppInstalled = Marshal.GetDelegateForFunctionPointer<FBIsAppInstalled>( Marshal.ReadIntPtr( VTable, 152) );
-			GetAppOwnerDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppOwnerDelegate>( Marshal.ReadIntPtr( VTable, 160) );
+			_GetAppOwner = Marshal.GetDelegateForFunctionPointer<FGetAppOwner>( Marshal.ReadIntPtr( VTable, 160) );
-			GetLaunchQueryParamDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLaunchQueryParamDelegate>( Marshal.ReadIntPtr( VTable, 168) );
+			_GetLaunchQueryParam = Marshal.GetDelegateForFunctionPointer<FGetLaunchQueryParam>( Marshal.ReadIntPtr( VTable, 168) );
-			GetDlcDownloadProgressDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetDlcDownloadProgressDelegate>( Marshal.ReadIntPtr( VTable, 176) );
+			_GetDlcDownloadProgress = Marshal.GetDelegateForFunctionPointer<FGetDlcDownloadProgress>( Marshal.ReadIntPtr( VTable, 176) );
-			GetAppBuildIdDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppBuildIdDelegate>( Marshal.ReadIntPtr( VTable, 184) );
+			_GetAppBuildId = Marshal.GetDelegateForFunctionPointer<FGetAppBuildId>( Marshal.ReadIntPtr( VTable, 184) );
-			RequestAllProofOfPurchaseKeysDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestAllProofOfPurchaseKeysDelegate>( Marshal.ReadIntPtr( VTable, 192) );
+			_RequestAllProofOfPurchaseKeys = Marshal.GetDelegateForFunctionPointer<FRequestAllProofOfPurchaseKeys>( Marshal.ReadIntPtr( VTable, 192) );
-			GetFileDetailsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetFileDetailsDelegate>( Marshal.ReadIntPtr( VTable, 200) );
+			_GetFileDetails = Marshal.GetDelegateForFunctionPointer<FGetFileDetails>( Marshal.ReadIntPtr( VTable, 200) );
-			GetLaunchCommandLineDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLaunchCommandLineDelegate>( Marshal.ReadIntPtr( VTable, 208) );
+			_GetLaunchCommandLine = Marshal.GetDelegateForFunctionPointer<FGetLaunchCommandLine>( Marshal.ReadIntPtr( VTable, 208) );
-			BIsSubscribedFromFamilySharingDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedFromFamilySharingDelegate>( Marshal.ReadIntPtr( VTable, 216) );
+			_BIsSubscribedFromFamilySharing = Marshal.GetDelegateForFunctionPointer<FBIsSubscribedFromFamilySharing>( Marshal.ReadIntPtr( VTable, 216) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsSubscribedDelegate( IntPtr self );
+		private delegate bool FBIsSubscribed( IntPtr self );
-		private BIsSubscribedDelegate BIsSubscribedDelegatePointer;
+		private FBIsSubscribed _BIsSubscribed;
 		
 		#endregion
 		internal bool BIsSubscribed()
 		{
-			return BIsSubscribedDelegatePointer( Self );
+			return _BIsSubscribed( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsLowViolenceDelegate( IntPtr self );
+		private delegate bool FBIsLowViolence( IntPtr self );
-		private BIsLowViolenceDelegate BIsLowViolenceDelegatePointer;
+		private FBIsLowViolence _BIsLowViolence;
 		
 		#endregion
 		internal bool BIsLowViolence()
 		{
-			return BIsLowViolenceDelegatePointer( Self );
+			return _BIsLowViolence( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsCybercafeDelegate( IntPtr self );
+		private delegate bool FBIsCybercafe( IntPtr self );
-		private BIsCybercafeDelegate BIsCybercafeDelegatePointer;
+		private FBIsCybercafe _BIsCybercafe;
 		
 		#endregion
 		internal bool BIsCybercafe()
 		{
-			return BIsCybercafeDelegatePointer( Self );
+			return _BIsCybercafe( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsVACBannedDelegate( IntPtr self );
+		private delegate bool FBIsVACBanned( IntPtr self );
-		private BIsVACBannedDelegate BIsVACBannedDelegatePointer;
+		private FBIsVACBanned _BIsVACBanned;
 		
 		#endregion
 		internal bool BIsVACBanned()
 		{
-			return BIsVACBannedDelegatePointer( Self );
+			return _BIsVACBanned( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetCurrentGameLanguageDelegate( IntPtr self );
+		private delegate IntPtr FGetCurrentGameLanguage( IntPtr self );
-		private GetCurrentGameLanguageDelegate GetCurrentGameLanguageDelegatePointer;
+		private FGetCurrentGameLanguage _GetCurrentGameLanguage;
 		
 		#endregion
 		internal string GetCurrentGameLanguage()
 		{
-			return GetString( GetCurrentGameLanguageDelegatePointer( Self ) );
+			return GetString( _GetCurrentGameLanguage( Self ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetAvailableGameLanguagesDelegate( IntPtr self );
+		private delegate IntPtr FGetAvailableGameLanguages( IntPtr self );
-		private GetAvailableGameLanguagesDelegate GetAvailableGameLanguagesDelegatePointer;
+		private FGetAvailableGameLanguages _GetAvailableGameLanguages;
 		
 		#endregion
 		internal string GetAvailableGameLanguages()
 		{
-			return GetString( GetAvailableGameLanguagesDelegatePointer( Self ) );
+			return GetString( _GetAvailableGameLanguages( Self ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsSubscribedAppDelegate( IntPtr self, AppId_t appID );
+		private delegate bool FBIsSubscribedApp( IntPtr self, AppId appID );
-		private BIsSubscribedAppDelegate BIsSubscribedAppDelegatePointer;
+		private FBIsSubscribedApp _BIsSubscribedApp;
 		
 		#endregion
-		internal bool BIsSubscribedApp( AppId_t appID )
+		internal bool BIsSubscribedApp( AppId appID )
 		{
-			return BIsSubscribedAppDelegatePointer( Self, appID );
+			return _BIsSubscribedApp( Self, appID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsDlcInstalledDelegate( IntPtr self, AppId_t appID );
+		private delegate bool FBIsDlcInstalled( IntPtr self, AppId appID );
-		private BIsDlcInstalledDelegate BIsDlcInstalledDelegatePointer;
+		private FBIsDlcInstalled _BIsDlcInstalled;
 		
 		#endregion
-		internal bool BIsDlcInstalled( AppId_t appID )
+		internal bool BIsDlcInstalled( AppId appID )
 		{
-			return BIsDlcInstalledDelegatePointer( Self, appID );
+			return _BIsDlcInstalled( Self, appID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetEarliestPurchaseUnixTimeDelegate( IntPtr self, AppId_t nAppID );
+		private delegate uint FGetEarliestPurchaseUnixTime( IntPtr self, AppId nAppID );
-		private GetEarliestPurchaseUnixTimeDelegate GetEarliestPurchaseUnixTimeDelegatePointer;
+		private FGetEarliestPurchaseUnixTime _GetEarliestPurchaseUnixTime;
 		
 		#endregion
-		internal uint GetEarliestPurchaseUnixTime( AppId_t nAppID )
+		internal uint GetEarliestPurchaseUnixTime( AppId nAppID )
 		{
-			return GetEarliestPurchaseUnixTimeDelegatePointer( Self, nAppID );
+			return _GetEarliestPurchaseUnixTime( Self, nAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsSubscribedFromFreeWeekendDelegate( IntPtr self );
+		private delegate bool FBIsSubscribedFromFreeWeekend( IntPtr self );
-		private BIsSubscribedFromFreeWeekendDelegate BIsSubscribedFromFreeWeekendDelegatePointer;
+		private FBIsSubscribedFromFreeWeekend _BIsSubscribedFromFreeWeekend;
 		
 		#endregion
 		internal bool BIsSubscribedFromFreeWeekend()
 		{
-			return BIsSubscribedFromFreeWeekendDelegatePointer( Self );
+			return _BIsSubscribedFromFreeWeekend( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetDLCCountDelegate( IntPtr self );
+		private delegate int FGetDLCCount( IntPtr self );
-		private GetDLCCountDelegate GetDLCCountDelegatePointer;
+		private FGetDLCCount _GetDLCCount;
 		
 		#endregion
 		internal int GetDLCCount()
 		{
-			return GetDLCCountDelegatePointer( Self );
+			return _GetDLCCount( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BGetDLCDataByIndexDelegate( IntPtr self, int iDLC, ref AppId_t pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize );
+		private delegate bool FBGetDLCDataByIndex( IntPtr self, int iDLC, ref AppId pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize );
-		private BGetDLCDataByIndexDelegate BGetDLCDataByIndexDelegatePointer;
+		private FBGetDLCDataByIndex _BGetDLCDataByIndex;
 		
 		#endregion
-		internal bool BGetDLCDataByIndex( int iDLC, ref AppId_t pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize )
+		internal bool BGetDLCDataByIndex( int iDLC, ref AppId pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize )
 		{
-			return BGetDLCDataByIndexDelegatePointer( Self, iDLC, ref pAppID, ref pbAvailable, pchName, cchNameBufferSize );
+			return _BGetDLCDataByIndex( Self, iDLC, ref pAppID, ref pbAvailable, pchName, cchNameBufferSize );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void InstallDLCDelegate( IntPtr self, AppId_t nAppID );
+		private delegate void FInstallDLC( IntPtr self, AppId nAppID );
-		private InstallDLCDelegate InstallDLCDelegatePointer;
+		private FInstallDLC _InstallDLC;
 		
 		#endregion
-		internal void InstallDLC( AppId_t nAppID )
+		internal void InstallDLC( AppId nAppID )
 		{
-			InstallDLCDelegatePointer( Self, nAppID );
+			_InstallDLC( Self, nAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void UninstallDLCDelegate( IntPtr self, AppId_t nAppID );
+		private delegate void FUninstallDLC( IntPtr self, AppId nAppID );
-		private UninstallDLCDelegate UninstallDLCDelegatePointer;
+		private FUninstallDLC _UninstallDLC;
 		
 		#endregion
-		internal void UninstallDLC( AppId_t nAppID )
+		internal void UninstallDLC( AppId nAppID )
 		{
-			UninstallDLCDelegatePointer( Self, nAppID );
+			_UninstallDLC( Self, nAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void RequestAppProofOfPurchaseKeyDelegate( IntPtr self, AppId_t nAppID );
+		private delegate void FRequestAppProofOfPurchaseKey( IntPtr self, AppId nAppID );
-		private RequestAppProofOfPurchaseKeyDelegate RequestAppProofOfPurchaseKeyDelegatePointer;
+		private FRequestAppProofOfPurchaseKey _RequestAppProofOfPurchaseKey;
 		
 		#endregion
-		internal void RequestAppProofOfPurchaseKey( AppId_t nAppID )
+		internal void RequestAppProofOfPurchaseKey( AppId nAppID )
 		{
-			RequestAppProofOfPurchaseKeyDelegatePointer( Self, nAppID );
+			_RequestAppProofOfPurchaseKey( Self, nAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetCurrentBetaNameDelegate( IntPtr self, StringBuilder pchName, int cchNameBufferSize );
+		private delegate bool FGetCurrentBetaName( IntPtr self, StringBuilder pchName, int cchNameBufferSize );
-		private GetCurrentBetaNameDelegate GetCurrentBetaNameDelegatePointer;
+		private FGetCurrentBetaName _GetCurrentBetaName;
 		
 		#endregion
 		internal bool GetCurrentBetaName( StringBuilder pchName, int cchNameBufferSize )
 		{
-			return GetCurrentBetaNameDelegatePointer( Self, pchName, cchNameBufferSize );
+			return _GetCurrentBetaName( Self, pchName, cchNameBufferSize );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool MarkContentCorruptDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bMissingFilesOnly );
+		private delegate bool FMarkContentCorrupt( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bMissingFilesOnly );
-		private MarkContentCorruptDelegate MarkContentCorruptDelegatePointer;
+		private FMarkContentCorrupt _MarkContentCorrupt;
 		
 		#endregion
 		internal bool MarkContentCorrupt( [MarshalAs( UnmanagedType.U1 )] bool bMissingFilesOnly )
 		{
-			return MarkContentCorruptDelegatePointer( Self, bMissingFilesOnly );
+			return _MarkContentCorrupt( Self, bMissingFilesOnly );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetInstalledDepotsDelegate( IntPtr self, AppId_t appID, [In,Out] DepotId_t[]  pvecDepots, uint cMaxDepots );
+		private delegate uint FGetInstalledDepots( IntPtr self, AppId appID, [In,Out] DepotId_t[]  pvecDepots, uint cMaxDepots );
-		private GetInstalledDepotsDelegate GetInstalledDepotsDelegatePointer;
+		private FGetInstalledDepots _GetInstalledDepots;
 		
 		#endregion
-		internal uint GetInstalledDepots( AppId_t appID, [In,Out] DepotId_t[]  pvecDepots, uint cMaxDepots )
+		internal uint GetInstalledDepots( AppId appID, [In,Out] DepotId_t[]  pvecDepots, uint cMaxDepots )
 		{
-			return GetInstalledDepotsDelegatePointer( Self, appID, pvecDepots, cMaxDepots );
+			return _GetInstalledDepots( Self, appID, pvecDepots, cMaxDepots );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetAppInstallDirDelegate( IntPtr self, AppId_t appID, StringBuilder pchFolder, uint cchFolderBufferSize );
+		private delegate uint FGetAppInstallDir( IntPtr self, AppId appID, StringBuilder pchFolder, uint cchFolderBufferSize );
-		private GetAppInstallDirDelegate GetAppInstallDirDelegatePointer;
+		private FGetAppInstallDir _GetAppInstallDir;
 		
 		#endregion
-		internal uint GetAppInstallDir( AppId_t appID, StringBuilder pchFolder, uint cchFolderBufferSize )
+		internal uint GetAppInstallDir( AppId appID, StringBuilder pchFolder, uint cchFolderBufferSize )
 		{
-			return GetAppInstallDirDelegatePointer( Self, appID, pchFolder, cchFolderBufferSize );
+			return _GetAppInstallDir( Self, appID, pchFolder, cchFolderBufferSize );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsAppInstalledDelegate( IntPtr self, AppId_t appID );
+		private delegate bool FBIsAppInstalled( IntPtr self, AppId appID );
-		private BIsAppInstalledDelegate BIsAppInstalledDelegatePointer;
+		private FBIsAppInstalled _BIsAppInstalled;
 		
 		#endregion
-		internal bool BIsAppInstalled( AppId_t appID )
+		internal bool BIsAppInstalled( AppId appID )
 		{
-			return BIsAppInstalledDelegatePointer( Self, appID );
+			return _BIsAppInstalled( Self, appID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void GetAppOwnerDelegate( IntPtr self, ref SteamId retVal );
+		private delegate void FGetAppOwner( IntPtr self, ref SteamId retVal );
-		private GetAppOwnerDelegate GetAppOwnerDelegatePointer;
+		private FGetAppOwner _GetAppOwner;
 		
 		#endregion
 		internal SteamId GetAppOwner()
 		{
 			var retVal = default( SteamId );
-			GetAppOwnerDelegatePointer( Self, ref retVal );
+			_GetAppOwner( Self, ref retVal );
 			return retVal;
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetLaunchQueryParamDelegate( IntPtr self, string pchKey );
+		private delegate IntPtr FGetLaunchQueryParam( IntPtr self, string pchKey );
-		private GetLaunchQueryParamDelegate GetLaunchQueryParamDelegatePointer;
+		private FGetLaunchQueryParam _GetLaunchQueryParam;
 		
 		#endregion
 		internal string GetLaunchQueryParam( string pchKey )
 		{
-			return GetString( GetLaunchQueryParamDelegatePointer( Self, pchKey ) );
+			return GetString( _GetLaunchQueryParam( Self, pchKey ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetDlcDownloadProgressDelegate( IntPtr self, AppId_t nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal );
+		private delegate bool FGetDlcDownloadProgress( IntPtr self, AppId nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal );
-		private GetDlcDownloadProgressDelegate GetDlcDownloadProgressDelegatePointer;
+		private FGetDlcDownloadProgress _GetDlcDownloadProgress;
 		
 		#endregion
-		internal bool GetDlcDownloadProgress( AppId_t nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal )
+		internal bool GetDlcDownloadProgress( AppId nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal )
 		{
-			return GetDlcDownloadProgressDelegatePointer( Self, nAppID, ref punBytesDownloaded, ref punBytesTotal );
+			return _GetDlcDownloadProgress( Self, nAppID, ref punBytesDownloaded, ref punBytesTotal );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetAppBuildIdDelegate( IntPtr self );
+		private delegate int FGetAppBuildId( IntPtr self );
-		private GetAppBuildIdDelegate GetAppBuildIdDelegatePointer;
+		private FGetAppBuildId _GetAppBuildId;
 		
 		#endregion
 		internal int GetAppBuildId()
 		{
-			return GetAppBuildIdDelegatePointer( Self );
+			return _GetAppBuildId( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void RequestAllProofOfPurchaseKeysDelegate( IntPtr self );
+		private delegate void FRequestAllProofOfPurchaseKeys( IntPtr self );
-		private RequestAllProofOfPurchaseKeysDelegate RequestAllProofOfPurchaseKeysDelegatePointer;
+		private FRequestAllProofOfPurchaseKeys _RequestAllProofOfPurchaseKeys;
 		
 		#endregion
 		internal void RequestAllProofOfPurchaseKeys()
 		{
-			RequestAllProofOfPurchaseKeysDelegatePointer( Self );
+			_RequestAllProofOfPurchaseKeys( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t GetFileDetailsDelegate( IntPtr self, string pszFileName );
+		private delegate SteamAPICall_t FGetFileDetails( IntPtr self, string pszFileName );
-		private GetFileDetailsDelegate GetFileDetailsDelegatePointer;
+		private FGetFileDetails _GetFileDetails;
 		
 		#endregion
 		internal async Task<FileDetailsResult_t?> GetFileDetails( string pszFileName )
 		{
-			return await (new Result<FileDetailsResult_t>( GetFileDetailsDelegatePointer( Self, pszFileName ) )).GetResult();
+			return await (new Result<FileDetailsResult_t>( _GetFileDetails( Self, pszFileName ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetLaunchCommandLineDelegate( IntPtr self, StringBuilder pszCommandLine, int cubCommandLine );
+		private delegate int FGetLaunchCommandLine( IntPtr self, StringBuilder pszCommandLine, int cubCommandLine );
-		private GetLaunchCommandLineDelegate GetLaunchCommandLineDelegatePointer;
+		private FGetLaunchCommandLine _GetLaunchCommandLine;
 		
 		#endregion
 		internal int GetLaunchCommandLine( StringBuilder pszCommandLine, int cubCommandLine )
 		{
-			return GetLaunchCommandLineDelegatePointer( Self, pszCommandLine, cubCommandLine );
+			return _GetLaunchCommandLine( Self, pszCommandLine, cubCommandLine );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsSubscribedFromFamilySharingDelegate( IntPtr self );
+		private delegate bool FBIsSubscribedFromFamilySharing( IntPtr self );
-		private BIsSubscribedFromFamilySharingDelegate BIsSubscribedFromFamilySharingDelegatePointer;
+		private FBIsSubscribedFromFamilySharing _BIsSubscribedFromFamilySharing;
 		
 		#endregion
 		internal bool BIsSubscribedFromFamilySharing()
 		{
-			return BIsSubscribedFromFamilySharingDelegatePointer( Self );
+			return _BIsSubscribedFromFamilySharing( Self );
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs

@@ -17,546 +17,546 @@ public ISteamGameServer( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			InitGameServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<InitGameServerDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_InitGameServer = Marshal.GetDelegateForFunctionPointer<FInitGameServer>( Marshal.ReadIntPtr( VTable, 0) );
-			SetProductDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetProductDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_SetProduct = Marshal.GetDelegateForFunctionPointer<FSetProduct>( Marshal.ReadIntPtr( VTable, 8) );
-			SetGameDescriptionDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetGameDescriptionDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_SetGameDescription = Marshal.GetDelegateForFunctionPointer<FSetGameDescription>( Marshal.ReadIntPtr( VTable, 16) );
-			SetModDirDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetModDirDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_SetModDir = Marshal.GetDelegateForFunctionPointer<FSetModDir>( Marshal.ReadIntPtr( VTable, 24) );
-			SetDedicatedServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetDedicatedServerDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_SetDedicatedServer = Marshal.GetDelegateForFunctionPointer<FSetDedicatedServer>( Marshal.ReadIntPtr( VTable, 32) );
-			LogOnDelegatePointer = Marshal.GetDelegateForFunctionPointer<LogOnDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_LogOn = Marshal.GetDelegateForFunctionPointer<FLogOn>( Marshal.ReadIntPtr( VTable, 40) );
-			LogOnAnonymousDelegatePointer = Marshal.GetDelegateForFunctionPointer<LogOnAnonymousDelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_LogOnAnonymous = Marshal.GetDelegateForFunctionPointer<FLogOnAnonymous>( Marshal.ReadIntPtr( VTable, 48) );
-			LogOffDelegatePointer = Marshal.GetDelegateForFunctionPointer<LogOffDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_LogOff = Marshal.GetDelegateForFunctionPointer<FLogOff>( Marshal.ReadIntPtr( VTable, 56) );
-			BLoggedOnDelegatePointer = Marshal.GetDelegateForFunctionPointer<BLoggedOnDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_BLoggedOn = Marshal.GetDelegateForFunctionPointer<FBLoggedOn>( Marshal.ReadIntPtr( VTable, 64) );
-			BSecureDelegatePointer = Marshal.GetDelegateForFunctionPointer<BSecureDelegate>( Marshal.ReadIntPtr( VTable, 72) );
+			_BSecure = Marshal.GetDelegateForFunctionPointer<FBSecure>( Marshal.ReadIntPtr( VTable, 72) );
-			GetSteamIDDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSteamIDDelegate>( Marshal.ReadIntPtr( VTable, 80) );
+			_GetSteamID = Marshal.GetDelegateForFunctionPointer<FGetSteamID>( Marshal.ReadIntPtr( VTable, 80) );
-			WasRestartRequestedDelegatePointer = Marshal.GetDelegateForFunctionPointer<WasRestartRequestedDelegate>( Marshal.ReadIntPtr( VTable, 88) );
+			_WasRestartRequested = Marshal.GetDelegateForFunctionPointer<FWasRestartRequested>( Marshal.ReadIntPtr( VTable, 88) );
-			SetMaxPlayerCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetMaxPlayerCountDelegate>( Marshal.ReadIntPtr( VTable, 96) );
+			_SetMaxPlayerCount = Marshal.GetDelegateForFunctionPointer<FSetMaxPlayerCount>( Marshal.ReadIntPtr( VTable, 96) );
-			SetBotPlayerCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetBotPlayerCountDelegate>( Marshal.ReadIntPtr( VTable, 104) );
+			_SetBotPlayerCount = Marshal.GetDelegateForFunctionPointer<FSetBotPlayerCount>( Marshal.ReadIntPtr( VTable, 104) );
-			SetServerNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetServerNameDelegate>( Marshal.ReadIntPtr( VTable, 112) );
+			_SetServerName = Marshal.GetDelegateForFunctionPointer<FSetServerName>( Marshal.ReadIntPtr( VTable, 112) );
-			SetMapNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetMapNameDelegate>( Marshal.ReadIntPtr( VTable, 120) );
+			_SetMapName = Marshal.GetDelegateForFunctionPointer<FSetMapName>( Marshal.ReadIntPtr( VTable, 120) );
-			SetPasswordProtectedDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetPasswordProtectedDelegate>( Marshal.ReadIntPtr( VTable, 128) );
+			_SetPasswordProtected = Marshal.GetDelegateForFunctionPointer<FSetPasswordProtected>( Marshal.ReadIntPtr( VTable, 128) );
-			SetSpectatorPortDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetSpectatorPortDelegate>( Marshal.ReadIntPtr( VTable, 136) );
+			_SetSpectatorPort = Marshal.GetDelegateForFunctionPointer<FSetSpectatorPort>( Marshal.ReadIntPtr( VTable, 136) );
-			SetSpectatorServerNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetSpectatorServerNameDelegate>( Marshal.ReadIntPtr( VTable, 144) );
+			_SetSpectatorServerName = Marshal.GetDelegateForFunctionPointer<FSetSpectatorServerName>( Marshal.ReadIntPtr( VTable, 144) );
-			ClearAllKeyValuesDelegatePointer = Marshal.GetDelegateForFunctionPointer<ClearAllKeyValuesDelegate>( Marshal.ReadIntPtr( VTable, 152) );
+			_ClearAllKeyValues = Marshal.GetDelegateForFunctionPointer<FClearAllKeyValues>( Marshal.ReadIntPtr( VTable, 152) );
-			SetKeyValueDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetKeyValueDelegate>( Marshal.ReadIntPtr( VTable, 160) );
+			_SetKeyValue = Marshal.GetDelegateForFunctionPointer<FSetKeyValue>( Marshal.ReadIntPtr( VTable, 160) );
-			SetGameTagsDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetGameTagsDelegate>( Marshal.ReadIntPtr( VTable, 168) );
+			_SetGameTags = Marshal.GetDelegateForFunctionPointer<FSetGameTags>( Marshal.ReadIntPtr( VTable, 168) );
-			SetGameDataDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetGameDataDelegate>( Marshal.ReadIntPtr( VTable, 176) );
+			_SetGameData = Marshal.GetDelegateForFunctionPointer<FSetGameData>( Marshal.ReadIntPtr( VTable, 176) );
-			SetRegionDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetRegionDelegate>( Marshal.ReadIntPtr( VTable, 184) );
+			_SetRegion = Marshal.GetDelegateForFunctionPointer<FSetRegion>( Marshal.ReadIntPtr( VTable, 184) );
-			SendUserConnectAndAuthenticateDelegatePointer = Marshal.GetDelegateForFunctionPointer<SendUserConnectAndAuthenticateDelegate>( Marshal.ReadIntPtr( VTable, 192) );
+			_SendUserConnectAndAuthenticate = Marshal.GetDelegateForFunctionPointer<FSendUserConnectAndAuthenticate>( Marshal.ReadIntPtr( VTable, 192) );
-			CreateUnauthenticatedUserConnectionDelegatePointer = Marshal.GetDelegateForFunctionPointer<CreateUnauthenticatedUserConnectionDelegate>( Marshal.ReadIntPtr( VTable, 200) );
+			_CreateUnauthenticatedUserConnection = Marshal.GetDelegateForFunctionPointer<FCreateUnauthenticatedUserConnection>( Marshal.ReadIntPtr( VTable, 200) );
-			SendUserDisconnectDelegatePointer = Marshal.GetDelegateForFunctionPointer<SendUserDisconnectDelegate>( Marshal.ReadIntPtr( VTable, 208) );
+			_SendUserDisconnect = Marshal.GetDelegateForFunctionPointer<FSendUserDisconnect>( Marshal.ReadIntPtr( VTable, 208) );
-			BUpdateUserDataDelegatePointer = Marshal.GetDelegateForFunctionPointer<BUpdateUserDataDelegate>( Marshal.ReadIntPtr( VTable, 216) );
+			_BUpdateUserData = Marshal.GetDelegateForFunctionPointer<FBUpdateUserData>( Marshal.ReadIntPtr( VTable, 216) );
-			GetAuthSessionTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAuthSessionTicketDelegate>( Marshal.ReadIntPtr( VTable, 224) );
+			_GetAuthSessionTicket = Marshal.GetDelegateForFunctionPointer<FGetAuthSessionTicket>( Marshal.ReadIntPtr( VTable, 224) );
-			BeginAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<BeginAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 232) );
+			_BeginAuthSession = Marshal.GetDelegateForFunctionPointer<FBeginAuthSession>( Marshal.ReadIntPtr( VTable, 232) );
-			EndAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<EndAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 240) );
+			_EndAuthSession = Marshal.GetDelegateForFunctionPointer<FEndAuthSession>( Marshal.ReadIntPtr( VTable, 240) );
-			CancelAuthTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelAuthTicketDelegate>( Marshal.ReadIntPtr( VTable, 248) );
+			_CancelAuthTicket = Marshal.GetDelegateForFunctionPointer<FCancelAuthTicket>( Marshal.ReadIntPtr( VTable, 248) );
-			UserHasLicenseForAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<UserHasLicenseForAppDelegate>( Marshal.ReadIntPtr( VTable, 256) );
+			_UserHasLicenseForApp = Marshal.GetDelegateForFunctionPointer<FUserHasLicenseForApp>( Marshal.ReadIntPtr( VTable, 256) );
-			RequestUserGroupStatusDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestUserGroupStatusDelegate>( Marshal.ReadIntPtr( VTable, 264) );
+			_RequestUserGroupStatus = Marshal.GetDelegateForFunctionPointer<FRequestUserGroupStatus>( Marshal.ReadIntPtr( VTable, 264) );
-			GetGameplayStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGameplayStatsDelegate>( Marshal.ReadIntPtr( VTable, 272) );
+			_GetGameplayStats = Marshal.GetDelegateForFunctionPointer<FGetGameplayStats>( Marshal.ReadIntPtr( VTable, 272) );
-			GetServerReputationDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerReputationDelegate>( Marshal.ReadIntPtr( VTable, 280) );
+			_GetServerReputation = Marshal.GetDelegateForFunctionPointer<FGetServerReputation>( Marshal.ReadIntPtr( VTable, 280) );
-			GetPublicIPDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetPublicIPDelegate>( Marshal.ReadIntPtr( VTable, 288) );
+			_GetPublicIP = Marshal.GetDelegateForFunctionPointer<FGetPublicIP>( Marshal.ReadIntPtr( VTable, 288) );
-			HandleIncomingPacketDelegatePointer = Marshal.GetDelegateForFunctionPointer<HandleIncomingPacketDelegate>( Marshal.ReadIntPtr( VTable, 296) );
+			_HandleIncomingPacket = Marshal.GetDelegateForFunctionPointer<FHandleIncomingPacket>( Marshal.ReadIntPtr( VTable, 296) );
-			GetNextOutgoingPacketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNextOutgoingPacketDelegate>( Marshal.ReadIntPtr( VTable, 304) );
+			_GetNextOutgoingPacket = Marshal.GetDelegateForFunctionPointer<FGetNextOutgoingPacket>( Marshal.ReadIntPtr( VTable, 304) );
-			EnableHeartbeatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<EnableHeartbeatsDelegate>( Marshal.ReadIntPtr( VTable, 312) );
+			_EnableHeartbeats = Marshal.GetDelegateForFunctionPointer<FEnableHeartbeats>( Marshal.ReadIntPtr( VTable, 312) );
-			SetHeartbeatIntervalDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetHeartbeatIntervalDelegate>( Marshal.ReadIntPtr( VTable, 320) );
+			_SetHeartbeatInterval = Marshal.GetDelegateForFunctionPointer<FSetHeartbeatInterval>( Marshal.ReadIntPtr( VTable, 320) );
-			ForceHeartbeatDelegatePointer = Marshal.GetDelegateForFunctionPointer<ForceHeartbeatDelegate>( Marshal.ReadIntPtr( VTable, 328) );
+			_ForceHeartbeat = Marshal.GetDelegateForFunctionPointer<FForceHeartbeat>( Marshal.ReadIntPtr( VTable, 328) );
-			AssociateWithClanDelegatePointer = Marshal.GetDelegateForFunctionPointer<AssociateWithClanDelegate>( Marshal.ReadIntPtr( VTable, 336) );
+			_AssociateWithClan = Marshal.GetDelegateForFunctionPointer<FAssociateWithClan>( Marshal.ReadIntPtr( VTable, 336) );
-			ComputeNewPlayerCompatibilityDelegatePointer = Marshal.GetDelegateForFunctionPointer<ComputeNewPlayerCompatibilityDelegate>( Marshal.ReadIntPtr( VTable, 344) );
+			_ComputeNewPlayerCompatibility = Marshal.GetDelegateForFunctionPointer<FComputeNewPlayerCompatibility>( Marshal.ReadIntPtr( VTable, 344) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool InitGameServerDelegate( IntPtr self, uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId_t nGameAppId, string pchVersionString );
+		private delegate bool FInitGameServer( IntPtr self, uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId nGameAppId, string pchVersionString );
-		private InitGameServerDelegate InitGameServerDelegatePointer;
+		private FInitGameServer _InitGameServer;
 		
 		#endregion
-		internal bool InitGameServer( uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId_t nGameAppId, string pchVersionString )
+		internal bool InitGameServer( uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId nGameAppId, string pchVersionString )
 		{
-			return InitGameServerDelegatePointer( Self, unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString );
+			return _InitGameServer( Self, unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetProductDelegate( IntPtr self, string pszProduct );
+		private delegate void FSetProduct( IntPtr self, string pszProduct );
-		private SetProductDelegate SetProductDelegatePointer;
+		private FSetProduct _SetProduct;
 		
 		#endregion
 		internal void SetProduct( string pszProduct )
 		{
-			SetProductDelegatePointer( Self, pszProduct );
+			_SetProduct( Self, pszProduct );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetGameDescriptionDelegate( IntPtr self, string pszGameDescription );
+		private delegate void FSetGameDescription( IntPtr self, string pszGameDescription );
-		private SetGameDescriptionDelegate SetGameDescriptionDelegatePointer;
+		private FSetGameDescription _SetGameDescription;
 		
 		#endregion
 		internal void SetGameDescription( string pszGameDescription )
 		{
-			SetGameDescriptionDelegatePointer( Self, pszGameDescription );
+			_SetGameDescription( Self, pszGameDescription );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetModDirDelegate( IntPtr self, string pszModDir );
+		private delegate void FSetModDir( IntPtr self, string pszModDir );
-		private SetModDirDelegate SetModDirDelegatePointer;
+		private FSetModDir _SetModDir;
 		
 		#endregion
 		internal void SetModDir( string pszModDir )
 		{
-			SetModDirDelegatePointer( Self, pszModDir );
+			_SetModDir( Self, pszModDir );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetDedicatedServerDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bDedicated );
+		private delegate void FSetDedicatedServer( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bDedicated );
-		private SetDedicatedServerDelegate SetDedicatedServerDelegatePointer;
+		private FSetDedicatedServer _SetDedicatedServer;
 		
 		#endregion
 		internal void SetDedicatedServer( [MarshalAs( UnmanagedType.U1 )] bool bDedicated )
 		{
-			SetDedicatedServerDelegatePointer( Self, bDedicated );
+			_SetDedicatedServer( Self, bDedicated );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void LogOnDelegate( IntPtr self, string pszToken );
+		private delegate void FLogOn( IntPtr self, string pszToken );
-		private LogOnDelegate LogOnDelegatePointer;
+		private FLogOn _LogOn;
 		
 		#endregion
 		internal void LogOn( string pszToken )
 		{
-			LogOnDelegatePointer( Self, pszToken );
+			_LogOn( Self, pszToken );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void LogOnAnonymousDelegate( IntPtr self );
+		private delegate void FLogOnAnonymous( IntPtr self );
-		private LogOnAnonymousDelegate LogOnAnonymousDelegatePointer;
+		private FLogOnAnonymous _LogOnAnonymous;
 		
 		#endregion
 		internal void LogOnAnonymous()
 		{
-			LogOnAnonymousDelegatePointer( Self );
+			_LogOnAnonymous( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void LogOffDelegate( IntPtr self );
+		private delegate void FLogOff( IntPtr self );
-		private LogOffDelegate LogOffDelegatePointer;
+		private FLogOff _LogOff;
 		
 		#endregion
 		internal void LogOff()
 		{
-			LogOffDelegatePointer( Self );
+			_LogOff( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BLoggedOnDelegate( IntPtr self );
+		private delegate bool FBLoggedOn( IntPtr self );
-		private BLoggedOnDelegate BLoggedOnDelegatePointer;
+		private FBLoggedOn _BLoggedOn;
 		
 		#endregion
 		internal bool BLoggedOn()
 		{
-			return BLoggedOnDelegatePointer( Self );
+			return _BLoggedOn( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BSecureDelegate( IntPtr self );
+		private delegate bool FBSecure( IntPtr self );
-		private BSecureDelegate BSecureDelegatePointer;
+		private FBSecure _BSecure;
 		
 		#endregion
 		internal bool BSecure()
 		{
-			return BSecureDelegatePointer( Self );
+			return _BSecure( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void GetSteamIDDelegate( IntPtr self, ref SteamId retVal );
+		private delegate void FGetSteamID( IntPtr self, ref SteamId retVal );
-		private GetSteamIDDelegate GetSteamIDDelegatePointer;
+		private FGetSteamID _GetSteamID;
 		
 		#endregion
 		internal SteamId GetSteamID()
 		{
 			var retVal = default( SteamId );
-			GetSteamIDDelegatePointer( Self, ref retVal );
+			_GetSteamID( Self, ref retVal );
 			return retVal;
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool WasRestartRequestedDelegate( IntPtr self );
+		private delegate bool FWasRestartRequested( IntPtr self );
-		private WasRestartRequestedDelegate WasRestartRequestedDelegatePointer;
+		private FWasRestartRequested _WasRestartRequested;
 		
 		#endregion
 		internal bool WasRestartRequested()
 		{
-			return WasRestartRequestedDelegatePointer( Self );
+			return _WasRestartRequested( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetMaxPlayerCountDelegate( IntPtr self, int cPlayersMax );
+		private delegate void FSetMaxPlayerCount( IntPtr self, int cPlayersMax );
-		private SetMaxPlayerCountDelegate SetMaxPlayerCountDelegatePointer;
+		private FSetMaxPlayerCount _SetMaxPlayerCount;
 		
 		#endregion
 		internal void SetMaxPlayerCount( int cPlayersMax )
 		{
-			SetMaxPlayerCountDelegatePointer( Self, cPlayersMax );
+			_SetMaxPlayerCount( Self, cPlayersMax );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetBotPlayerCountDelegate( IntPtr self, int cBotplayers );
+		private delegate void FSetBotPlayerCount( IntPtr self, int cBotplayers );
-		private SetBotPlayerCountDelegate SetBotPlayerCountDelegatePointer;
+		private FSetBotPlayerCount _SetBotPlayerCount;
 		
 		#endregion
 		internal void SetBotPlayerCount( int cBotplayers )
 		{
-			SetBotPlayerCountDelegatePointer( Self, cBotplayers );
+			_SetBotPlayerCount( Self, cBotplayers );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetServerNameDelegate( IntPtr self, string pszServerName );
+		private delegate void FSetServerName( IntPtr self, string pszServerName );
-		private SetServerNameDelegate SetServerNameDelegatePointer;
+		private FSetServerName _SetServerName;
 		
 		#endregion
 		internal void SetServerName( string pszServerName )
 		{
-			SetServerNameDelegatePointer( Self, pszServerName );
+			_SetServerName( Self, pszServerName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetMapNameDelegate( IntPtr self, string pszMapName );
+		private delegate void FSetMapName( IntPtr self, string pszMapName );
-		private SetMapNameDelegate SetMapNameDelegatePointer;
+		private FSetMapName _SetMapName;
 		
 		#endregion
 		internal void SetMapName( string pszMapName )
 		{
-			SetMapNameDelegatePointer( Self, pszMapName );
+			_SetMapName( Self, pszMapName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetPasswordProtectedDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bPasswordProtected );
+		private delegate void FSetPasswordProtected( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bPasswordProtected );
-		private SetPasswordProtectedDelegate SetPasswordProtectedDelegatePointer;
+		private FSetPasswordProtected _SetPasswordProtected;
 		
 		#endregion
 		internal void SetPasswordProtected( [MarshalAs( UnmanagedType.U1 )] bool bPasswordProtected )
 		{
-			SetPasswordProtectedDelegatePointer( Self, bPasswordProtected );
+			_SetPasswordProtected( Self, bPasswordProtected );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetSpectatorPortDelegate( IntPtr self, ushort unSpectatorPort );
+		private delegate void FSetSpectatorPort( IntPtr self, ushort unSpectatorPort );
-		private SetSpectatorPortDelegate SetSpectatorPortDelegatePointer;
+		private FSetSpectatorPort _SetSpectatorPort;
 		
 		#endregion
 		internal void SetSpectatorPort( ushort unSpectatorPort )
 		{
-			SetSpectatorPortDelegatePointer( Self, unSpectatorPort );
+			_SetSpectatorPort( Self, unSpectatorPort );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetSpectatorServerNameDelegate( IntPtr self, string pszSpectatorServerName );
+		private delegate void FSetSpectatorServerName( IntPtr self, string pszSpectatorServerName );
-		private SetSpectatorServerNameDelegate SetSpectatorServerNameDelegatePointer;
+		private FSetSpectatorServerName _SetSpectatorServerName;
 		
 		#endregion
 		internal void SetSpectatorServerName( string pszSpectatorServerName )
 		{
-			SetSpectatorServerNameDelegatePointer( Self, pszSpectatorServerName );
+			_SetSpectatorServerName( Self, pszSpectatorServerName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void ClearAllKeyValuesDelegate( IntPtr self );
+		private delegate void FClearAllKeyValues( IntPtr self );
-		private ClearAllKeyValuesDelegate ClearAllKeyValuesDelegatePointer;
+		private FClearAllKeyValues _ClearAllKeyValues;
 		
 		#endregion
 		internal void ClearAllKeyValues()
 		{
-			ClearAllKeyValuesDelegatePointer( Self );
+			_ClearAllKeyValues( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetKeyValueDelegate( IntPtr self, string pKey, string pValue );
+		private delegate void FSetKeyValue( IntPtr self, string pKey, string pValue );
-		private SetKeyValueDelegate SetKeyValueDelegatePointer;
+		private FSetKeyValue _SetKeyValue;
 		
 		#endregion
 		internal void SetKeyValue( string pKey, string pValue )
 		{
-			SetKeyValueDelegatePointer( Self, pKey, pValue );
+			_SetKeyValue( Self, pKey, pValue );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetGameTagsDelegate( IntPtr self, string pchGameTags );
+		private delegate void FSetGameTags( IntPtr self, string pchGameTags );
-		private SetGameTagsDelegate SetGameTagsDelegatePointer;
+		private FSetGameTags _SetGameTags;
 		
 		#endregion
 		internal void SetGameTags( string pchGameTags )
 		{
-			SetGameTagsDelegatePointer( Self, pchGameTags );
+			_SetGameTags( Self, pchGameTags );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetGameDataDelegate( IntPtr self, string pchGameData );
+		private delegate void FSetGameData( IntPtr self, string pchGameData );
-		private SetGameDataDelegate SetGameDataDelegatePointer;
+		private FSetGameData _SetGameData;
 		
 		#endregion
 		internal void SetGameData( string pchGameData )
 		{
-			SetGameDataDelegatePointer( Self, pchGameData );
+			_SetGameData( Self, pchGameData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetRegionDelegate( IntPtr self, string pszRegion );
+		private delegate void FSetRegion( IntPtr self, string pszRegion );
-		private SetRegionDelegate SetRegionDelegatePointer;
+		private FSetRegion _SetRegion;
 		
 		#endregion
 		internal void SetRegion( string pszRegion )
 		{
-			SetRegionDelegatePointer( Self, pszRegion );
+			_SetRegion( Self, pszRegion );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool SendUserConnectAndAuthenticateDelegate( IntPtr self, uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser );
+		private delegate bool FSendUserConnectAndAuthenticate( IntPtr self, uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser );
-		private SendUserConnectAndAuthenticateDelegate SendUserConnectAndAuthenticateDelegatePointer;
+		private FSendUserConnectAndAuthenticate _SendUserConnectAndAuthenticate;
 		
 		#endregion
 		internal bool SendUserConnectAndAuthenticate( uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser )
 		{
-			return SendUserConnectAndAuthenticateDelegatePointer( Self, unIPClient, pvAuthBlob, cubAuthBlobSize, ref pSteamIDUser );
+			return _SendUserConnectAndAuthenticate( Self, unIPClient, pvAuthBlob, cubAuthBlobSize, ref pSteamIDUser );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void CreateUnauthenticatedUserConnectionDelegate( IntPtr self, ref SteamId retVal );
+		private delegate void FCreateUnauthenticatedUserConnection( IntPtr self, ref SteamId retVal );
-		private CreateUnauthenticatedUserConnectionDelegate CreateUnauthenticatedUserConnectionDelegatePointer;
+		private FCreateUnauthenticatedUserConnection _CreateUnauthenticatedUserConnection;
 		
 		#endregion
 		internal SteamId CreateUnauthenticatedUserConnection()
 		{
 			var retVal = default( SteamId );
-			CreateUnauthenticatedUserConnectionDelegatePointer( Self, ref retVal );
+			_CreateUnauthenticatedUserConnection( Self, ref retVal );
 			return retVal;
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SendUserDisconnectDelegate( IntPtr self, SteamId steamIDUser );
+		private delegate void FSendUserDisconnect( IntPtr self, SteamId steamIDUser );
-		private SendUserDisconnectDelegate SendUserDisconnectDelegatePointer;
+		private FSendUserDisconnect _SendUserDisconnect;
 		
 		#endregion
 		internal void SendUserDisconnect( SteamId steamIDUser )
 		{
-			SendUserDisconnectDelegatePointer( Self, steamIDUser );
+			_SendUserDisconnect( Self, steamIDUser );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BUpdateUserDataDelegate( IntPtr self, SteamId steamIDUser, string pchPlayerName, uint uScore );
+		private delegate bool FBUpdateUserData( IntPtr self, SteamId steamIDUser, string pchPlayerName, uint uScore );
-		private BUpdateUserDataDelegate BUpdateUserDataDelegatePointer;
+		private FBUpdateUserData _BUpdateUserData;
 		
 		#endregion
 		internal bool BUpdateUserData( SteamId steamIDUser, string pchPlayerName, uint uScore )
 		{
-			return BUpdateUserDataDelegatePointer( Self, steamIDUser, pchPlayerName, uScore );
+			return _BUpdateUserData( Self, steamIDUser, pchPlayerName, uScore );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HAuthTicket GetAuthSessionTicketDelegate( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
+		private delegate HAuthTicket FGetAuthSessionTicket( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
-		private GetAuthSessionTicketDelegate GetAuthSessionTicketDelegatePointer;
+		private FGetAuthSessionTicket _GetAuthSessionTicket;
 		
 		#endregion
 		internal HAuthTicket GetAuthSessionTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket )
 		{
-			return GetAuthSessionTicketDelegatePointer( Self, pTicket, cbMaxTicket, ref pcbTicket );
+			return _GetAuthSessionTicket( Self, pTicket, cbMaxTicket, ref pcbTicket );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate BeginAuthResult BeginAuthSessionDelegate( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID );
+		private delegate BeginAuthResult FBeginAuthSession( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID );
-		private BeginAuthSessionDelegate BeginAuthSessionDelegatePointer;
+		private FBeginAuthSession _BeginAuthSession;
 		
 		#endregion
 		internal BeginAuthResult BeginAuthSession( IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID )
 		{
-			return BeginAuthSessionDelegatePointer( Self, pAuthTicket, cbAuthTicket, steamID );
+			return _BeginAuthSession( Self, pAuthTicket, cbAuthTicket, steamID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void EndAuthSessionDelegate( IntPtr self, SteamId steamID );
+		private delegate void FEndAuthSession( IntPtr self, SteamId steamID );
-		private EndAuthSessionDelegate EndAuthSessionDelegatePointer;
+		private FEndAuthSession _EndAuthSession;
 		
 		#endregion
 		internal void EndAuthSession( SteamId steamID )
 		{
-			EndAuthSessionDelegatePointer( Self, steamID );
+			_EndAuthSession( Self, steamID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void CancelAuthTicketDelegate( IntPtr self, HAuthTicket hAuthTicket );
+		private delegate void FCancelAuthTicket( IntPtr self, HAuthTicket hAuthTicket );
-		private CancelAuthTicketDelegate CancelAuthTicketDelegatePointer;
+		private FCancelAuthTicket _CancelAuthTicket;
 		
 		#endregion
 		internal void CancelAuthTicket( HAuthTicket hAuthTicket )
 		{
-			CancelAuthTicketDelegatePointer( Self, hAuthTicket );
+			_CancelAuthTicket( Self, hAuthTicket );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate UserHasLicenseForAppResult UserHasLicenseForAppDelegate( IntPtr self, SteamId steamID, AppId_t appID );
+		private delegate UserHasLicenseForAppResult FUserHasLicenseForApp( IntPtr self, SteamId steamID, AppId appID );
-		private UserHasLicenseForAppDelegate UserHasLicenseForAppDelegatePointer;
+		private FUserHasLicenseForApp _UserHasLicenseForApp;
 		
 		#endregion
-		internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId_t appID )
+		internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId appID )
 		{
-			return UserHasLicenseForAppDelegatePointer( Self, steamID, appID );
+			return _UserHasLicenseForApp( Self, steamID, appID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool RequestUserGroupStatusDelegate( IntPtr self, SteamId steamIDUser, SteamId steamIDGroup );
+		private delegate bool FRequestUserGroupStatus( IntPtr self, SteamId steamIDUser, SteamId steamIDGroup );
-		private RequestUserGroupStatusDelegate RequestUserGroupStatusDelegatePointer;
+		private FRequestUserGroupStatus _RequestUserGroupStatus;
 		
 		#endregion
 		internal bool RequestUserGroupStatus( SteamId steamIDUser, SteamId steamIDGroup )
 		{
-			return RequestUserGroupStatusDelegatePointer( Self, steamIDUser, steamIDGroup );
+			return _RequestUserGroupStatus( Self, steamIDUser, steamIDGroup );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void GetGameplayStatsDelegate( IntPtr self );
+		private delegate void FGetGameplayStats( IntPtr self );
-		private GetGameplayStatsDelegate GetGameplayStatsDelegatePointer;
+		private FGetGameplayStats _GetGameplayStats;
 		
 		#endregion
 		internal void GetGameplayStats()
 		{
-			GetGameplayStatsDelegatePointer( Self );
+			_GetGameplayStats( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t GetServerReputationDelegate( IntPtr self );
+		private delegate SteamAPICall_t FGetServerReputation( IntPtr self );
-		private GetServerReputationDelegate GetServerReputationDelegatePointer;
+		private FGetServerReputation _GetServerReputation;
 		
 		#endregion
 		internal async Task<GSReputation_t?> GetServerReputation()
 		{
-			return await (new Result<GSReputation_t>( GetServerReputationDelegatePointer( Self ) )).GetResult();
+			return await (new Result<GSReputation_t>( _GetServerReputation( Self ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetPublicIPDelegate( IntPtr self );
+		private delegate uint FGetPublicIP( IntPtr self );
-		private GetPublicIPDelegate GetPublicIPDelegatePointer;
+		private FGetPublicIP _GetPublicIP;
 		
 		#endregion
 		internal uint GetPublicIP()
 		{
-			return GetPublicIPDelegatePointer( Self );
+			return _GetPublicIP( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool HandleIncomingPacketDelegate( IntPtr self, IntPtr pData, int cbData, uint srcIP, ushort srcPort );
+		private delegate bool FHandleIncomingPacket( IntPtr self, IntPtr pData, int cbData, uint srcIP, ushort srcPort );
-		private HandleIncomingPacketDelegate HandleIncomingPacketDelegatePointer;
+		private FHandleIncomingPacket _HandleIncomingPacket;
 		
 		#endregion
 		internal bool HandleIncomingPacket( IntPtr pData, int cbData, uint srcIP, ushort srcPort )
 		{
-			return HandleIncomingPacketDelegatePointer( Self, pData, cbData, srcIP, srcPort );
+			return _HandleIncomingPacket( Self, pData, cbData, srcIP, srcPort );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetNextOutgoingPacketDelegate( IntPtr self, IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort );
+		private delegate int FGetNextOutgoingPacket( IntPtr self, IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort );
-		private GetNextOutgoingPacketDelegate GetNextOutgoingPacketDelegatePointer;
+		private FGetNextOutgoingPacket _GetNextOutgoingPacket;
 		
 		#endregion
 		internal int GetNextOutgoingPacket( IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort )
 		{
-			return GetNextOutgoingPacketDelegatePointer( Self, pOut, cbMaxOut, ref pNetAdr, ref pPort );
+			return _GetNextOutgoingPacket( Self, pOut, cbMaxOut, ref pNetAdr, ref pPort );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void EnableHeartbeatsDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bActive );
+		private delegate void FEnableHeartbeats( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bActive );
-		private EnableHeartbeatsDelegate EnableHeartbeatsDelegatePointer;
+		private FEnableHeartbeats _EnableHeartbeats;
 		
 		#endregion
 		internal void EnableHeartbeats( [MarshalAs( UnmanagedType.U1 )] bool bActive )
 		{
-			EnableHeartbeatsDelegatePointer( Self, bActive );
+			_EnableHeartbeats( Self, bActive );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetHeartbeatIntervalDelegate( IntPtr self, int iHeartbeatInterval );
+		private delegate void FSetHeartbeatInterval( IntPtr self, int iHeartbeatInterval );
-		private SetHeartbeatIntervalDelegate SetHeartbeatIntervalDelegatePointer;
+		private FSetHeartbeatInterval _SetHeartbeatInterval;
 		
 		#endregion
 		internal void SetHeartbeatInterval( int iHeartbeatInterval )
 		{
-			SetHeartbeatIntervalDelegatePointer( Self, iHeartbeatInterval );
+			_SetHeartbeatInterval( Self, iHeartbeatInterval );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void ForceHeartbeatDelegate( IntPtr self );
+		private delegate void FForceHeartbeat( IntPtr self );
-		private ForceHeartbeatDelegate ForceHeartbeatDelegatePointer;
+		private FForceHeartbeat _ForceHeartbeat;
 		
 		#endregion
 		internal void ForceHeartbeat()
 		{
-			ForceHeartbeatDelegatePointer( Self );
+			_ForceHeartbeat( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t AssociateWithClanDelegate( IntPtr self, SteamId steamIDClan );
+		private delegate SteamAPICall_t FAssociateWithClan( IntPtr self, SteamId steamIDClan );
-		private AssociateWithClanDelegate AssociateWithClanDelegatePointer;
+		private FAssociateWithClan _AssociateWithClan;
 		
 		#endregion
 		internal async Task<AssociateWithClanResult_t?> AssociateWithClan( SteamId steamIDClan )
 		{
-			return await (new Result<AssociateWithClanResult_t>( AssociateWithClanDelegatePointer( Self, steamIDClan ) )).GetResult();
+			return await (new Result<AssociateWithClanResult_t>( _AssociateWithClan( Self, steamIDClan ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t ComputeNewPlayerCompatibilityDelegate( IntPtr self, SteamId steamIDNewPlayer );
+		private delegate SteamAPICall_t FComputeNewPlayerCompatibility( IntPtr self, SteamId steamIDNewPlayer );
-		private ComputeNewPlayerCompatibilityDelegate ComputeNewPlayerCompatibilityDelegatePointer;
+		private FComputeNewPlayerCompatibility _ComputeNewPlayerCompatibility;
 		
 		#endregion
 		internal async Task<ComputeNewPlayerCompatibilityResult_t?> ComputeNewPlayerCompatibility( SteamId steamIDNewPlayer )
 		{
-			return await (new Result<ComputeNewPlayerCompatibilityResult_t>( ComputeNewPlayerCompatibilityDelegatePointer( Self, steamIDNewPlayer ) )).GetResult();
+			return await (new Result<ComputeNewPlayerCompatibilityResult_t>( _ComputeNewPlayerCompatibility( Self, steamIDNewPlayer ) )).GetResult();
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingServers.cs

@@ -17,211 +17,211 @@ public ISteamMatchmakingServers( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			RequestInternetServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestInternetServerListDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_RequestInternetServerList = Marshal.GetDelegateForFunctionPointer<FRequestInternetServerList>( Marshal.ReadIntPtr( VTable, 0) );
-			RequestLANServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestLANServerListDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_RequestLANServerList = Marshal.GetDelegateForFunctionPointer<FRequestLANServerList>( Marshal.ReadIntPtr( VTable, 8) );
-			RequestFriendsServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestFriendsServerListDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_RequestFriendsServerList = Marshal.GetDelegateForFunctionPointer<FRequestFriendsServerList>( Marshal.ReadIntPtr( VTable, 16) );
-			RequestFavoritesServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestFavoritesServerListDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_RequestFavoritesServerList = Marshal.GetDelegateForFunctionPointer<FRequestFavoritesServerList>( Marshal.ReadIntPtr( VTable, 24) );
-			RequestHistoryServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestHistoryServerListDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_RequestHistoryServerList = Marshal.GetDelegateForFunctionPointer<FRequestHistoryServerList>( Marshal.ReadIntPtr( VTable, 32) );
-			RequestSpectatorServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestSpectatorServerListDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_RequestSpectatorServerList = Marshal.GetDelegateForFunctionPointer<FRequestSpectatorServerList>( Marshal.ReadIntPtr( VTable, 40) );
-			ReleaseRequestDelegatePointer = Marshal.GetDelegateForFunctionPointer<ReleaseRequestDelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_ReleaseRequest = Marshal.GetDelegateForFunctionPointer<FReleaseRequest>( Marshal.ReadIntPtr( VTable, 48) );
-			GetServerDetailsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerDetailsDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_GetServerDetails = Marshal.GetDelegateForFunctionPointer<FGetServerDetails>( Marshal.ReadIntPtr( VTable, 56) );
-			CancelQueryDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelQueryDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_CancelQuery = Marshal.GetDelegateForFunctionPointer<FCancelQuery>( Marshal.ReadIntPtr( VTable, 64) );
-			RefreshQueryDelegatePointer = Marshal.GetDelegateForFunctionPointer<RefreshQueryDelegate>( Marshal.ReadIntPtr( VTable, 72) );
+			_RefreshQuery = Marshal.GetDelegateForFunctionPointer<FRefreshQuery>( Marshal.ReadIntPtr( VTable, 72) );
-			IsRefreshingDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsRefreshingDelegate>( Marshal.ReadIntPtr( VTable, 80) );
+			_IsRefreshing = Marshal.GetDelegateForFunctionPointer<FIsRefreshing>( Marshal.ReadIntPtr( VTable, 80) );
-			GetServerCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerCountDelegate>( Marshal.ReadIntPtr( VTable, 88) );
+			_GetServerCount = Marshal.GetDelegateForFunctionPointer<FGetServerCount>( Marshal.ReadIntPtr( VTable, 88) );
-			RefreshServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<RefreshServerDelegate>( Marshal.ReadIntPtr( VTable, 96) );
+			_RefreshServer = Marshal.GetDelegateForFunctionPointer<FRefreshServer>( Marshal.ReadIntPtr( VTable, 96) );
-			PingServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<PingServerDelegate>( Marshal.ReadIntPtr( VTable, 104) );
+			_PingServer = Marshal.GetDelegateForFunctionPointer<FPingServer>( Marshal.ReadIntPtr( VTable, 104) );
-			PlayerDetailsDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayerDetailsDelegate>( Marshal.ReadIntPtr( VTable, 112) );
+			_PlayerDetails = Marshal.GetDelegateForFunctionPointer<FPlayerDetails>( Marshal.ReadIntPtr( VTable, 112) );
-			ServerRulesDelegatePointer = Marshal.GetDelegateForFunctionPointer<ServerRulesDelegate>( Marshal.ReadIntPtr( VTable, 120) );
+			_ServerRules = Marshal.GetDelegateForFunctionPointer<FServerRules>( Marshal.ReadIntPtr( VTable, 120) );
-			CancelServerQueryDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelServerQueryDelegate>( Marshal.ReadIntPtr( VTable, 128) );
+			_CancelServerQuery = Marshal.GetDelegateForFunctionPointer<FCancelServerQuery>( Marshal.ReadIntPtr( VTable, 128) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerListRequest RequestInternetServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
+		private delegate HServerListRequest FRequestInternetServerList( IntPtr self, AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
-		private RequestInternetServerListDelegate RequestInternetServerListDelegatePointer;
+		private FRequestInternetServerList _RequestInternetServerList;
 		
 		#endregion
-		internal HServerListRequest RequestInternetServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
+		internal HServerListRequest RequestInternetServerList( AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
 		{
-			return RequestInternetServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
+			return _RequestInternetServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerListRequest RequestLANServerListDelegate( IntPtr self, AppId_t iApp, IntPtr pRequestServersResponse );
+		private delegate HServerListRequest FRequestLANServerList( IntPtr self, AppId iApp, IntPtr pRequestServersResponse );
-		private RequestLANServerListDelegate RequestLANServerListDelegatePointer;
+		private FRequestLANServerList _RequestLANServerList;
 		
 		#endregion
-		internal HServerListRequest RequestLANServerList( AppId_t iApp, IntPtr pRequestServersResponse )
+		internal HServerListRequest RequestLANServerList( AppId iApp, IntPtr pRequestServersResponse )
 		{
-			return RequestLANServerListDelegatePointer( Self, iApp, pRequestServersResponse );
+			return _RequestLANServerList( Self, iApp, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerListRequest RequestFriendsServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
+		private delegate HServerListRequest FRequestFriendsServerList( IntPtr self, AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
-		private RequestFriendsServerListDelegate RequestFriendsServerListDelegatePointer;
+		private FRequestFriendsServerList _RequestFriendsServerList;
 		
 		#endregion
-		internal HServerListRequest RequestFriendsServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
+		internal HServerListRequest RequestFriendsServerList( AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
 		{
-			return RequestFriendsServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
+			return _RequestFriendsServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerListRequest RequestFavoritesServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
+		private delegate HServerListRequest FRequestFavoritesServerList( IntPtr self, AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
-		private RequestFavoritesServerListDelegate RequestFavoritesServerListDelegatePointer;
+		private FRequestFavoritesServerList _RequestFavoritesServerList;
 		
 		#endregion
-		internal HServerListRequest RequestFavoritesServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
+		internal HServerListRequest RequestFavoritesServerList( AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
 		{
-			return RequestFavoritesServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
+			return _RequestFavoritesServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerListRequest RequestHistoryServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
+		private delegate HServerListRequest FRequestHistoryServerList( IntPtr self, AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
-		private RequestHistoryServerListDelegate RequestHistoryServerListDelegatePointer;
+		private FRequestHistoryServerList _RequestHistoryServerList;
 		
 		#endregion
-		internal HServerListRequest RequestHistoryServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
+		internal HServerListRequest RequestHistoryServerList( AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
 		{
-			return RequestHistoryServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
+			return _RequestHistoryServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerListRequest RequestSpectatorServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
+		private delegate HServerListRequest FRequestSpectatorServerList( IntPtr self, AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
-		private RequestSpectatorServerListDelegate RequestSpectatorServerListDelegatePointer;
+		private FRequestSpectatorServerList _RequestSpectatorServerList;
 		
 		#endregion
-		internal HServerListRequest RequestSpectatorServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
+		internal HServerListRequest RequestSpectatorServerList( AppId iApp, [In,Out] ref MatchMakingKeyValuePair_t[]  ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
 		{
-			return RequestSpectatorServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
+			return _RequestSpectatorServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void ReleaseRequestDelegate( IntPtr self, HServerListRequest hServerListRequest );
+		private delegate void FReleaseRequest( IntPtr self, HServerListRequest hServerListRequest );
-		private ReleaseRequestDelegate ReleaseRequestDelegatePointer;
+		private FReleaseRequest _ReleaseRequest;
 		
 		#endregion
 		internal void ReleaseRequest( HServerListRequest hServerListRequest )
 		{
-			ReleaseRequestDelegatePointer( Self, hServerListRequest );
+			_ReleaseRequest( Self, hServerListRequest );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetServerDetailsDelegate( IntPtr self, HServerListRequest hRequest, int iServer );
+		private delegate IntPtr FGetServerDetails( IntPtr self, HServerListRequest hRequest, int iServer );
-		private GetServerDetailsDelegate GetServerDetailsDelegatePointer;
+		private FGetServerDetails _GetServerDetails;
 		
 		#endregion
 		internal gameserveritem_t GetServerDetails( HServerListRequest hRequest, int iServer )
 		{
-			return new gameserveritem_t().Fill( GetServerDetailsDelegatePointer( Self, hRequest, iServer ) );
+			return new gameserveritem_t().Fill( _GetServerDetails( Self, hRequest, iServer ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void CancelQueryDelegate( IntPtr self, HServerListRequest hRequest );
+		private delegate void FCancelQuery( IntPtr self, HServerListRequest hRequest );
-		private CancelQueryDelegate CancelQueryDelegatePointer;
+		private FCancelQuery _CancelQuery;
 		
 		#endregion
 		internal void CancelQuery( HServerListRequest hRequest )
 		{
-			CancelQueryDelegatePointer( Self, hRequest );
+			_CancelQuery( Self, hRequest );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void RefreshQueryDelegate( IntPtr self, HServerListRequest hRequest );
+		private delegate void FRefreshQuery( IntPtr self, HServerListRequest hRequest );
-		private RefreshQueryDelegate RefreshQueryDelegatePointer;
+		private FRefreshQuery _RefreshQuery;
 		
 		#endregion
 		internal void RefreshQuery( HServerListRequest hRequest )
 		{
-			RefreshQueryDelegatePointer( Self, hRequest );
+			_RefreshQuery( Self, hRequest );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsRefreshingDelegate( IntPtr self, HServerListRequest hRequest );
+		private delegate bool FIsRefreshing( IntPtr self, HServerListRequest hRequest );
-		private IsRefreshingDelegate IsRefreshingDelegatePointer;
+		private FIsRefreshing _IsRefreshing;
 		
 		#endregion
 		internal bool IsRefreshing( HServerListRequest hRequest )
 		{
-			return IsRefreshingDelegatePointer( Self, hRequest );
+			return _IsRefreshing( Self, hRequest );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetServerCountDelegate( IntPtr self, HServerListRequest hRequest );
+		private delegate int FGetServerCount( IntPtr self, HServerListRequest hRequest );
-		private GetServerCountDelegate GetServerCountDelegatePointer;
+		private FGetServerCount _GetServerCount;
 		
 		#endregion
 		internal int GetServerCount( HServerListRequest hRequest )
 		{
-			return GetServerCountDelegatePointer( Self, hRequest );
+			return _GetServerCount( Self, hRequest );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void RefreshServerDelegate( IntPtr self, HServerListRequest hRequest, int iServer );
+		private delegate void FRefreshServer( IntPtr self, HServerListRequest hRequest, int iServer );
-		private RefreshServerDelegate RefreshServerDelegatePointer;
+		private FRefreshServer _RefreshServer;
 		
 		#endregion
 		internal void RefreshServer( HServerListRequest hRequest, int iServer )
 		{
-			RefreshServerDelegatePointer( Self, hRequest, iServer );
+			_RefreshServer( Self, hRequest, iServer );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerQuery PingServerDelegate( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
+		private delegate HServerQuery FPingServer( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
-		private PingServerDelegate PingServerDelegatePointer;
+		private FPingServer _PingServer;
 		
 		#endregion
 		internal HServerQuery PingServer( uint unIP, ushort usPort, IntPtr pRequestServersResponse )
 		{
-			return PingServerDelegatePointer( Self, unIP, usPort, pRequestServersResponse );
+			return _PingServer( Self, unIP, usPort, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerQuery PlayerDetailsDelegate( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
+		private delegate HServerQuery FPlayerDetails( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
-		private PlayerDetailsDelegate PlayerDetailsDelegatePointer;
+		private FPlayerDetails _PlayerDetails;
 		
 		#endregion
 		internal HServerQuery PlayerDetails( uint unIP, ushort usPort, IntPtr pRequestServersResponse )
 		{
-			return PlayerDetailsDelegatePointer( Self, unIP, usPort, pRequestServersResponse );
+			return _PlayerDetails( Self, unIP, usPort, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HServerQuery ServerRulesDelegate( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
+		private delegate HServerQuery FServerRules( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
-		private ServerRulesDelegate ServerRulesDelegatePointer;
+		private FServerRules _ServerRules;
 		
 		#endregion
 		internal HServerQuery ServerRules( uint unIP, ushort usPort, IntPtr pRequestServersResponse )
 		{
-			return ServerRulesDelegatePointer( Self, unIP, usPort, pRequestServersResponse );
+			return _ServerRules( Self, unIP, usPort, pRequestServersResponse );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void CancelServerQueryDelegate( IntPtr self, HServerQuery hServerQuery );
+		private delegate void FCancelServerQuery( IntPtr self, HServerQuery hServerQuery );
-		private CancelServerQueryDelegate CancelServerQueryDelegatePointer;
+		private FCancelServerQuery _CancelServerQuery;
 		
 		#endregion
 		internal void CancelServerQuery( HServerQuery hServerQuery )
 		{
-			CancelServerQueryDelegatePointer( Self, hServerQuery );
+			_CancelServerQuery( Self, hServerQuery );
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamMusic.cs

@@ -17,116 +17,116 @@ public ISteamMusic( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			BIsEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsEnabledDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_BIsEnabled = Marshal.GetDelegateForFunctionPointer<FBIsEnabled>( Marshal.ReadIntPtr( VTable, 0) );
-			BIsPlayingDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPlayingDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_BIsPlaying = Marshal.GetDelegateForFunctionPointer<FBIsPlaying>( Marshal.ReadIntPtr( VTable, 8) );
-			GetPlaybackStatusDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetPlaybackStatusDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_GetPlaybackStatus = Marshal.GetDelegateForFunctionPointer<FGetPlaybackStatus>( Marshal.ReadIntPtr( VTable, 16) );
-			PlayDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_Play = Marshal.GetDelegateForFunctionPointer<FPlay>( Marshal.ReadIntPtr( VTable, 24) );
-			PauseDelegatePointer = Marshal.GetDelegateForFunctionPointer<PauseDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_Pause = Marshal.GetDelegateForFunctionPointer<FPause>( Marshal.ReadIntPtr( VTable, 32) );
-			PlayPreviousDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayPreviousDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_PlayPrevious = Marshal.GetDelegateForFunctionPointer<FPlayPrevious>( Marshal.ReadIntPtr( VTable, 40) );
-			PlayNextDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayNextDelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_PlayNext = Marshal.GetDelegateForFunctionPointer<FPlayNext>( Marshal.ReadIntPtr( VTable, 48) );
-			SetVolumeDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetVolumeDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_SetVolume = Marshal.GetDelegateForFunctionPointer<FSetVolume>( Marshal.ReadIntPtr( VTable, 56) );
-			GetVolumeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVolumeDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_GetVolume = Marshal.GetDelegateForFunctionPointer<FGetVolume>( Marshal.ReadIntPtr( VTable, 64) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsEnabledDelegate( IntPtr self );
+		private delegate bool FBIsEnabled( IntPtr self );
-		private BIsEnabledDelegate BIsEnabledDelegatePointer;
+		private FBIsEnabled _BIsEnabled;
 		
 		#endregion
 		internal bool BIsEnabled()
 		{
-			return BIsEnabledDelegatePointer( Self );
+			return _BIsEnabled( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsPlayingDelegate( IntPtr self );
+		private delegate bool FBIsPlaying( IntPtr self );
-		private BIsPlayingDelegate BIsPlayingDelegatePointer;
+		private FBIsPlaying _BIsPlaying;
 		
 		#endregion
 		internal bool BIsPlaying()
 		{
-			return BIsPlayingDelegatePointer( Self );
+			return _BIsPlaying( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate MusicStatus GetPlaybackStatusDelegate( IntPtr self );
+		private delegate MusicStatus FGetPlaybackStatus( IntPtr self );
-		private GetPlaybackStatusDelegate GetPlaybackStatusDelegatePointer;
+		private FGetPlaybackStatus _GetPlaybackStatus;
 		
 		#endregion
 		internal MusicStatus GetPlaybackStatus()
 		{
-			return GetPlaybackStatusDelegatePointer( Self );
+			return _GetPlaybackStatus( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void PlayDelegate( IntPtr self );
+		private delegate void FPlay( IntPtr self );
-		private PlayDelegate PlayDelegatePointer;
+		private FPlay _Play;
 		
 		#endregion
 		internal void Play()
 		{
-			PlayDelegatePointer( Self );
+			_Play( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void PauseDelegate( IntPtr self );
+		private delegate void FPause( IntPtr self );
-		private PauseDelegate PauseDelegatePointer;
+		private FPause _Pause;
 		
 		#endregion
 		internal void Pause()
 		{
-			PauseDelegatePointer( Self );
+			_Pause( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void PlayPreviousDelegate( IntPtr self );
+		private delegate void FPlayPrevious( IntPtr self );
-		private PlayPreviousDelegate PlayPreviousDelegatePointer;
+		private FPlayPrevious _PlayPrevious;
 		
 		#endregion
 		internal void PlayPrevious()
 		{
-			PlayPreviousDelegatePointer( Self );
+			_PlayPrevious( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void PlayNextDelegate( IntPtr self );
+		private delegate void FPlayNext( IntPtr self );
-		private PlayNextDelegate PlayNextDelegatePointer;
+		private FPlayNext _PlayNext;
 		
 		#endregion
 		internal void PlayNext()
 		{
-			PlayNextDelegatePointer( Self );
+			_PlayNext( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetVolumeDelegate( IntPtr self, float flVolume );
+		private delegate void FSetVolume( IntPtr self, float flVolume );
-		private SetVolumeDelegate SetVolumeDelegatePointer;
+		private FSetVolume _SetVolume;
 		
 		#endregion
 		internal void SetVolume( float flVolume )
 		{
-			SetVolumeDelegatePointer( Self, flVolume );
+			_SetVolume( Self, flVolume );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate float GetVolumeDelegate( IntPtr self );
+		private delegate float FGetVolume( IntPtr self );
-		private GetVolumeDelegate GetVolumeDelegatePointer;
+		private FGetVolume _GetVolume;
 		
 		#endregion
 		internal float GetVolume()
 		{
-			return GetVolumeDelegatePointer( Self );
+			return _GetVolume( Self );
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamParentalSettings.cs

@@ -17,84 +17,84 @@ public ISteamParentalSettings( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			BIsParentalLockEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsParentalLockEnabledDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_BIsParentalLockEnabled = Marshal.GetDelegateForFunctionPointer<FBIsParentalLockEnabled>( Marshal.ReadIntPtr( VTable, 0) );
-			BIsParentalLockLockedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsParentalLockLockedDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_BIsParentalLockLocked = Marshal.GetDelegateForFunctionPointer<FBIsParentalLockLocked>( Marshal.ReadIntPtr( VTable, 8) );
-			BIsAppBlockedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsAppBlockedDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_BIsAppBlocked = Marshal.GetDelegateForFunctionPointer<FBIsAppBlocked>( Marshal.ReadIntPtr( VTable, 16) );
-			BIsAppInBlockListDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsAppInBlockListDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_BIsAppInBlockList = Marshal.GetDelegateForFunctionPointer<FBIsAppInBlockList>( Marshal.ReadIntPtr( VTable, 24) );
-			BIsFeatureBlockedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsFeatureBlockedDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_BIsFeatureBlocked = Marshal.GetDelegateForFunctionPointer<FBIsFeatureBlocked>( Marshal.ReadIntPtr( VTable, 32) );
-			BIsFeatureInBlockListDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsFeatureInBlockListDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_BIsFeatureInBlockList = Marshal.GetDelegateForFunctionPointer<FBIsFeatureInBlockList>( Marshal.ReadIntPtr( VTable, 40) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsParentalLockEnabledDelegate( IntPtr self );
+		private delegate bool FBIsParentalLockEnabled( IntPtr self );
-		private BIsParentalLockEnabledDelegate BIsParentalLockEnabledDelegatePointer;
+		private FBIsParentalLockEnabled _BIsParentalLockEnabled;
 		
 		#endregion
 		internal bool BIsParentalLockEnabled()
 		{
-			return BIsParentalLockEnabledDelegatePointer( Self );
+			return _BIsParentalLockEnabled( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsParentalLockLockedDelegate( IntPtr self );
+		private delegate bool FBIsParentalLockLocked( IntPtr self );
-		private BIsParentalLockLockedDelegate BIsParentalLockLockedDelegatePointer;
+		private FBIsParentalLockLocked _BIsParentalLockLocked;
 		
 		#endregion
 		internal bool BIsParentalLockLocked()
 		{
-			return BIsParentalLockLockedDelegatePointer( Self );
+			return _BIsParentalLockLocked( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsAppBlockedDelegate( IntPtr self, AppId_t nAppID );
+		private delegate bool FBIsAppBlocked( IntPtr self, AppId nAppID );
-		private BIsAppBlockedDelegate BIsAppBlockedDelegatePointer;
+		private FBIsAppBlocked _BIsAppBlocked;
 		
 		#endregion
-		internal bool BIsAppBlocked( AppId_t nAppID )
+		internal bool BIsAppBlocked( AppId nAppID )
 		{
-			return BIsAppBlockedDelegatePointer( Self, nAppID );
+			return _BIsAppBlocked( Self, nAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsAppInBlockListDelegate( IntPtr self, AppId_t nAppID );
+		private delegate bool FBIsAppInBlockList( IntPtr self, AppId nAppID );
-		private BIsAppInBlockListDelegate BIsAppInBlockListDelegatePointer;
+		private FBIsAppInBlockList _BIsAppInBlockList;
 		
 		#endregion
-		internal bool BIsAppInBlockList( AppId_t nAppID )
+		internal bool BIsAppInBlockList( AppId nAppID )
 		{
-			return BIsAppInBlockListDelegatePointer( Self, nAppID );
+			return _BIsAppInBlockList( Self, nAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsFeatureBlockedDelegate( IntPtr self, ParentalFeature eFeature );
+		private delegate bool FBIsFeatureBlocked( IntPtr self, ParentalFeature eFeature );
-		private BIsFeatureBlockedDelegate BIsFeatureBlockedDelegatePointer;
+		private FBIsFeatureBlocked _BIsFeatureBlocked;
 		
 		#endregion
 		internal bool BIsFeatureBlocked( ParentalFeature eFeature )
 		{
-			return BIsFeatureBlockedDelegatePointer( Self, eFeature );
+			return _BIsFeatureBlocked( Self, eFeature );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsFeatureInBlockListDelegate( IntPtr self, ParentalFeature eFeature );
+		private delegate bool FBIsFeatureInBlockList( IntPtr self, ParentalFeature eFeature );
-		private BIsFeatureInBlockListDelegate BIsFeatureInBlockListDelegatePointer;
+		private FBIsFeatureInBlockList _BIsFeatureInBlockList;
 		
 		#endregion
 		internal bool BIsFeatureInBlockList( ParentalFeature eFeature )
 		{
-			return BIsFeatureInBlockListDelegatePointer( Self, eFeature );
+			return _BIsFeatureInBlockList( Self, eFeature );
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamScreenshots.cs

@@ -17,118 +17,118 @@ public ISteamScreenshots( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			WriteScreenshotDelegatePointer = Marshal.GetDelegateForFunctionPointer<WriteScreenshotDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_WriteScreenshot = Marshal.GetDelegateForFunctionPointer<FWriteScreenshot>( Marshal.ReadIntPtr( VTable, 0) );
-			AddScreenshotToLibraryDelegatePointer = Marshal.GetDelegateForFunctionPointer<AddScreenshotToLibraryDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_AddScreenshotToLibrary = Marshal.GetDelegateForFunctionPointer<FAddScreenshotToLibrary>( Marshal.ReadIntPtr( VTable, 8) );
-			TriggerScreenshotDelegatePointer = Marshal.GetDelegateForFunctionPointer<TriggerScreenshotDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_TriggerScreenshot = Marshal.GetDelegateForFunctionPointer<FTriggerScreenshot>( Marshal.ReadIntPtr( VTable, 16) );
-			HookScreenshotsDelegatePointer = Marshal.GetDelegateForFunctionPointer<HookScreenshotsDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_HookScreenshots = Marshal.GetDelegateForFunctionPointer<FHookScreenshots>( Marshal.ReadIntPtr( VTable, 24) );
-			SetLocationDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetLocationDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_SetLocation = Marshal.GetDelegateForFunctionPointer<FSetLocation>( Marshal.ReadIntPtr( VTable, 32) );
-			TagUserDelegatePointer = Marshal.GetDelegateForFunctionPointer<TagUserDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_TagUser = Marshal.GetDelegateForFunctionPointer<FTagUser>( Marshal.ReadIntPtr( VTable, 40) );
-			TagPublishedFileDelegatePointer = Marshal.GetDelegateForFunctionPointer<TagPublishedFileDelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_TagPublishedFile = Marshal.GetDelegateForFunctionPointer<FTagPublishedFile>( Marshal.ReadIntPtr( VTable, 48) );
-			IsScreenshotsHookedDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsScreenshotsHookedDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_IsScreenshotsHooked = Marshal.GetDelegateForFunctionPointer<FIsScreenshotsHooked>( Marshal.ReadIntPtr( VTable, 56) );
-			AddVRScreenshotToLibraryDelegatePointer = Marshal.GetDelegateForFunctionPointer<AddVRScreenshotToLibraryDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_AddVRScreenshotToLibrary = Marshal.GetDelegateForFunctionPointer<FAddVRScreenshotToLibrary>( Marshal.ReadIntPtr( VTable, 64) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate ScreenshotHandle WriteScreenshotDelegate( IntPtr self, IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight );
+		private delegate ScreenshotHandle FWriteScreenshot( IntPtr self, IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight );
-		private WriteScreenshotDelegate WriteScreenshotDelegatePointer;
+		private FWriteScreenshot _WriteScreenshot;
 		
 		#endregion
 		internal ScreenshotHandle WriteScreenshot( IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight )
 		{
-			return WriteScreenshotDelegatePointer( Self, pubRGB, cubRGB, nWidth, nHeight );
+			return _WriteScreenshot( Self, pubRGB, cubRGB, nWidth, nHeight );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate ScreenshotHandle AddScreenshotToLibraryDelegate( IntPtr self, string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight );
+		private delegate ScreenshotHandle FAddScreenshotToLibrary( IntPtr self, string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight );
-		private AddScreenshotToLibraryDelegate AddScreenshotToLibraryDelegatePointer;
+		private FAddScreenshotToLibrary _AddScreenshotToLibrary;
 		
 		#endregion
 		internal ScreenshotHandle AddScreenshotToLibrary( string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight )
 		{
-			return AddScreenshotToLibraryDelegatePointer( Self, pchFilename, pchThumbnailFilename, nWidth, nHeight );
+			return _AddScreenshotToLibrary( Self, pchFilename, pchThumbnailFilename, nWidth, nHeight );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void TriggerScreenshotDelegate( IntPtr self );
+		private delegate void FTriggerScreenshot( IntPtr self );
-		private TriggerScreenshotDelegate TriggerScreenshotDelegatePointer;
+		private FTriggerScreenshot _TriggerScreenshot;
 		
 		#endregion
 		internal void TriggerScreenshot()
 		{
-			TriggerScreenshotDelegatePointer( Self );
+			_TriggerScreenshot( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void HookScreenshotsDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bHook );
+		private delegate void FHookScreenshots( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bHook );
-		private HookScreenshotsDelegate HookScreenshotsDelegatePointer;
+		private FHookScreenshots _HookScreenshots;
 		
 		#endregion
 		internal void HookScreenshots( [MarshalAs( UnmanagedType.U1 )] bool bHook )
 		{
-			HookScreenshotsDelegatePointer( Self, bHook );
+			_HookScreenshots( Self, bHook );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool SetLocationDelegate( IntPtr self, ScreenshotHandle hScreenshot, string pchLocation );
+		private delegate bool FSetLocation( IntPtr self, ScreenshotHandle hScreenshot, string pchLocation );
-		private SetLocationDelegate SetLocationDelegatePointer;
+		private FSetLocation _SetLocation;
 		
 		#endregion
 		internal bool SetLocation( ScreenshotHandle hScreenshot, string pchLocation )
 		{
-			return SetLocationDelegatePointer( Self, hScreenshot, pchLocation );
+			return _SetLocation( Self, hScreenshot, pchLocation );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool TagUserDelegate( IntPtr self, ScreenshotHandle hScreenshot, SteamId steamID );
+		private delegate bool FTagUser( IntPtr self, ScreenshotHandle hScreenshot, SteamId steamID );
-		private TagUserDelegate TagUserDelegatePointer;
+		private FTagUser _TagUser;
 		
 		#endregion
 		internal bool TagUser( ScreenshotHandle hScreenshot, SteamId steamID )
 		{
-			return TagUserDelegatePointer( Self, hScreenshot, steamID );
+			return _TagUser( Self, hScreenshot, steamID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool TagPublishedFileDelegate( IntPtr self, ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID );
+		private delegate bool FTagPublishedFile( IntPtr self, ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID );
-		private TagPublishedFileDelegate TagPublishedFileDelegatePointer;
+		private FTagPublishedFile _TagPublishedFile;
 		
 		#endregion
 		internal bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID )
 		{
-			return TagPublishedFileDelegatePointer( Self, hScreenshot, unPublishedFileID );
+			return _TagPublishedFile( Self, hScreenshot, unPublishedFileID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsScreenshotsHookedDelegate( IntPtr self );
+		private delegate bool FIsScreenshotsHooked( IntPtr self );
-		private IsScreenshotsHookedDelegate IsScreenshotsHookedDelegatePointer;
+		private FIsScreenshotsHooked _IsScreenshotsHooked;
 		
 		#endregion
 		internal bool IsScreenshotsHooked()
 		{
-			return IsScreenshotsHookedDelegatePointer( Self );
+			return _IsScreenshotsHooked( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate ScreenshotHandle AddVRScreenshotToLibraryDelegate( IntPtr self, VRScreenshotType eType, string pchFilename, string pchVRFilename );
+		private delegate ScreenshotHandle FAddVRScreenshotToLibrary( IntPtr self, VRScreenshotType eType, string pchFilename, string pchVRFilename );
-		private AddVRScreenshotToLibraryDelegate AddVRScreenshotToLibraryDelegatePointer;
+		private FAddVRScreenshotToLibrary _AddVRScreenshotToLibrary;
 		
 		#endregion
 		internal ScreenshotHandle AddVRScreenshotToLibrary( VRScreenshotType eType, string pchFilename, string pchVRFilename )
 		{
-			return AddVRScreenshotToLibraryDelegatePointer( Self, eType, pchFilename, pchVRFilename );
+			return _AddVRScreenshotToLibrary( Self, eType, pchFilename, pchVRFilename );
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamUGC.cs

@@ -0,0 +1,980 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Steamworks.Data;
+
+
+namespace Steamworks
+{
+	internal class ISteamUGC : SteamInterface
+	{
+		public ISteamUGC( bool server = false ) : base( server )
+		{
+		}
+		
+		public override string InterfaceName => "STEAMUGC_INTERFACE_VERSION012";
+		
+		public override void InitInternals()
+		{
+			_CreateQueryUserUGCRequest = Marshal.GetDelegateForFunctionPointer<FCreateQueryUserUGCRequest>( Marshal.ReadIntPtr( VTable, 0) );
+			_CreateQueryAllUGCRequest1 = Marshal.GetDelegateForFunctionPointer<FCreateQueryAllUGCRequest1>( Marshal.ReadIntPtr( VTable, 16) );
+			_CreateQueryAllUGCRequest2 = Marshal.GetDelegateForFunctionPointer<FCreateQueryAllUGCRequest2>( Marshal.ReadIntPtr( VTable, 8) );
+			_CreateQueryUGCDetailsRequest = Marshal.GetDelegateForFunctionPointer<FCreateQueryUGCDetailsRequest>( Marshal.ReadIntPtr( VTable, 24) );
+			_SendQueryUGCRequest = Marshal.GetDelegateForFunctionPointer<FSendQueryUGCRequest>( Marshal.ReadIntPtr( VTable, 32) );
+			_GetQueryUGCResult = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCResult>( Marshal.ReadIntPtr( VTable, 40) );
+			_GetQueryUGCPreviewURL = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCPreviewURL>( Marshal.ReadIntPtr( VTable, 48) );
+			_GetQueryUGCMetadata = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCMetadata>( Marshal.ReadIntPtr( VTable, 56) );
+			_GetQueryUGCChildren = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCChildren>( Marshal.ReadIntPtr( VTable, 64) );
+			_GetQueryUGCStatistic = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCStatistic>( Marshal.ReadIntPtr( VTable, 72) );
+			_GetQueryUGCNumAdditionalPreviews = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCNumAdditionalPreviews>( Marshal.ReadIntPtr( VTable, 80) );
+			_GetQueryUGCAdditionalPreview = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCAdditionalPreview>( Marshal.ReadIntPtr( VTable, 88) );
+			_GetQueryUGCNumKeyValueTags = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCNumKeyValueTags>( Marshal.ReadIntPtr( VTable, 96) );
+			_GetQueryUGCKeyValueTag = Marshal.GetDelegateForFunctionPointer<FGetQueryUGCKeyValueTag>( Marshal.ReadIntPtr( VTable, 104) );
+			_ReleaseQueryUGCRequest = Marshal.GetDelegateForFunctionPointer<FReleaseQueryUGCRequest>( Marshal.ReadIntPtr( VTable, 112) );
+			_AddRequiredTag = Marshal.GetDelegateForFunctionPointer<FAddRequiredTag>( Marshal.ReadIntPtr( VTable, 120) );
+			_AddExcludedTag = Marshal.GetDelegateForFunctionPointer<FAddExcludedTag>( Marshal.ReadIntPtr( VTable, 128) );
+			_SetReturnOnlyIDs = Marshal.GetDelegateForFunctionPointer<FSetReturnOnlyIDs>( Marshal.ReadIntPtr( VTable, 136) );
+			_SetReturnKeyValueTags = Marshal.GetDelegateForFunctionPointer<FSetReturnKeyValueTags>( Marshal.ReadIntPtr( VTable, 144) );
+			_SetReturnLongDescription = Marshal.GetDelegateForFunctionPointer<FSetReturnLongDescription>( Marshal.ReadIntPtr( VTable, 152) );
+			_SetReturnMetadata = Marshal.GetDelegateForFunctionPointer<FSetReturnMetadata>( Marshal.ReadIntPtr( VTable, 160) );
+			_SetReturnChildren = Marshal.GetDelegateForFunctionPointer<FSetReturnChildren>( Marshal.ReadIntPtr( VTable, 168) );
+			_SetReturnAdditionalPreviews = Marshal.GetDelegateForFunctionPointer<FSetReturnAdditionalPreviews>( Marshal.ReadIntPtr( VTable, 176) );
+			_SetReturnTotalOnly = Marshal.GetDelegateForFunctionPointer<FSetReturnTotalOnly>( Marshal.ReadIntPtr( VTable, 184) );
+			_SetReturnPlaytimeStats = Marshal.GetDelegateForFunctionPointer<FSetReturnPlaytimeStats>( Marshal.ReadIntPtr( VTable, 192) );
+			_SetLanguage = Marshal.GetDelegateForFunctionPointer<FSetLanguage>( Marshal.ReadIntPtr( VTable, 200) );
+			_SetAllowCachedResponse = Marshal.GetDelegateForFunctionPointer<FSetAllowCachedResponse>( Marshal.ReadIntPtr( VTable, 208) );
+			_SetCloudFileNameFilter = Marshal.GetDelegateForFunctionPointer<FSetCloudFileNameFilter>( Marshal.ReadIntPtr( VTable, 216) );
+			_SetMatchAnyTag = Marshal.GetDelegateForFunctionPointer<FSetMatchAnyTag>( Marshal.ReadIntPtr( VTable, 224) );
+			_SetSearchText = Marshal.GetDelegateForFunctionPointer<FSetSearchText>( Marshal.ReadIntPtr( VTable, 232) );
+			_SetRankedByTrendDays = Marshal.GetDelegateForFunctionPointer<FSetRankedByTrendDays>( Marshal.ReadIntPtr( VTable, 240) );
+			_AddRequiredKeyValueTag = Marshal.GetDelegateForFunctionPointer<FAddRequiredKeyValueTag>( Marshal.ReadIntPtr( VTable, 248) );
+			_RequestUGCDetails = Marshal.GetDelegateForFunctionPointer<FRequestUGCDetails>( Marshal.ReadIntPtr( VTable, 256) );
+			_CreateItem = Marshal.GetDelegateForFunctionPointer<FCreateItem>( Marshal.ReadIntPtr( VTable, 264) );
+			_StartItemUpdate = Marshal.GetDelegateForFunctionPointer<FStartItemUpdate>( Marshal.ReadIntPtr( VTable, 272) );
+			_SetItemTitle = Marshal.GetDelegateForFunctionPointer<FSetItemTitle>( Marshal.ReadIntPtr( VTable, 280) );
+			_SetItemDescription = Marshal.GetDelegateForFunctionPointer<FSetItemDescription>( Marshal.ReadIntPtr( VTable, 288) );
+			_SetItemUpdateLanguage = Marshal.GetDelegateForFunctionPointer<FSetItemUpdateLanguage>( Marshal.ReadIntPtr( VTable, 296) );
+			_SetItemMetadata = Marshal.GetDelegateForFunctionPointer<FSetItemMetadata>( Marshal.ReadIntPtr( VTable, 304) );
+			_SetItemVisibility = Marshal.GetDelegateForFunctionPointer<FSetItemVisibility>( Marshal.ReadIntPtr( VTable, 312) );
+			_SetItemTags = Marshal.GetDelegateForFunctionPointer<FSetItemTags>( Marshal.ReadIntPtr( VTable, 320) );
+			_SetItemContent = Marshal.GetDelegateForFunctionPointer<FSetItemContent>( Marshal.ReadIntPtr( VTable, 328) );
+			_SetItemPreview = Marshal.GetDelegateForFunctionPointer<FSetItemPreview>( Marshal.ReadIntPtr( VTable, 336) );
+			_SetAllowLegacyUpload = Marshal.GetDelegateForFunctionPointer<FSetAllowLegacyUpload>( Marshal.ReadIntPtr( VTable, 344) );
+			_RemoveItemKeyValueTags = Marshal.GetDelegateForFunctionPointer<FRemoveItemKeyValueTags>( Marshal.ReadIntPtr( VTable, 352) );
+			_AddItemKeyValueTag = Marshal.GetDelegateForFunctionPointer<FAddItemKeyValueTag>( Marshal.ReadIntPtr( VTable, 360) );
+			_AddItemPreviewFile = Marshal.GetDelegateForFunctionPointer<FAddItemPreviewFile>( Marshal.ReadIntPtr( VTable, 368) );
+			_AddItemPreviewVideo = Marshal.GetDelegateForFunctionPointer<FAddItemPreviewVideo>( Marshal.ReadIntPtr( VTable, 376) );
+			_UpdateItemPreviewFile = Marshal.GetDelegateForFunctionPointer<FUpdateItemPreviewFile>( Marshal.ReadIntPtr( VTable, 384) );
+			_UpdateItemPreviewVideo = Marshal.GetDelegateForFunctionPointer<FUpdateItemPreviewVideo>( Marshal.ReadIntPtr( VTable, 392) );
+			_RemoveItemPreview = Marshal.GetDelegateForFunctionPointer<FRemoveItemPreview>( Marshal.ReadIntPtr( VTable, 400) );
+			_SubmitItemUpdate = Marshal.GetDelegateForFunctionPointer<FSubmitItemUpdate>( Marshal.ReadIntPtr( VTable, 408) );
+			_GetItemUpdateProgress = Marshal.GetDelegateForFunctionPointer<FGetItemUpdateProgress>( Marshal.ReadIntPtr( VTable, 416) );
+			_SetUserItemVote = Marshal.GetDelegateForFunctionPointer<FSetUserItemVote>( Marshal.ReadIntPtr( VTable, 424) );
+			_GetUserItemVote = Marshal.GetDelegateForFunctionPointer<FGetUserItemVote>( Marshal.ReadIntPtr( VTable, 432) );
+			_AddItemToFavorites = Marshal.GetDelegateForFunctionPointer<FAddItemToFavorites>( Marshal.ReadIntPtr( VTable, 440) );
+			_RemoveItemFromFavorites = Marshal.GetDelegateForFunctionPointer<FRemoveItemFromFavorites>( Marshal.ReadIntPtr( VTable, 448) );
+			_SubscribeItem = Marshal.GetDelegateForFunctionPointer<FSubscribeItem>( Marshal.ReadIntPtr( VTable, 456) );
+			_UnsubscribeItem = Marshal.GetDelegateForFunctionPointer<FUnsubscribeItem>( Marshal.ReadIntPtr( VTable, 464) );
+			_GetNumSubscribedItems = Marshal.GetDelegateForFunctionPointer<FGetNumSubscribedItems>( Marshal.ReadIntPtr( VTable, 472) );
+			_GetSubscribedItems = Marshal.GetDelegateForFunctionPointer<FGetSubscribedItems>( Marshal.ReadIntPtr( VTable, 480) );
+			_GetItemState = Marshal.GetDelegateForFunctionPointer<FGetItemState>( Marshal.ReadIntPtr( VTable, 488) );
+			_GetItemInstallInfo = Marshal.GetDelegateForFunctionPointer<FGetItemInstallInfo>( Marshal.ReadIntPtr( VTable, 496) );
+			_GetItemDownloadInfo = Marshal.GetDelegateForFunctionPointer<FGetItemDownloadInfo>( Marshal.ReadIntPtr( VTable, 504) );
+			_DownloadItem = Marshal.GetDelegateForFunctionPointer<FDownloadItem>( Marshal.ReadIntPtr( VTable, 512) );
+			_BInitWorkshopForGameServer = Marshal.GetDelegateForFunctionPointer<FBInitWorkshopForGameServer>( Marshal.ReadIntPtr( VTable, 520) );
+			_SuspendDownloads = Marshal.GetDelegateForFunctionPointer<FSuspendDownloads>( Marshal.ReadIntPtr( VTable, 528) );
+			_StartPlaytimeTracking = Marshal.GetDelegateForFunctionPointer<FStartPlaytimeTracking>( Marshal.ReadIntPtr( VTable, 536) );
+			_StopPlaytimeTracking = Marshal.GetDelegateForFunctionPointer<FStopPlaytimeTracking>( Marshal.ReadIntPtr( VTable, 544) );
+			_StopPlaytimeTrackingForAllItems = Marshal.GetDelegateForFunctionPointer<FStopPlaytimeTrackingForAllItems>( Marshal.ReadIntPtr( VTable, 552) );
+			_AddDependency = Marshal.GetDelegateForFunctionPointer<FAddDependency>( Marshal.ReadIntPtr( VTable, 560) );
+			_RemoveDependency = Marshal.GetDelegateForFunctionPointer<FRemoveDependency>( Marshal.ReadIntPtr( VTable, 568) );
+			_AddAppDependency = Marshal.GetDelegateForFunctionPointer<FAddAppDependency>( Marshal.ReadIntPtr( VTable, 576) );
+			_RemoveAppDependency = Marshal.GetDelegateForFunctionPointer<FRemoveAppDependency>( Marshal.ReadIntPtr( VTable, 584) );
+			_GetAppDependencies = Marshal.GetDelegateForFunctionPointer<FGetAppDependencies>( Marshal.ReadIntPtr( VTable, 592) );
+			_DeleteItem = Marshal.GetDelegateForFunctionPointer<FDeleteItem>( Marshal.ReadIntPtr( VTable, 600) );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate UGCQueryHandle_t FCreateQueryUserUGCRequest( IntPtr self, AccountID_t unAccountID, UserUGCList eListType, UgcType eMatchingUGCType, UserUGCListSortOrder eSortOrder, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage );
+		private FCreateQueryUserUGCRequest _CreateQueryUserUGCRequest;
+		
+		#endregion
+		internal UGCQueryHandle_t CreateQueryUserUGCRequest( AccountID_t unAccountID, UserUGCList eListType, UgcType eMatchingUGCType, UserUGCListSortOrder eSortOrder, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage )
+		{
+			return _CreateQueryUserUGCRequest( Self, unAccountID, eListType, eMatchingUGCType, eSortOrder, nCreatorAppID, nConsumerAppID, unPage );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate UGCQueryHandle_t FCreateQueryAllUGCRequest1( IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage );
+		private FCreateQueryAllUGCRequest1 _CreateQueryAllUGCRequest1;
+		
+		#endregion
+		internal UGCQueryHandle_t CreateQueryAllUGCRequest1( UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, uint unPage )
+		{
+			return _CreateQueryAllUGCRequest1( Self, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, unPage );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate UGCQueryHandle_t FCreateQueryAllUGCRequest2( IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, string pchCursor );
+		private FCreateQueryAllUGCRequest2 _CreateQueryAllUGCRequest2;
+		
+		#endregion
+		internal UGCQueryHandle_t CreateQueryAllUGCRequest2( UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, string pchCursor )
+		{
+			return _CreateQueryAllUGCRequest2( Self, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate UGCQueryHandle_t FCreateQueryUGCDetailsRequest( IntPtr self, [In,Out] PublishedFileId[]  pvecPublishedFileID, uint unNumPublishedFileIDs );
+		private FCreateQueryUGCDetailsRequest _CreateQueryUGCDetailsRequest;
+		
+		#endregion
+		internal UGCQueryHandle_t CreateQueryUGCDetailsRequest( [In,Out] PublishedFileId[]  pvecPublishedFileID, uint unNumPublishedFileIDs )
+		{
+			return _CreateQueryUGCDetailsRequest( Self, pvecPublishedFileID, unNumPublishedFileIDs );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FSendQueryUGCRequest( IntPtr self, UGCQueryHandle_t handle );
+		private FSendQueryUGCRequest _SendQueryUGCRequest;
+		
+		#endregion
+		internal async Task<SteamUGCQueryCompleted_t?> SendQueryUGCRequest( UGCQueryHandle_t handle )
+		{
+			return await (new Result<SteamUGCQueryCompleted_t>( _SendQueryUGCRequest( Self, handle ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetQueryUGCResult( IntPtr self, UGCQueryHandle_t handle, uint index, ref SteamUGCDetails_t pDetails );
+		private FGetQueryUGCResult _GetQueryUGCResult;
+		
+		#endregion
+		internal bool GetQueryUGCResult( UGCQueryHandle_t handle, uint index, ref SteamUGCDetails_t pDetails )
+		{
+			return _GetQueryUGCResult( Self, handle, index, ref pDetails );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetQueryUGCPreviewURL( IntPtr self, UGCQueryHandle_t handle, uint index, StringBuilder pchURL, uint cchURLSize );
+		private FGetQueryUGCPreviewURL _GetQueryUGCPreviewURL;
+		
+		#endregion
+		internal bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint index, StringBuilder pchURL, uint cchURLSize )
+		{
+			return _GetQueryUGCPreviewURL( Self, handle, index, pchURL, cchURLSize );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetQueryUGCMetadata( IntPtr self, UGCQueryHandle_t handle, uint index, StringBuilder pchMetadata, uint cchMetadatasize );
+		private FGetQueryUGCMetadata _GetQueryUGCMetadata;
+		
+		#endregion
+		internal bool GetQueryUGCMetadata( UGCQueryHandle_t handle, uint index, StringBuilder pchMetadata, uint cchMetadatasize )
+		{
+			return _GetQueryUGCMetadata( Self, handle, index, pchMetadata, cchMetadatasize );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetQueryUGCChildren( IntPtr self, UGCQueryHandle_t handle, uint index, [In,Out] PublishedFileId[]  pvecPublishedFileID, uint cMaxEntries );
+		private FGetQueryUGCChildren _GetQueryUGCChildren;
+		
+		#endregion
+		internal bool GetQueryUGCChildren( UGCQueryHandle_t handle, uint index, [In,Out] PublishedFileId[]  pvecPublishedFileID, uint cMaxEntries )
+		{
+			return _GetQueryUGCChildren( Self, handle, index, pvecPublishedFileID, cMaxEntries );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetQueryUGCStatistic( IntPtr self, UGCQueryHandle_t handle, uint index, ItemStatistic eStatType, ref ulong pStatValue );
+		private FGetQueryUGCStatistic _GetQueryUGCStatistic;
+		
+		#endregion
+		internal bool GetQueryUGCStatistic( UGCQueryHandle_t handle, uint index, ItemStatistic eStatType, ref ulong pStatValue )
+		{
+			return _GetQueryUGCStatistic( Self, handle, index, eStatType, ref pStatValue );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate uint FGetQueryUGCNumAdditionalPreviews( IntPtr self, UGCQueryHandle_t handle, uint index );
+		private FGetQueryUGCNumAdditionalPreviews _GetQueryUGCNumAdditionalPreviews;
+		
+		#endregion
+		internal uint GetQueryUGCNumAdditionalPreviews( UGCQueryHandle_t handle, uint index )
+		{
+			return _GetQueryUGCNumAdditionalPreviews( Self, handle, index );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetQueryUGCAdditionalPreview( IntPtr self, UGCQueryHandle_t handle, uint index, uint previewIndex, StringBuilder pchURLOrVideoID, uint cchURLSize, StringBuilder pchOriginalFileName, uint cchOriginalFileNameSize, ref ItemPreviewType pPreviewType );
+		private FGetQueryUGCAdditionalPreview _GetQueryUGCAdditionalPreview;
+		
+		#endregion
+		internal bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint index, uint previewIndex, StringBuilder pchURLOrVideoID, uint cchURLSize, StringBuilder pchOriginalFileName, uint cchOriginalFileNameSize, ref ItemPreviewType pPreviewType )
+		{
+			return _GetQueryUGCAdditionalPreview( Self, handle, index, previewIndex, pchURLOrVideoID, cchURLSize, pchOriginalFileName, cchOriginalFileNameSize, ref pPreviewType );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate uint FGetQueryUGCNumKeyValueTags( IntPtr self, UGCQueryHandle_t handle, uint index );
+		private FGetQueryUGCNumKeyValueTags _GetQueryUGCNumKeyValueTags;
+		
+		#endregion
+		internal uint GetQueryUGCNumKeyValueTags( UGCQueryHandle_t handle, uint index )
+		{
+			return _GetQueryUGCNumKeyValueTags( Self, handle, index );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetQueryUGCKeyValueTag( IntPtr self, UGCQueryHandle_t handle, uint index, uint keyValueTagIndex, StringBuilder pchKey, uint cchKeySize, StringBuilder pchValue, uint cchValueSize );
+		private FGetQueryUGCKeyValueTag _GetQueryUGCKeyValueTag;
+		
+		#endregion
+		internal bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint index, uint keyValueTagIndex, StringBuilder pchKey, uint cchKeySize, StringBuilder pchValue, uint cchValueSize )
+		{
+			return _GetQueryUGCKeyValueTag( Self, handle, index, keyValueTagIndex, pchKey, cchKeySize, pchValue, cchValueSize );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FReleaseQueryUGCRequest( IntPtr self, UGCQueryHandle_t handle );
+		private FReleaseQueryUGCRequest _ReleaseQueryUGCRequest;
+		
+		#endregion
+		internal bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle )
+		{
+			return _ReleaseQueryUGCRequest( Self, handle );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FAddRequiredTag( IntPtr self, UGCQueryHandle_t handle, string pTagName );
+		private FAddRequiredTag _AddRequiredTag;
+		
+		#endregion
+		internal bool AddRequiredTag( UGCQueryHandle_t handle, string pTagName )
+		{
+			return _AddRequiredTag( Self, handle, pTagName );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FAddExcludedTag( IntPtr self, UGCQueryHandle_t handle, string pTagName );
+		private FAddExcludedTag _AddExcludedTag;
+		
+		#endregion
+		internal bool AddExcludedTag( UGCQueryHandle_t handle, string pTagName )
+		{
+			return _AddExcludedTag( Self, handle, pTagName );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnOnlyIDs( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnOnlyIDs );
+		private FSetReturnOnlyIDs _SetReturnOnlyIDs;
+		
+		#endregion
+		internal bool SetReturnOnlyIDs( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnOnlyIDs )
+		{
+			return _SetReturnOnlyIDs( Self, handle, bReturnOnlyIDs );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnKeyValueTags( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnKeyValueTags );
+		private FSetReturnKeyValueTags _SetReturnKeyValueTags;
+		
+		#endregion
+		internal bool SetReturnKeyValueTags( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnKeyValueTags )
+		{
+			return _SetReturnKeyValueTags( Self, handle, bReturnKeyValueTags );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnLongDescription( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnLongDescription );
+		private FSetReturnLongDescription _SetReturnLongDescription;
+		
+		#endregion
+		internal bool SetReturnLongDescription( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnLongDescription )
+		{
+			return _SetReturnLongDescription( Self, handle, bReturnLongDescription );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnMetadata( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnMetadata );
+		private FSetReturnMetadata _SetReturnMetadata;
+		
+		#endregion
+		internal bool SetReturnMetadata( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnMetadata )
+		{
+			return _SetReturnMetadata( Self, handle, bReturnMetadata );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnChildren( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnChildren );
+		private FSetReturnChildren _SetReturnChildren;
+		
+		#endregion
+		internal bool SetReturnChildren( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnChildren )
+		{
+			return _SetReturnChildren( Self, handle, bReturnChildren );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnAdditionalPreviews( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnAdditionalPreviews );
+		private FSetReturnAdditionalPreviews _SetReturnAdditionalPreviews;
+		
+		#endregion
+		internal bool SetReturnAdditionalPreviews( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnAdditionalPreviews )
+		{
+			return _SetReturnAdditionalPreviews( Self, handle, bReturnAdditionalPreviews );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnTotalOnly( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnTotalOnly );
+		private FSetReturnTotalOnly _SetReturnTotalOnly;
+		
+		#endregion
+		internal bool SetReturnTotalOnly( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bReturnTotalOnly )
+		{
+			return _SetReturnTotalOnly( Self, handle, bReturnTotalOnly );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetReturnPlaytimeStats( IntPtr self, UGCQueryHandle_t handle, uint unDays );
+		private FSetReturnPlaytimeStats _SetReturnPlaytimeStats;
+		
+		#endregion
+		internal bool SetReturnPlaytimeStats( UGCQueryHandle_t handle, uint unDays )
+		{
+			return _SetReturnPlaytimeStats( Self, handle, unDays );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetLanguage( IntPtr self, UGCQueryHandle_t handle, string pchLanguage );
+		private FSetLanguage _SetLanguage;
+		
+		#endregion
+		internal bool SetLanguage( UGCQueryHandle_t handle, string pchLanguage )
+		{
+			return _SetLanguage( Self, handle, pchLanguage );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetAllowCachedResponse( IntPtr self, UGCQueryHandle_t handle, uint unMaxAgeSeconds );
+		private FSetAllowCachedResponse _SetAllowCachedResponse;
+		
+		#endregion
+		internal bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint unMaxAgeSeconds )
+		{
+			return _SetAllowCachedResponse( Self, handle, unMaxAgeSeconds );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetCloudFileNameFilter( IntPtr self, UGCQueryHandle_t handle, string pMatchCloudFileName );
+		private FSetCloudFileNameFilter _SetCloudFileNameFilter;
+		
+		#endregion
+		internal bool SetCloudFileNameFilter( UGCQueryHandle_t handle, string pMatchCloudFileName )
+		{
+			return _SetCloudFileNameFilter( Self, handle, pMatchCloudFileName );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetMatchAnyTag( IntPtr self, UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bMatchAnyTag );
+		private FSetMatchAnyTag _SetMatchAnyTag;
+		
+		#endregion
+		internal bool SetMatchAnyTag( UGCQueryHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bMatchAnyTag )
+		{
+			return _SetMatchAnyTag( Self, handle, bMatchAnyTag );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetSearchText( IntPtr self, UGCQueryHandle_t handle, string pSearchText );
+		private FSetSearchText _SetSearchText;
+		
+		#endregion
+		internal bool SetSearchText( UGCQueryHandle_t handle, string pSearchText )
+		{
+			return _SetSearchText( Self, handle, pSearchText );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetRankedByTrendDays( IntPtr self, UGCQueryHandle_t handle, uint unDays );
+		private FSetRankedByTrendDays _SetRankedByTrendDays;
+		
+		#endregion
+		internal bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint unDays )
+		{
+			return _SetRankedByTrendDays( Self, handle, unDays );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FAddRequiredKeyValueTag( IntPtr self, UGCQueryHandle_t handle, string pKey, string pValue );
+		private FAddRequiredKeyValueTag _AddRequiredKeyValueTag;
+		
+		#endregion
+		internal bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, string pKey, string pValue )
+		{
+			return _AddRequiredKeyValueTag( Self, handle, pKey, pValue );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FRequestUGCDetails( IntPtr self, PublishedFileId nPublishedFileID, uint unMaxAgeSeconds );
+		private FRequestUGCDetails _RequestUGCDetails;
+		
+		#endregion
+		internal async Task<SteamUGCRequestUGCDetailsResult_t?> RequestUGCDetails( PublishedFileId nPublishedFileID, uint unMaxAgeSeconds )
+		{
+			return await (new Result<SteamUGCRequestUGCDetailsResult_t>( _RequestUGCDetails( Self, nPublishedFileID, unMaxAgeSeconds ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FCreateItem( IntPtr self, AppId nConsumerAppId, WorkshopFileType eFileType );
+		private FCreateItem _CreateItem;
+		
+		#endregion
+		internal async Task<CreateItemResult_t?> CreateItem( AppId nConsumerAppId, WorkshopFileType eFileType )
+		{
+			return await (new Result<CreateItemResult_t>( _CreateItem( Self, nConsumerAppId, eFileType ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate UGCUpdateHandle_t FStartItemUpdate( IntPtr self, AppId nConsumerAppId, PublishedFileId nPublishedFileID );
+		private FStartItemUpdate _StartItemUpdate;
+		
+		#endregion
+		internal UGCUpdateHandle_t StartItemUpdate( AppId nConsumerAppId, PublishedFileId nPublishedFileID )
+		{
+			return _StartItemUpdate( Self, nConsumerAppId, nPublishedFileID );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemTitle( IntPtr self, UGCUpdateHandle_t handle, string pchTitle );
+		private FSetItemTitle _SetItemTitle;
+		
+		#endregion
+		internal bool SetItemTitle( UGCUpdateHandle_t handle, string pchTitle )
+		{
+			return _SetItemTitle( Self, handle, pchTitle );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemDescription( IntPtr self, UGCUpdateHandle_t handle, string pchDescription );
+		private FSetItemDescription _SetItemDescription;
+		
+		#endregion
+		internal bool SetItemDescription( UGCUpdateHandle_t handle, string pchDescription )
+		{
+			return _SetItemDescription( Self, handle, pchDescription );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemUpdateLanguage( IntPtr self, UGCUpdateHandle_t handle, string pchLanguage );
+		private FSetItemUpdateLanguage _SetItemUpdateLanguage;
+		
+		#endregion
+		internal bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, string pchLanguage )
+		{
+			return _SetItemUpdateLanguage( Self, handle, pchLanguage );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemMetadata( IntPtr self, UGCUpdateHandle_t handle, string pchMetaData );
+		private FSetItemMetadata _SetItemMetadata;
+		
+		#endregion
+		internal bool SetItemMetadata( UGCUpdateHandle_t handle, string pchMetaData )
+		{
+			return _SetItemMetadata( Self, handle, pchMetaData );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemVisibility( IntPtr self, UGCUpdateHandle_t handle, RemoteStoragePublishedFileVisibility eVisibility );
+		private FSetItemVisibility _SetItemVisibility;
+		
+		#endregion
+		internal bool SetItemVisibility( UGCUpdateHandle_t handle, RemoteStoragePublishedFileVisibility eVisibility )
+		{
+			return _SetItemVisibility( Self, handle, eVisibility );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemTags( IntPtr self, UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags );
+		private FSetItemTags _SetItemTags;
+		
+		#endregion
+		internal bool SetItemTags( UGCUpdateHandle_t updateHandle, ref SteamParamStringArray_t pTags )
+		{
+			return _SetItemTags( Self, updateHandle, ref pTags );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemContent( IntPtr self, UGCUpdateHandle_t handle, string pszContentFolder );
+		private FSetItemContent _SetItemContent;
+		
+		#endregion
+		internal bool SetItemContent( UGCUpdateHandle_t handle, string pszContentFolder )
+		{
+			return _SetItemContent( Self, handle, pszContentFolder );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetItemPreview( IntPtr self, UGCUpdateHandle_t handle, string pszPreviewFile );
+		private FSetItemPreview _SetItemPreview;
+		
+		#endregion
+		internal bool SetItemPreview( UGCUpdateHandle_t handle, string pszPreviewFile )
+		{
+			return _SetItemPreview( Self, handle, pszPreviewFile );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FSetAllowLegacyUpload( IntPtr self, UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bAllowLegacyUpload );
+		private FSetAllowLegacyUpload _SetAllowLegacyUpload;
+		
+		#endregion
+		internal bool SetAllowLegacyUpload( UGCUpdateHandle_t handle, [MarshalAs( UnmanagedType.U1 )] bool bAllowLegacyUpload )
+		{
+			return _SetAllowLegacyUpload( Self, handle, bAllowLegacyUpload );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FRemoveItemKeyValueTags( IntPtr self, UGCUpdateHandle_t handle, string pchKey );
+		private FRemoveItemKeyValueTags _RemoveItemKeyValueTags;
+		
+		#endregion
+		internal bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, string pchKey )
+		{
+			return _RemoveItemKeyValueTags( Self, handle, pchKey );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FAddItemKeyValueTag( IntPtr self, UGCUpdateHandle_t handle, string pchKey, string pchValue );
+		private FAddItemKeyValueTag _AddItemKeyValueTag;
+		
+		#endregion
+		internal bool AddItemKeyValueTag( UGCUpdateHandle_t handle, string pchKey, string pchValue )
+		{
+			return _AddItemKeyValueTag( Self, handle, pchKey, pchValue );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FAddItemPreviewFile( IntPtr self, UGCUpdateHandle_t handle, string pszPreviewFile, ItemPreviewType type );
+		private FAddItemPreviewFile _AddItemPreviewFile;
+		
+		#endregion
+		internal bool AddItemPreviewFile( UGCUpdateHandle_t handle, string pszPreviewFile, ItemPreviewType type )
+		{
+			return _AddItemPreviewFile( Self, handle, pszPreviewFile, type );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FAddItemPreviewVideo( IntPtr self, UGCUpdateHandle_t handle, string pszVideoID );
+		private FAddItemPreviewVideo _AddItemPreviewVideo;
+		
+		#endregion
+		internal bool AddItemPreviewVideo( UGCUpdateHandle_t handle, string pszVideoID )
+		{
+			return _AddItemPreviewVideo( Self, handle, pszVideoID );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FUpdateItemPreviewFile( IntPtr self, UGCUpdateHandle_t handle, uint index, string pszPreviewFile );
+		private FUpdateItemPreviewFile _UpdateItemPreviewFile;
+		
+		#endregion
+		internal bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint index, string pszPreviewFile )
+		{
+			return _UpdateItemPreviewFile( Self, handle, index, pszPreviewFile );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FUpdateItemPreviewVideo( IntPtr self, UGCUpdateHandle_t handle, uint index, string pszVideoID );
+		private FUpdateItemPreviewVideo _UpdateItemPreviewVideo;
+		
+		#endregion
+		internal bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint index, string pszVideoID )
+		{
+			return _UpdateItemPreviewVideo( Self, handle, index, pszVideoID );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FRemoveItemPreview( IntPtr self, UGCUpdateHandle_t handle, uint index );
+		private FRemoveItemPreview _RemoveItemPreview;
+		
+		#endregion
+		internal bool RemoveItemPreview( UGCUpdateHandle_t handle, uint index )
+		{
+			return _RemoveItemPreview( Self, handle, index );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FSubmitItemUpdate( IntPtr self, UGCUpdateHandle_t handle, string pchChangeNote );
+		private FSubmitItemUpdate _SubmitItemUpdate;
+		
+		#endregion
+		internal async Task<SubmitItemUpdateResult_t?> SubmitItemUpdate( UGCUpdateHandle_t handle, string pchChangeNote )
+		{
+			return await (new Result<SubmitItemUpdateResult_t>( _SubmitItemUpdate( Self, handle, pchChangeNote ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate ItemUpdateStatus FGetItemUpdateProgress( IntPtr self, UGCUpdateHandle_t handle, ref ulong punBytesProcessed, ref ulong punBytesTotal );
+		private FGetItemUpdateProgress _GetItemUpdateProgress;
+		
+		#endregion
+		internal ItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, ref ulong punBytesProcessed, ref ulong punBytesTotal )
+		{
+			return _GetItemUpdateProgress( Self, handle, ref punBytesProcessed, ref punBytesTotal );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FSetUserItemVote( IntPtr self, PublishedFileId nPublishedFileID, [MarshalAs( UnmanagedType.U1 )] bool bVoteUp );
+		private FSetUserItemVote _SetUserItemVote;
+		
+		#endregion
+		internal async Task<SetUserItemVoteResult_t?> SetUserItemVote( PublishedFileId nPublishedFileID, [MarshalAs( UnmanagedType.U1 )] bool bVoteUp )
+		{
+			return await (new Result<SetUserItemVoteResult_t>( _SetUserItemVote( Self, nPublishedFileID, bVoteUp ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FGetUserItemVote( IntPtr self, PublishedFileId nPublishedFileID );
+		private FGetUserItemVote _GetUserItemVote;
+		
+		#endregion
+		internal async Task<GetUserItemVoteResult_t?> GetUserItemVote( PublishedFileId nPublishedFileID )
+		{
+			return await (new Result<GetUserItemVoteResult_t>( _GetUserItemVote( Self, nPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FAddItemToFavorites( IntPtr self, AppId nAppId, PublishedFileId nPublishedFileID );
+		private FAddItemToFavorites _AddItemToFavorites;
+		
+		#endregion
+		internal async Task<UserFavoriteItemsListChanged_t?> AddItemToFavorites( AppId nAppId, PublishedFileId nPublishedFileID )
+		{
+			return await (new Result<UserFavoriteItemsListChanged_t>( _AddItemToFavorites( Self, nAppId, nPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FRemoveItemFromFavorites( IntPtr self, AppId nAppId, PublishedFileId nPublishedFileID );
+		private FRemoveItemFromFavorites _RemoveItemFromFavorites;
+		
+		#endregion
+		internal async Task<UserFavoriteItemsListChanged_t?> RemoveItemFromFavorites( AppId nAppId, PublishedFileId nPublishedFileID )
+		{
+			return await (new Result<UserFavoriteItemsListChanged_t>( _RemoveItemFromFavorites( Self, nAppId, nPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FSubscribeItem( IntPtr self, PublishedFileId nPublishedFileID );
+		private FSubscribeItem _SubscribeItem;
+		
+		#endregion
+		internal async Task<RemoteStorageSubscribePublishedFileResult_t?> SubscribeItem( PublishedFileId nPublishedFileID )
+		{
+			return await (new Result<RemoteStorageSubscribePublishedFileResult_t>( _SubscribeItem( Self, nPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FUnsubscribeItem( IntPtr self, PublishedFileId nPublishedFileID );
+		private FUnsubscribeItem _UnsubscribeItem;
+		
+		#endregion
+		internal async Task<RemoteStorageUnsubscribePublishedFileResult_t?> UnsubscribeItem( PublishedFileId nPublishedFileID )
+		{
+			return await (new Result<RemoteStorageUnsubscribePublishedFileResult_t>( _UnsubscribeItem( Self, nPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate uint FGetNumSubscribedItems( IntPtr self );
+		private FGetNumSubscribedItems _GetNumSubscribedItems;
+		
+		#endregion
+		internal uint GetNumSubscribedItems()
+		{
+			return _GetNumSubscribedItems( Self );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate uint FGetSubscribedItems( IntPtr self, [In,Out] PublishedFileId[]  pvecPublishedFileID, uint cMaxEntries );
+		private FGetSubscribedItems _GetSubscribedItems;
+		
+		#endregion
+		internal uint GetSubscribedItems( [In,Out] PublishedFileId[]  pvecPublishedFileID, uint cMaxEntries )
+		{
+			return _GetSubscribedItems( Self, pvecPublishedFileID, cMaxEntries );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate uint FGetItemState( IntPtr self, PublishedFileId nPublishedFileID );
+		private FGetItemState _GetItemState;
+		
+		#endregion
+		internal uint GetItemState( PublishedFileId nPublishedFileID )
+		{
+			return _GetItemState( Self, nPublishedFileID );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetItemInstallInfo( IntPtr self, PublishedFileId nPublishedFileID, ref ulong punSizeOnDisk, StringBuilder pchFolder, uint cchFolderSize, ref uint punTimeStamp );
+		private FGetItemInstallInfo _GetItemInstallInfo;
+		
+		#endregion
+		internal bool GetItemInstallInfo( PublishedFileId nPublishedFileID, ref ulong punSizeOnDisk, StringBuilder pchFolder, uint cchFolderSize, ref uint punTimeStamp )
+		{
+			return _GetItemInstallInfo( Self, nPublishedFileID, ref punSizeOnDisk, pchFolder, cchFolderSize, ref punTimeStamp );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FGetItemDownloadInfo( IntPtr self, PublishedFileId nPublishedFileID, ref ulong punBytesDownloaded, ref ulong punBytesTotal );
+		private FGetItemDownloadInfo _GetItemDownloadInfo;
+		
+		#endregion
+		internal bool GetItemDownloadInfo( PublishedFileId nPublishedFileID, ref ulong punBytesDownloaded, ref ulong punBytesTotal )
+		{
+			return _GetItemDownloadInfo( Self, nPublishedFileID, ref punBytesDownloaded, ref punBytesTotal );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FDownloadItem( IntPtr self, PublishedFileId nPublishedFileID, [MarshalAs( UnmanagedType.U1 )] bool bHighPriority );
+		private FDownloadItem _DownloadItem;
+		
+		#endregion
+		internal bool DownloadItem( PublishedFileId nPublishedFileID, [MarshalAs( UnmanagedType.U1 )] bool bHighPriority )
+		{
+			return _DownloadItem( Self, nPublishedFileID, bHighPriority );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		[return: MarshalAs( UnmanagedType.I1 )]
+		private delegate bool FBInitWorkshopForGameServer( IntPtr self, DepotId_t unWorkshopDepotID, string pszFolder );
+		private FBInitWorkshopForGameServer _BInitWorkshopForGameServer;
+		
+		#endregion
+		internal bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, string pszFolder )
+		{
+			return _BInitWorkshopForGameServer( Self, unWorkshopDepotID, pszFolder );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate void FSuspendDownloads( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bSuspend );
+		private FSuspendDownloads _SuspendDownloads;
+		
+		#endregion
+		internal void SuspendDownloads( [MarshalAs( UnmanagedType.U1 )] bool bSuspend )
+		{
+			_SuspendDownloads( Self, bSuspend );
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FStartPlaytimeTracking( IntPtr self, [In,Out] PublishedFileId[]  pvecPublishedFileID, uint unNumPublishedFileIDs );
+		private FStartPlaytimeTracking _StartPlaytimeTracking;
+		
+		#endregion
+		internal async Task<StartPlaytimeTrackingResult_t?> StartPlaytimeTracking( [In,Out] PublishedFileId[]  pvecPublishedFileID, uint unNumPublishedFileIDs )
+		{
+			return await (new Result<StartPlaytimeTrackingResult_t>( _StartPlaytimeTracking( Self, pvecPublishedFileID, unNumPublishedFileIDs ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FStopPlaytimeTracking( IntPtr self, [In,Out] PublishedFileId[]  pvecPublishedFileID, uint unNumPublishedFileIDs );
+		private FStopPlaytimeTracking _StopPlaytimeTracking;
+		
+		#endregion
+		internal async Task<StopPlaytimeTrackingResult_t?> StopPlaytimeTracking( [In,Out] PublishedFileId[]  pvecPublishedFileID, uint unNumPublishedFileIDs )
+		{
+			return await (new Result<StopPlaytimeTrackingResult_t>( _StopPlaytimeTracking( Self, pvecPublishedFileID, unNumPublishedFileIDs ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FStopPlaytimeTrackingForAllItems( IntPtr self );
+		private FStopPlaytimeTrackingForAllItems _StopPlaytimeTrackingForAllItems;
+		
+		#endregion
+		internal async Task<StopPlaytimeTrackingResult_t?> StopPlaytimeTrackingForAllItems()
+		{
+			return await (new Result<StopPlaytimeTrackingResult_t>( _StopPlaytimeTrackingForAllItems( Self ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FAddDependency( IntPtr self, PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID );
+		private FAddDependency _AddDependency;
+		
+		#endregion
+		internal async Task<AddUGCDependencyResult_t?> AddDependency( PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID )
+		{
+			return await (new Result<AddUGCDependencyResult_t>( _AddDependency( Self, nParentPublishedFileID, nChildPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FRemoveDependency( IntPtr self, PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID );
+		private FRemoveDependency _RemoveDependency;
+		
+		#endregion
+		internal async Task<RemoveUGCDependencyResult_t?> RemoveDependency( PublishedFileId nParentPublishedFileID, PublishedFileId nChildPublishedFileID )
+		{
+			return await (new Result<RemoveUGCDependencyResult_t>( _RemoveDependency( Self, nParentPublishedFileID, nChildPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FAddAppDependency( IntPtr self, PublishedFileId nPublishedFileID, AppId nAppID );
+		private FAddAppDependency _AddAppDependency;
+		
+		#endregion
+		internal async Task<AddAppDependencyResult_t?> AddAppDependency( PublishedFileId nPublishedFileID, AppId nAppID )
+		{
+			return await (new Result<AddAppDependencyResult_t>( _AddAppDependency( Self, nPublishedFileID, nAppID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FRemoveAppDependency( IntPtr self, PublishedFileId nPublishedFileID, AppId nAppID );
+		private FRemoveAppDependency _RemoveAppDependency;
+		
+		#endregion
+		internal async Task<RemoveAppDependencyResult_t?> RemoveAppDependency( PublishedFileId nPublishedFileID, AppId nAppID )
+		{
+			return await (new Result<RemoveAppDependencyResult_t>( _RemoveAppDependency( Self, nPublishedFileID, nAppID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FGetAppDependencies( IntPtr self, PublishedFileId nPublishedFileID );
+		private FGetAppDependencies _GetAppDependencies;
+		
+		#endregion
+		internal async Task<GetAppDependenciesResult_t?> GetAppDependencies( PublishedFileId nPublishedFileID )
+		{
+			return await (new Result<GetAppDependenciesResult_t>( _GetAppDependencies( Self, nPublishedFileID ) )).GetResult();
+		}
+		
+		#region FunctionMeta
+		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
+		private delegate SteamAPICall_t FDeleteItem( IntPtr self, PublishedFileId nPublishedFileID );
+		private FDeleteItem _DeleteItem;
+		
+		#endregion
+		internal async Task<DeleteItemResult_t?> DeleteItem( PublishedFileId nPublishedFileID )
+		{
+			return await (new Result<DeleteItemResult_t>( _DeleteItem( Self, nPublishedFileID ) )).GetResult();
+		}
+		
+	}
+}

Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs

@@ -17,376 +17,376 @@ public ISteamUser( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			GetHSteamUserDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetHSteamUserDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_GetHSteamUser = Marshal.GetDelegateForFunctionPointer<FGetHSteamUser>( Marshal.ReadIntPtr( VTable, 0) );
-			BLoggedOnDelegatePointer = Marshal.GetDelegateForFunctionPointer<BLoggedOnDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_BLoggedOn = Marshal.GetDelegateForFunctionPointer<FBLoggedOn>( Marshal.ReadIntPtr( VTable, 8) );
-			GetSteamIDDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSteamIDDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_GetSteamID = Marshal.GetDelegateForFunctionPointer<FGetSteamID>( Marshal.ReadIntPtr( VTable, 16) );
-			InitiateGameConnectionDelegatePointer = Marshal.GetDelegateForFunctionPointer<InitiateGameConnectionDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_InitiateGameConnection = Marshal.GetDelegateForFunctionPointer<FInitiateGameConnection>( Marshal.ReadIntPtr( VTable, 24) );
-			TerminateGameConnectionDelegatePointer = Marshal.GetDelegateForFunctionPointer<TerminateGameConnectionDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_TerminateGameConnection = Marshal.GetDelegateForFunctionPointer<FTerminateGameConnection>( Marshal.ReadIntPtr( VTable, 32) );
-			TrackAppUsageEventDelegatePointer = Marshal.GetDelegateForFunctionPointer<TrackAppUsageEventDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_TrackAppUsageEvent = Marshal.GetDelegateForFunctionPointer<FTrackAppUsageEvent>( Marshal.ReadIntPtr( VTable, 40) );
-			GetUserDataFolderDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserDataFolderDelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_GetUserDataFolder = Marshal.GetDelegateForFunctionPointer<FGetUserDataFolder>( Marshal.ReadIntPtr( VTable, 48) );
-			StartVoiceRecordingDelegatePointer = Marshal.GetDelegateForFunctionPointer<StartVoiceRecordingDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_StartVoiceRecording = Marshal.GetDelegateForFunctionPointer<FStartVoiceRecording>( Marshal.ReadIntPtr( VTable, 56) );
-			StopVoiceRecordingDelegatePointer = Marshal.GetDelegateForFunctionPointer<StopVoiceRecordingDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_StopVoiceRecording = Marshal.GetDelegateForFunctionPointer<FStopVoiceRecording>( Marshal.ReadIntPtr( VTable, 64) );
-			GetAvailableVoiceDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAvailableVoiceDelegate>( Marshal.ReadIntPtr( VTable, 72) );
+			_GetAvailableVoice = Marshal.GetDelegateForFunctionPointer<FGetAvailableVoice>( Marshal.ReadIntPtr( VTable, 72) );
-			GetVoiceDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVoiceDelegate>( Marshal.ReadIntPtr( VTable, 80) );
+			_GetVoice = Marshal.GetDelegateForFunctionPointer<FGetVoice>( Marshal.ReadIntPtr( VTable, 80) );
-			DecompressVoiceDelegatePointer = Marshal.GetDelegateForFunctionPointer<DecompressVoiceDelegate>( Marshal.ReadIntPtr( VTable, 88) );
+			_DecompressVoice = Marshal.GetDelegateForFunctionPointer<FDecompressVoice>( Marshal.ReadIntPtr( VTable, 88) );
-			GetVoiceOptimalSampleRateDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVoiceOptimalSampleRateDelegate>( Marshal.ReadIntPtr( VTable, 96) );
+			_GetVoiceOptimalSampleRate = Marshal.GetDelegateForFunctionPointer<FGetVoiceOptimalSampleRate>( Marshal.ReadIntPtr( VTable, 96) );
-			GetAuthSessionTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAuthSessionTicketDelegate>( Marshal.ReadIntPtr( VTable, 104) );
+			_GetAuthSessionTicket = Marshal.GetDelegateForFunctionPointer<FGetAuthSessionTicket>( Marshal.ReadIntPtr( VTable, 104) );
-			BeginAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<BeginAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 112) );
+			_BeginAuthSession = Marshal.GetDelegateForFunctionPointer<FBeginAuthSession>( Marshal.ReadIntPtr( VTable, 112) );
-			EndAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<EndAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 120) );
+			_EndAuthSession = Marshal.GetDelegateForFunctionPointer<FEndAuthSession>( Marshal.ReadIntPtr( VTable, 120) );
-			CancelAuthTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelAuthTicketDelegate>( Marshal.ReadIntPtr( VTable, 128) );
+			_CancelAuthTicket = Marshal.GetDelegateForFunctionPointer<FCancelAuthTicket>( Marshal.ReadIntPtr( VTable, 128) );
-			UserHasLicenseForAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<UserHasLicenseForAppDelegate>( Marshal.ReadIntPtr( VTable, 136) );
+			_UserHasLicenseForApp = Marshal.GetDelegateForFunctionPointer<FUserHasLicenseForApp>( Marshal.ReadIntPtr( VTable, 136) );
-			BIsBehindNATDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsBehindNATDelegate>( Marshal.ReadIntPtr( VTable, 144) );
+			_BIsBehindNAT = Marshal.GetDelegateForFunctionPointer<FBIsBehindNAT>( Marshal.ReadIntPtr( VTable, 144) );
-			AdvertiseGameDelegatePointer = Marshal.GetDelegateForFunctionPointer<AdvertiseGameDelegate>( Marshal.ReadIntPtr( VTable, 152) );
+			_AdvertiseGame = Marshal.GetDelegateForFunctionPointer<FAdvertiseGame>( Marshal.ReadIntPtr( VTable, 152) );
-			RequestEncryptedAppTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestEncryptedAppTicketDelegate>( Marshal.ReadIntPtr( VTable, 160) );
+			_RequestEncryptedAppTicket = Marshal.GetDelegateForFunctionPointer<FRequestEncryptedAppTicket>( Marshal.ReadIntPtr( VTable, 160) );
-			GetEncryptedAppTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEncryptedAppTicketDelegate>( Marshal.ReadIntPtr( VTable, 168) );
+			_GetEncryptedAppTicket = Marshal.GetDelegateForFunctionPointer<FGetEncryptedAppTicket>( Marshal.ReadIntPtr( VTable, 168) );
-			GetGameBadgeLevelDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGameBadgeLevelDelegate>( Marshal.ReadIntPtr( VTable, 176) );
+			_GetGameBadgeLevel = Marshal.GetDelegateForFunctionPointer<FGetGameBadgeLevel>( Marshal.ReadIntPtr( VTable, 176) );
-			GetPlayerSteamLevelDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetPlayerSteamLevelDelegate>( Marshal.ReadIntPtr( VTable, 184) );
+			_GetPlayerSteamLevel = Marshal.GetDelegateForFunctionPointer<FGetPlayerSteamLevel>( Marshal.ReadIntPtr( VTable, 184) );
-			RequestStoreAuthURLDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestStoreAuthURLDelegate>( Marshal.ReadIntPtr( VTable, 192) );
+			_RequestStoreAuthURL = Marshal.GetDelegateForFunctionPointer<FRequestStoreAuthURL>( Marshal.ReadIntPtr( VTable, 192) );
-			BIsPhoneVerifiedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPhoneVerifiedDelegate>( Marshal.ReadIntPtr( VTable, 200) );
+			_BIsPhoneVerified = Marshal.GetDelegateForFunctionPointer<FBIsPhoneVerified>( Marshal.ReadIntPtr( VTable, 200) );
-			BIsTwoFactorEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsTwoFactorEnabledDelegate>( Marshal.ReadIntPtr( VTable, 208) );
+			_BIsTwoFactorEnabled = Marshal.GetDelegateForFunctionPointer<FBIsTwoFactorEnabled>( Marshal.ReadIntPtr( VTable, 208) );
-			BIsPhoneIdentifyingDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPhoneIdentifyingDelegate>( Marshal.ReadIntPtr( VTable, 216) );
+			_BIsPhoneIdentifying = Marshal.GetDelegateForFunctionPointer<FBIsPhoneIdentifying>( Marshal.ReadIntPtr( VTable, 216) );
-			BIsPhoneRequiringVerificationDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPhoneRequiringVerificationDelegate>( Marshal.ReadIntPtr( VTable, 224) );
+			_BIsPhoneRequiringVerification = Marshal.GetDelegateForFunctionPointer<FBIsPhoneRequiringVerification>( Marshal.ReadIntPtr( VTable, 224) );
-			GetMarketEligibilityDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetMarketEligibilityDelegate>( Marshal.ReadIntPtr( VTable, 232) );
+			_GetMarketEligibility = Marshal.GetDelegateForFunctionPointer<FGetMarketEligibility>( Marshal.ReadIntPtr( VTable, 232) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HSteamUser GetHSteamUserDelegate( IntPtr self );
+		private delegate HSteamUser FGetHSteamUser( IntPtr self );
-		private GetHSteamUserDelegate GetHSteamUserDelegatePointer;
+		private FGetHSteamUser _GetHSteamUser;
 		
 		#endregion
 		internal HSteamUser GetHSteamUser()
 		{
-			return GetHSteamUserDelegatePointer( Self );
+			return _GetHSteamUser( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BLoggedOnDelegate( IntPtr self );
+		private delegate bool FBLoggedOn( IntPtr self );
-		private BLoggedOnDelegate BLoggedOnDelegatePointer;
+		private FBLoggedOn _BLoggedOn;
 		
 		#endregion
 		internal bool BLoggedOn()
 		{
-			return BLoggedOnDelegatePointer( Self );
+			return _BLoggedOn( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void GetSteamIDDelegate( IntPtr self, ref SteamId retVal );
+		private delegate void FGetSteamID( IntPtr self, ref SteamId retVal );
-		private GetSteamIDDelegate GetSteamIDDelegatePointer;
+		private FGetSteamID _GetSteamID;
 		
 		#endregion
 		internal SteamId GetSteamID()
 		{
 			var retVal = default( SteamId );
-			GetSteamIDDelegatePointer( Self, ref retVal );
+			_GetSteamID( Self, ref retVal );
 			return retVal;
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int InitiateGameConnectionDelegate( IntPtr self, IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs( UnmanagedType.U1 )] bool bSecure );
+		private delegate int FInitiateGameConnection( IntPtr self, IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs( UnmanagedType.U1 )] bool bSecure );
-		private InitiateGameConnectionDelegate InitiateGameConnectionDelegatePointer;
+		private FInitiateGameConnection _InitiateGameConnection;
 		
 		#endregion
 		internal int InitiateGameConnection( IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs( UnmanagedType.U1 )] bool bSecure )
 		{
-			return InitiateGameConnectionDelegatePointer( Self, pAuthBlob, cbMaxAuthBlob, steamIDGameServer, unIPServer, usPortServer, bSecure );
+			return _InitiateGameConnection( Self, pAuthBlob, cbMaxAuthBlob, steamIDGameServer, unIPServer, usPortServer, bSecure );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void TerminateGameConnectionDelegate( IntPtr self, uint unIPServer, ushort usPortServer );
+		private delegate void FTerminateGameConnection( IntPtr self, uint unIPServer, ushort usPortServer );
-		private TerminateGameConnectionDelegate TerminateGameConnectionDelegatePointer;
+		private FTerminateGameConnection _TerminateGameConnection;
 		
 		#endregion
 		internal void TerminateGameConnection( uint unIPServer, ushort usPortServer )
 		{
-			TerminateGameConnectionDelegatePointer( Self, unIPServer, usPortServer );
+			_TerminateGameConnection( Self, unIPServer, usPortServer );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void TrackAppUsageEventDelegate( IntPtr self, GameId gameID, int eAppUsageEvent, string pchExtraInfo );
+		private delegate void FTrackAppUsageEvent( IntPtr self, GameId gameID, int eAppUsageEvent, string pchExtraInfo );
-		private TrackAppUsageEventDelegate TrackAppUsageEventDelegatePointer;
+		private FTrackAppUsageEvent _TrackAppUsageEvent;
 		
 		#endregion
 		internal void TrackAppUsageEvent( GameId gameID, int eAppUsageEvent, string pchExtraInfo )
 		{
-			TrackAppUsageEventDelegatePointer( Self, gameID, eAppUsageEvent, pchExtraInfo );
+			_TrackAppUsageEvent( Self, gameID, eAppUsageEvent, pchExtraInfo );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetUserDataFolderDelegate( IntPtr self, StringBuilder pchBuffer, int cubBuffer );
+		private delegate bool FGetUserDataFolder( IntPtr self, StringBuilder pchBuffer, int cubBuffer );
-		private GetUserDataFolderDelegate GetUserDataFolderDelegatePointer;
+		private FGetUserDataFolder _GetUserDataFolder;
 		
 		#endregion
 		internal bool GetUserDataFolder( StringBuilder pchBuffer, int cubBuffer )
 		{
-			return GetUserDataFolderDelegatePointer( Self, pchBuffer, cubBuffer );
+			return _GetUserDataFolder( Self, pchBuffer, cubBuffer );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void StartVoiceRecordingDelegate( IntPtr self );
+		private delegate void FStartVoiceRecording( IntPtr self );
-		private StartVoiceRecordingDelegate StartVoiceRecordingDelegatePointer;
+		private FStartVoiceRecording _StartVoiceRecording;
 		
 		#endregion
 		internal void StartVoiceRecording()
 		{
-			StartVoiceRecordingDelegatePointer( Self );
+			_StartVoiceRecording( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void StopVoiceRecordingDelegate( IntPtr self );
+		private delegate void FStopVoiceRecording( IntPtr self );
-		private StopVoiceRecordingDelegate StopVoiceRecordingDelegatePointer;
+		private FStopVoiceRecording _StopVoiceRecording;
 		
 		#endregion
 		internal void StopVoiceRecording()
 		{
-			StopVoiceRecordingDelegatePointer( Self );
+			_StopVoiceRecording( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate VoiceResult GetAvailableVoiceDelegate( IntPtr self, ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated );
+		private delegate VoiceResult FGetAvailableVoice( IntPtr self, ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated );
-		private GetAvailableVoiceDelegate GetAvailableVoiceDelegatePointer;
+		private FGetAvailableVoice _GetAvailableVoice;
 		
 		#endregion
 		internal VoiceResult GetAvailableVoice( ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated )
 		{
-			return GetAvailableVoiceDelegatePointer( Self, ref pcbCompressed, ref pcbUncompressed_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated );
+			return _GetAvailableVoice( Self, ref pcbCompressed, ref pcbUncompressed_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate VoiceResult GetVoiceDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs( UnmanagedType.U1 )] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated );
+		private delegate VoiceResult FGetVoice( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs( UnmanagedType.U1 )] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated );
-		private GetVoiceDelegate GetVoiceDelegatePointer;
+		private FGetVoice _GetVoice;
 		
 		#endregion
 		internal VoiceResult GetVoice( [MarshalAs( UnmanagedType.U1 )] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs( UnmanagedType.U1 )] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated )
 		{
-			return GetVoiceDelegatePointer( Self, bWantCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, bWantUncompressed_Deprecated, pUncompressedDestBuffer_Deprecated, cbUncompressedDestBufferSize_Deprecated, ref nUncompressBytesWritten_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated );
+			return _GetVoice( Self, bWantCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, bWantUncompressed_Deprecated, pUncompressedDestBuffer_Deprecated, cbUncompressedDestBufferSize_Deprecated, ref nUncompressBytesWritten_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate VoiceResult DecompressVoiceDelegate( IntPtr self, IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate );
+		private delegate VoiceResult FDecompressVoice( IntPtr self, IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate );
-		private DecompressVoiceDelegate DecompressVoiceDelegatePointer;
+		private FDecompressVoice _DecompressVoice;
 		
 		#endregion
 		internal VoiceResult DecompressVoice( IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate )
 		{
-			return DecompressVoiceDelegatePointer( Self, pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, nDesiredSampleRate );
+			return _DecompressVoice( Self, pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, nDesiredSampleRate );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetVoiceOptimalSampleRateDelegate( IntPtr self );
+		private delegate uint FGetVoiceOptimalSampleRate( IntPtr self );
-		private GetVoiceOptimalSampleRateDelegate GetVoiceOptimalSampleRateDelegatePointer;
+		private FGetVoiceOptimalSampleRate _GetVoiceOptimalSampleRate;
 		
 		#endregion
 		internal uint GetVoiceOptimalSampleRate()
 		{
-			return GetVoiceOptimalSampleRateDelegatePointer( Self );
+			return _GetVoiceOptimalSampleRate( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate HAuthTicket GetAuthSessionTicketDelegate( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
+		private delegate HAuthTicket FGetAuthSessionTicket( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
-		private GetAuthSessionTicketDelegate GetAuthSessionTicketDelegatePointer;
+		private FGetAuthSessionTicket _GetAuthSessionTicket;
 		
 		#endregion
 		internal HAuthTicket GetAuthSessionTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket )
 		{
-			return GetAuthSessionTicketDelegatePointer( Self, pTicket, cbMaxTicket, ref pcbTicket );
+			return _GetAuthSessionTicket( Self, pTicket, cbMaxTicket, ref pcbTicket );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate BeginAuthResult BeginAuthSessionDelegate( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID );
+		private delegate BeginAuthResult FBeginAuthSession( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID );
-		private BeginAuthSessionDelegate BeginAuthSessionDelegatePointer;
+		private FBeginAuthSession _BeginAuthSession;
 		
 		#endregion
 		internal BeginAuthResult BeginAuthSession( IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID )
 		{
-			return BeginAuthSessionDelegatePointer( Self, pAuthTicket, cbAuthTicket, steamID );
+			return _BeginAuthSession( Self, pAuthTicket, cbAuthTicket, steamID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void EndAuthSessionDelegate( IntPtr self, SteamId steamID );
+		private delegate void FEndAuthSession( IntPtr self, SteamId steamID );
-		private EndAuthSessionDelegate EndAuthSessionDelegatePointer;
+		private FEndAuthSession _EndAuthSession;
 		
 		#endregion
 		internal void EndAuthSession( SteamId steamID )
 		{
-			EndAuthSessionDelegatePointer( Self, steamID );
+			_EndAuthSession( Self, steamID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void CancelAuthTicketDelegate( IntPtr self, HAuthTicket hAuthTicket );
+		private delegate void FCancelAuthTicket( IntPtr self, HAuthTicket hAuthTicket );
-		private CancelAuthTicketDelegate CancelAuthTicketDelegatePointer;
+		private FCancelAuthTicket _CancelAuthTicket;
 		
 		#endregion
 		internal void CancelAuthTicket( HAuthTicket hAuthTicket )
 		{
-			CancelAuthTicketDelegatePointer( Self, hAuthTicket );
+			_CancelAuthTicket( Self, hAuthTicket );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate UserHasLicenseForAppResult UserHasLicenseForAppDelegate( IntPtr self, SteamId steamID, AppId_t appID );
+		private delegate UserHasLicenseForAppResult FUserHasLicenseForApp( IntPtr self, SteamId steamID, AppId appID );
-		private UserHasLicenseForAppDelegate UserHasLicenseForAppDelegatePointer;
+		private FUserHasLicenseForApp _UserHasLicenseForApp;
 		
 		#endregion
-		internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId_t appID )
+		internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId appID )
 		{
-			return UserHasLicenseForAppDelegatePointer( Self, steamID, appID );
+			return _UserHasLicenseForApp( Self, steamID, appID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsBehindNATDelegate( IntPtr self );
+		private delegate bool FBIsBehindNAT( IntPtr self );
-		private BIsBehindNATDelegate BIsBehindNATDelegatePointer;
+		private FBIsBehindNAT _BIsBehindNAT;
 		
 		#endregion
 		internal bool BIsBehindNAT()
 		{
-			return BIsBehindNATDelegatePointer( Self );
+			return _BIsBehindNAT( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void AdvertiseGameDelegate( IntPtr self, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer );
+		private delegate void FAdvertiseGame( IntPtr self, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer );
-		private AdvertiseGameDelegate AdvertiseGameDelegatePointer;
+		private FAdvertiseGame _AdvertiseGame;
 		
 		#endregion
 		internal void AdvertiseGame( SteamId steamIDGameServer, uint unIPServer, ushort usPortServer )
 		{
-			AdvertiseGameDelegatePointer( Self, steamIDGameServer, unIPServer, usPortServer );
+			_AdvertiseGame( Self, steamIDGameServer, unIPServer, usPortServer );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t RequestEncryptedAppTicketDelegate( IntPtr self, IntPtr pDataToInclude, int cbDataToInclude );
+		private delegate SteamAPICall_t FRequestEncryptedAppTicket( IntPtr self, IntPtr pDataToInclude, int cbDataToInclude );
-		private RequestEncryptedAppTicketDelegate RequestEncryptedAppTicketDelegatePointer;
+		private FRequestEncryptedAppTicket _RequestEncryptedAppTicket;
 		
 		#endregion
 		internal async Task<EncryptedAppTicketResponse_t?> RequestEncryptedAppTicket( IntPtr pDataToInclude, int cbDataToInclude )
 		{
-			return await (new Result<EncryptedAppTicketResponse_t>( RequestEncryptedAppTicketDelegatePointer( Self, pDataToInclude, cbDataToInclude ) )).GetResult();
+			return await (new Result<EncryptedAppTicketResponse_t>( _RequestEncryptedAppTicket( Self, pDataToInclude, cbDataToInclude ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetEncryptedAppTicketDelegate( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
+		private delegate bool FGetEncryptedAppTicket( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
-		private GetEncryptedAppTicketDelegate GetEncryptedAppTicketDelegatePointer;
+		private FGetEncryptedAppTicket _GetEncryptedAppTicket;
 		
 		#endregion
 		internal bool GetEncryptedAppTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket )
 		{
-			return GetEncryptedAppTicketDelegatePointer( Self, pTicket, cbMaxTicket, ref pcbTicket );
+			return _GetEncryptedAppTicket( Self, pTicket, cbMaxTicket, ref pcbTicket );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetGameBadgeLevelDelegate( IntPtr self, int nSeries, [MarshalAs( UnmanagedType.U1 )] bool bFoil );
+		private delegate int FGetGameBadgeLevel( IntPtr self, int nSeries, [MarshalAs( UnmanagedType.U1 )] bool bFoil );
-		private GetGameBadgeLevelDelegate GetGameBadgeLevelDelegatePointer;
+		private FGetGameBadgeLevel _GetGameBadgeLevel;
 		
 		#endregion
 		internal int GetGameBadgeLevel( int nSeries, [MarshalAs( UnmanagedType.U1 )] bool bFoil )
 		{
-			return GetGameBadgeLevelDelegatePointer( Self, nSeries, bFoil );
+			return _GetGameBadgeLevel( Self, nSeries, bFoil );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetPlayerSteamLevelDelegate( IntPtr self );
+		private delegate int FGetPlayerSteamLevel( IntPtr self );
-		private GetPlayerSteamLevelDelegate GetPlayerSteamLevelDelegatePointer;
+		private FGetPlayerSteamLevel _GetPlayerSteamLevel;
 		
 		#endregion
 		internal int GetPlayerSteamLevel()
 		{
-			return GetPlayerSteamLevelDelegatePointer( Self );
+			return _GetPlayerSteamLevel( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t RequestStoreAuthURLDelegate( IntPtr self, string pchRedirectURL );
+		private delegate SteamAPICall_t FRequestStoreAuthURL( IntPtr self, string pchRedirectURL );
-		private RequestStoreAuthURLDelegate RequestStoreAuthURLDelegatePointer;
+		private FRequestStoreAuthURL _RequestStoreAuthURL;
 		
 		#endregion
 		internal async Task<StoreAuthURLResponse_t?> RequestStoreAuthURL( string pchRedirectURL )
 		{
-			return await (new Result<StoreAuthURLResponse_t>( RequestStoreAuthURLDelegatePointer( Self, pchRedirectURL ) )).GetResult();
+			return await (new Result<StoreAuthURLResponse_t>( _RequestStoreAuthURL( Self, pchRedirectURL ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsPhoneVerifiedDelegate( IntPtr self );
+		private delegate bool FBIsPhoneVerified( IntPtr self );
-		private BIsPhoneVerifiedDelegate BIsPhoneVerifiedDelegatePointer;
+		private FBIsPhoneVerified _BIsPhoneVerified;
 		
 		#endregion
 		internal bool BIsPhoneVerified()
 		{
-			return BIsPhoneVerifiedDelegatePointer( Self );
+			return _BIsPhoneVerified( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsTwoFactorEnabledDelegate( IntPtr self );
+		private delegate bool FBIsTwoFactorEnabled( IntPtr self );
-		private BIsTwoFactorEnabledDelegate BIsTwoFactorEnabledDelegatePointer;
+		private FBIsTwoFactorEnabled _BIsTwoFactorEnabled;
 		
 		#endregion
 		internal bool BIsTwoFactorEnabled()
 		{
-			return BIsTwoFactorEnabledDelegatePointer( Self );
+			return _BIsTwoFactorEnabled( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsPhoneIdentifyingDelegate( IntPtr self );
+		private delegate bool FBIsPhoneIdentifying( IntPtr self );
-		private BIsPhoneIdentifyingDelegate BIsPhoneIdentifyingDelegatePointer;
+		private FBIsPhoneIdentifying _BIsPhoneIdentifying;
 		
 		#endregion
 		internal bool BIsPhoneIdentifying()
 		{
-			return BIsPhoneIdentifyingDelegatePointer( Self );
+			return _BIsPhoneIdentifying( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BIsPhoneRequiringVerificationDelegate( IntPtr self );
+		private delegate bool FBIsPhoneRequiringVerification( IntPtr self );
-		private BIsPhoneRequiringVerificationDelegate BIsPhoneRequiringVerificationDelegatePointer;
+		private FBIsPhoneRequiringVerification _BIsPhoneRequiringVerification;
 		
 		#endregion
 		internal bool BIsPhoneRequiringVerification()
 		{
-			return BIsPhoneRequiringVerificationDelegatePointer( Self );
+			return _BIsPhoneRequiringVerification( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t GetMarketEligibilityDelegate( IntPtr self );
+		private delegate SteamAPICall_t FGetMarketEligibility( IntPtr self );
-		private GetMarketEligibilityDelegate GetMarketEligibilityDelegatePointer;
+		private FGetMarketEligibility _GetMarketEligibility;
 		
 		#endregion
 		internal async Task<MarketEligibilityResponse_t?> GetMarketEligibility()
 		{
-			return await (new Result<MarketEligibilityResponse_t>( GetMarketEligibilityDelegatePointer( Self ) )).GetResult();
+			return await (new Result<MarketEligibilityResponse_t>( _GetMarketEligibility( Self ) )).GetResult();
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs

@@ -17,543 +17,543 @@ public ISteamUserStats( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			RequestCurrentStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestCurrentStatsDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_RequestCurrentStats = Marshal.GetDelegateForFunctionPointer<FRequestCurrentStats>( Marshal.ReadIntPtr( VTable, 0) );
-			GetStatDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetStatDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_GetStat1 = Marshal.GetDelegateForFunctionPointer<FGetStat1>( Marshal.ReadIntPtr( VTable, 16) );
-			GetStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetStat2Delegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_GetStat2 = Marshal.GetDelegateForFunctionPointer<FGetStat2>( Marshal.ReadIntPtr( VTable, 8) );
-			SetStatDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetStatDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_SetStat1 = Marshal.GetDelegateForFunctionPointer<FSetStat1>( Marshal.ReadIntPtr( VTable, 32) );
-			SetStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<SetStat2Delegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_SetStat2 = Marshal.GetDelegateForFunctionPointer<FSetStat2>( Marshal.ReadIntPtr( VTable, 24) );
-			UpdateAvgRateStatDelegatePointer = Marshal.GetDelegateForFunctionPointer<UpdateAvgRateStatDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_UpdateAvgRateStat = Marshal.GetDelegateForFunctionPointer<FUpdateAvgRateStat>( Marshal.ReadIntPtr( VTable, 40) );
-			GetAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementDelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_GetAchievement = Marshal.GetDelegateForFunctionPointer<FGetAchievement>( Marshal.ReadIntPtr( VTable, 48) );
-			SetAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetAchievementDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_SetAchievement = Marshal.GetDelegateForFunctionPointer<FSetAchievement>( Marshal.ReadIntPtr( VTable, 56) );
-			ClearAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<ClearAchievementDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_ClearAchievement = Marshal.GetDelegateForFunctionPointer<FClearAchievement>( Marshal.ReadIntPtr( VTable, 64) );
-			GetAchievementAndUnlockTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementAndUnlockTimeDelegate>( Marshal.ReadIntPtr( VTable, 72) );
+			_GetAchievementAndUnlockTime = Marshal.GetDelegateForFunctionPointer<FGetAchievementAndUnlockTime>( Marshal.ReadIntPtr( VTable, 72) );
-			StoreStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<StoreStatsDelegate>( Marshal.ReadIntPtr( VTable, 80) );
+			_StoreStats = Marshal.GetDelegateForFunctionPointer<FStoreStats>( Marshal.ReadIntPtr( VTable, 80) );
-			GetAchievementIconDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementIconDelegate>( Marshal.ReadIntPtr( VTable, 88) );
+			_GetAchievementIcon = Marshal.GetDelegateForFunctionPointer<FGetAchievementIcon>( Marshal.ReadIntPtr( VTable, 88) );
-			GetAchievementDisplayAttributeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementDisplayAttributeDelegate>( Marshal.ReadIntPtr( VTable, 96) );
+			_GetAchievementDisplayAttribute = Marshal.GetDelegateForFunctionPointer<FGetAchievementDisplayAttribute>( Marshal.ReadIntPtr( VTable, 96) );
-			IndicateAchievementProgressDelegatePointer = Marshal.GetDelegateForFunctionPointer<IndicateAchievementProgressDelegate>( Marshal.ReadIntPtr( VTable, 104) );
+			_IndicateAchievementProgress = Marshal.GetDelegateForFunctionPointer<FIndicateAchievementProgress>( Marshal.ReadIntPtr( VTable, 104) );
-			GetNumAchievementsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNumAchievementsDelegate>( Marshal.ReadIntPtr( VTable, 112) );
+			_GetNumAchievements = Marshal.GetDelegateForFunctionPointer<FGetNumAchievements>( Marshal.ReadIntPtr( VTable, 112) );
-			GetAchievementNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementNameDelegate>( Marshal.ReadIntPtr( VTable, 120) );
+			_GetAchievementName = Marshal.GetDelegateForFunctionPointer<FGetAchievementName>( Marshal.ReadIntPtr( VTable, 120) );
-			RequestUserStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestUserStatsDelegate>( Marshal.ReadIntPtr( VTable, 128) );
+			_RequestUserStats = Marshal.GetDelegateForFunctionPointer<FRequestUserStats>( Marshal.ReadIntPtr( VTable, 128) );
-			GetUserStatDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserStatDelegate>( Marshal.ReadIntPtr( VTable, 136) );
+			_GetUserStat1 = Marshal.GetDelegateForFunctionPointer<FGetUserStat1>( Marshal.ReadIntPtr( VTable, 144) );
-			GetUserStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserStat2Delegate>( Marshal.ReadIntPtr( VTable, 144) );
+			_GetUserStat2 = Marshal.GetDelegateForFunctionPointer<FGetUserStat2>( Marshal.ReadIntPtr( VTable, 136) );
-			GetUserAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserAchievementDelegate>( Marshal.ReadIntPtr( VTable, 152) );
+			_GetUserAchievement = Marshal.GetDelegateForFunctionPointer<FGetUserAchievement>( Marshal.ReadIntPtr( VTable, 152) );
-			GetUserAchievementAndUnlockTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserAchievementAndUnlockTimeDelegate>( Marshal.ReadIntPtr( VTable, 160) );
+			_GetUserAchievementAndUnlockTime = Marshal.GetDelegateForFunctionPointer<FGetUserAchievementAndUnlockTime>( Marshal.ReadIntPtr( VTable, 160) );
-			ResetAllStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<ResetAllStatsDelegate>( Marshal.ReadIntPtr( VTable, 168) );
+			_ResetAllStats = Marshal.GetDelegateForFunctionPointer<FResetAllStats>( Marshal.ReadIntPtr( VTable, 168) );
-			FindOrCreateLeaderboardDelegatePointer = Marshal.GetDelegateForFunctionPointer<FindOrCreateLeaderboardDelegate>( Marshal.ReadIntPtr( VTable, 176) );
+			_FindOrCreateLeaderboard = Marshal.GetDelegateForFunctionPointer<FFindOrCreateLeaderboard>( Marshal.ReadIntPtr( VTable, 176) );
-			FindLeaderboardDelegatePointer = Marshal.GetDelegateForFunctionPointer<FindLeaderboardDelegate>( Marshal.ReadIntPtr( VTable, 184) );
+			_FindLeaderboard = Marshal.GetDelegateForFunctionPointer<FFindLeaderboard>( Marshal.ReadIntPtr( VTable, 184) );
-			GetLeaderboardNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardNameDelegate>( Marshal.ReadIntPtr( VTable, 192) );
+			_GetLeaderboardName = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardName>( Marshal.ReadIntPtr( VTable, 192) );
-			GetLeaderboardEntryCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardEntryCountDelegate>( Marshal.ReadIntPtr( VTable, 200) );
+			_GetLeaderboardEntryCount = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardEntryCount>( Marshal.ReadIntPtr( VTable, 200) );
-			GetLeaderboardSortMethodDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardSortMethodDelegate>( Marshal.ReadIntPtr( VTable, 208) );
+			_GetLeaderboardSortMethod = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardSortMethod>( Marshal.ReadIntPtr( VTable, 208) );
-			GetLeaderboardDisplayTypeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardDisplayTypeDelegate>( Marshal.ReadIntPtr( VTable, 216) );
+			_GetLeaderboardDisplayType = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardDisplayType>( Marshal.ReadIntPtr( VTable, 216) );
-			DownloadLeaderboardEntriesDelegatePointer = Marshal.GetDelegateForFunctionPointer<DownloadLeaderboardEntriesDelegate>( Marshal.ReadIntPtr( VTable, 224) );
+			_DownloadLeaderboardEntries = Marshal.GetDelegateForFunctionPointer<FDownloadLeaderboardEntries>( Marshal.ReadIntPtr( VTable, 224) );
-			DownloadLeaderboardEntriesForUsersDelegatePointer = Marshal.GetDelegateForFunctionPointer<DownloadLeaderboardEntriesForUsersDelegate>( Marshal.ReadIntPtr( VTable, 232) );
+			_DownloadLeaderboardEntriesForUsers = Marshal.GetDelegateForFunctionPointer<FDownloadLeaderboardEntriesForUsers>( Marshal.ReadIntPtr( VTable, 232) );
-			GetDownloadedLeaderboardEntryDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetDownloadedLeaderboardEntryDelegate>( Marshal.ReadIntPtr( VTable, 240) );
+			_GetDownloadedLeaderboardEntry = Marshal.GetDelegateForFunctionPointer<FGetDownloadedLeaderboardEntry>( Marshal.ReadIntPtr( VTable, 240) );
-			UploadLeaderboardScoreDelegatePointer = Marshal.GetDelegateForFunctionPointer<UploadLeaderboardScoreDelegate>( Marshal.ReadIntPtr( VTable, 248) );
+			_UploadLeaderboardScore = Marshal.GetDelegateForFunctionPointer<FUploadLeaderboardScore>( Marshal.ReadIntPtr( VTable, 248) );
-			AttachLeaderboardUGCDelegatePointer = Marshal.GetDelegateForFunctionPointer<AttachLeaderboardUGCDelegate>( Marshal.ReadIntPtr( VTable, 256) );
+			_AttachLeaderboardUGC = Marshal.GetDelegateForFunctionPointer<FAttachLeaderboardUGC>( Marshal.ReadIntPtr( VTable, 256) );
-			GetNumberOfCurrentPlayersDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNumberOfCurrentPlayersDelegate>( Marshal.ReadIntPtr( VTable, 264) );
+			_GetNumberOfCurrentPlayers = Marshal.GetDelegateForFunctionPointer<FGetNumberOfCurrentPlayers>( Marshal.ReadIntPtr( VTable, 264) );
-			RequestGlobalAchievementPercentagesDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestGlobalAchievementPercentagesDelegate>( Marshal.ReadIntPtr( VTable, 272) );
+			_RequestGlobalAchievementPercentages = Marshal.GetDelegateForFunctionPointer<FRequestGlobalAchievementPercentages>( Marshal.ReadIntPtr( VTable, 272) );
-			GetMostAchievedAchievementInfoDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetMostAchievedAchievementInfoDelegate>( Marshal.ReadIntPtr( VTable, 280) );
+			_GetMostAchievedAchievementInfo = Marshal.GetDelegateForFunctionPointer<FGetMostAchievedAchievementInfo>( Marshal.ReadIntPtr( VTable, 280) );
-			GetNextMostAchievedAchievementInfoDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNextMostAchievedAchievementInfoDelegate>( Marshal.ReadIntPtr( VTable, 288) );
+			_GetNextMostAchievedAchievementInfo = Marshal.GetDelegateForFunctionPointer<FGetNextMostAchievedAchievementInfo>( Marshal.ReadIntPtr( VTable, 288) );
-			GetAchievementAchievedPercentDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementAchievedPercentDelegate>( Marshal.ReadIntPtr( VTable, 296) );
+			_GetAchievementAchievedPercent = Marshal.GetDelegateForFunctionPointer<FGetAchievementAchievedPercent>( Marshal.ReadIntPtr( VTable, 296) );
-			RequestGlobalStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestGlobalStatsDelegate>( Marshal.ReadIntPtr( VTable, 304) );
+			_RequestGlobalStats = Marshal.GetDelegateForFunctionPointer<FRequestGlobalStats>( Marshal.ReadIntPtr( VTable, 304) );
-			GetGlobalStatDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStatDelegate>( Marshal.ReadIntPtr( VTable, 312) );
+			_GetGlobalStat1 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStat1>( Marshal.ReadIntPtr( VTable, 320) );
-			GetGlobalStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStat2Delegate>( Marshal.ReadIntPtr( VTable, 320) );
+			_GetGlobalStat2 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStat2>( Marshal.ReadIntPtr( VTable, 312) );
-			GetGlobalStatHistoryDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStatHistoryDelegate>( Marshal.ReadIntPtr( VTable, 328) );
+			_GetGlobalStatHistory1 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStatHistory1>( Marshal.ReadIntPtr( VTable, 336) );
-			GetGlobalStatHistory2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStatHistory2Delegate>( Marshal.ReadIntPtr( VTable, 336) );
+			_GetGlobalStatHistory2 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStatHistory2>( Marshal.ReadIntPtr( VTable, 328) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool RequestCurrentStatsDelegate( IntPtr self );
+		private delegate bool FRequestCurrentStats( IntPtr self );
-		private RequestCurrentStatsDelegate RequestCurrentStatsDelegatePointer;
+		private FRequestCurrentStats _RequestCurrentStats;
 		
 		#endregion
 		internal bool RequestCurrentStats()
 		{
-			return RequestCurrentStatsDelegatePointer( Self );
+			return _RequestCurrentStats( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetStatDelegate( IntPtr self, string pchName, ref int pData );
+		private delegate bool FGetStat1( IntPtr self, string pchName, ref int pData );
-		private GetStatDelegate GetStatDelegatePointer;
+		private FGetStat1 _GetStat1;
 		
 		#endregion
-		internal bool GetStat( string pchName, ref int pData )
+		internal bool GetStat1( string pchName, ref int pData )
 		{
-			return GetStatDelegatePointer( Self, pchName, ref pData );
+			return _GetStat1( Self, pchName, ref pData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetStat2Delegate( IntPtr self, string pchName, ref float pData );
+		private delegate bool FGetStat2( IntPtr self, string pchName, ref float pData );
-		private GetStat2Delegate GetStat2DelegatePointer;
+		private FGetStat2 _GetStat2;
 		
 		#endregion
 		internal bool GetStat2( string pchName, ref float pData )
 		{
-			return GetStat2DelegatePointer( Self, pchName, ref pData );
+			return _GetStat2( Self, pchName, ref pData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool SetStatDelegate( IntPtr self, string pchName, int nData );
+		private delegate bool FSetStat1( IntPtr self, string pchName, int nData );
-		private SetStatDelegate SetStatDelegatePointer;
+		private FSetStat1 _SetStat1;
 		
 		#endregion
-		internal bool SetStat( string pchName, int nData )
+		internal bool SetStat1( string pchName, int nData )
 		{
-			return SetStatDelegatePointer( Self, pchName, nData );
+			return _SetStat1( Self, pchName, nData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool SetStat2Delegate( IntPtr self, string pchName, float fData );
+		private delegate bool FSetStat2( IntPtr self, string pchName, float fData );
-		private SetStat2Delegate SetStat2DelegatePointer;
+		private FSetStat2 _SetStat2;
 		
 		#endregion
 		internal bool SetStat2( string pchName, float fData )
 		{
-			return SetStat2DelegatePointer( Self, pchName, fData );
+			return _SetStat2( Self, pchName, fData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool UpdateAvgRateStatDelegate( IntPtr self, string pchName, float flCountThisSession, double dSessionLength );
+		private delegate bool FUpdateAvgRateStat( IntPtr self, string pchName, float flCountThisSession, double dSessionLength );
-		private UpdateAvgRateStatDelegate UpdateAvgRateStatDelegatePointer;
+		private FUpdateAvgRateStat _UpdateAvgRateStat;
 		
 		#endregion
 		internal bool UpdateAvgRateStat( string pchName, float flCountThisSession, double dSessionLength )
 		{
-			return UpdateAvgRateStatDelegatePointer( Self, pchName, flCountThisSession, dSessionLength );
+			return _UpdateAvgRateStat( Self, pchName, flCountThisSession, dSessionLength );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetAchievementDelegate( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
+		private delegate bool FGetAchievement( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
-		private GetAchievementDelegate GetAchievementDelegatePointer;
+		private FGetAchievement _GetAchievement;
 		
 		#endregion
 		internal bool GetAchievement( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
 		{
-			return GetAchievementDelegatePointer( Self, pchName, ref pbAchieved );
+			return _GetAchievement( Self, pchName, ref pbAchieved );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool SetAchievementDelegate( IntPtr self, string pchName );
+		private delegate bool FSetAchievement( IntPtr self, string pchName );
-		private SetAchievementDelegate SetAchievementDelegatePointer;
+		private FSetAchievement _SetAchievement;
 		
 		#endregion
 		internal bool SetAchievement( string pchName )
 		{
-			return SetAchievementDelegatePointer( Self, pchName );
+			return _SetAchievement( Self, pchName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool ClearAchievementDelegate( IntPtr self, string pchName );
+		private delegate bool FClearAchievement( IntPtr self, string pchName );
-		private ClearAchievementDelegate ClearAchievementDelegatePointer;
+		private FClearAchievement _ClearAchievement;
 		
 		#endregion
 		internal bool ClearAchievement( string pchName )
 		{
-			return ClearAchievementDelegatePointer( Self, pchName );
+			return _ClearAchievement( Self, pchName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetAchievementAndUnlockTimeDelegate( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
+		private delegate bool FGetAchievementAndUnlockTime( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
-		private GetAchievementAndUnlockTimeDelegate GetAchievementAndUnlockTimeDelegatePointer;
+		private FGetAchievementAndUnlockTime _GetAchievementAndUnlockTime;
 		
 		#endregion
 		internal bool GetAchievementAndUnlockTime( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
 		{
-			return GetAchievementAndUnlockTimeDelegatePointer( Self, pchName, ref pbAchieved, ref punUnlockTime );
+			return _GetAchievementAndUnlockTime( Self, pchName, ref pbAchieved, ref punUnlockTime );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool StoreStatsDelegate( IntPtr self );
+		private delegate bool FStoreStats( IntPtr self );
-		private StoreStatsDelegate StoreStatsDelegatePointer;
+		private FStoreStats _StoreStats;
 		
 		#endregion
 		internal bool StoreStats()
 		{
-			return StoreStatsDelegatePointer( Self );
+			return _StoreStats( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetAchievementIconDelegate( IntPtr self, string pchName );
+		private delegate int FGetAchievementIcon( IntPtr self, string pchName );
-		private GetAchievementIconDelegate GetAchievementIconDelegatePointer;
+		private FGetAchievementIcon _GetAchievementIcon;
 		
 		#endregion
 		internal int GetAchievementIcon( string pchName )
 		{
-			return GetAchievementIconDelegatePointer( Self, pchName );
+			return _GetAchievementIcon( Self, pchName );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetAchievementDisplayAttributeDelegate( IntPtr self, string pchName, string pchKey );
+		private delegate IntPtr FGetAchievementDisplayAttribute( IntPtr self, string pchName, string pchKey );
-		private GetAchievementDisplayAttributeDelegate GetAchievementDisplayAttributeDelegatePointer;
+		private FGetAchievementDisplayAttribute _GetAchievementDisplayAttribute;
 		
 		#endregion
 		internal string GetAchievementDisplayAttribute( string pchName, string pchKey )
 		{
-			return GetString( GetAchievementDisplayAttributeDelegatePointer( Self, pchName, pchKey ) );
+			return GetString( _GetAchievementDisplayAttribute( Self, pchName, pchKey ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IndicateAchievementProgressDelegate( IntPtr self, string pchName, uint nCurProgress, uint nMaxProgress );
+		private delegate bool FIndicateAchievementProgress( IntPtr self, string pchName, uint nCurProgress, uint nMaxProgress );
-		private IndicateAchievementProgressDelegate IndicateAchievementProgressDelegatePointer;
+		private FIndicateAchievementProgress _IndicateAchievementProgress;
 		
 		#endregion
 		internal bool IndicateAchievementProgress( string pchName, uint nCurProgress, uint nMaxProgress )
 		{
-			return IndicateAchievementProgressDelegatePointer( Self, pchName, nCurProgress, nMaxProgress );
+			return _IndicateAchievementProgress( Self, pchName, nCurProgress, nMaxProgress );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetNumAchievementsDelegate( IntPtr self );
+		private delegate uint FGetNumAchievements( IntPtr self );
-		private GetNumAchievementsDelegate GetNumAchievementsDelegatePointer;
+		private FGetNumAchievements _GetNumAchievements;
 		
 		#endregion
 		internal uint GetNumAchievements()
 		{
-			return GetNumAchievementsDelegatePointer( Self );
+			return _GetNumAchievements( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetAchievementNameDelegate( IntPtr self, uint iAchievement );
+		private delegate IntPtr FGetAchievementName( IntPtr self, uint iAchievement );
-		private GetAchievementNameDelegate GetAchievementNameDelegatePointer;
+		private FGetAchievementName _GetAchievementName;
 		
 		#endregion
 		internal string GetAchievementName( uint iAchievement )
 		{
-			return GetString( GetAchievementNameDelegatePointer( Self, iAchievement ) );
+			return GetString( _GetAchievementName( Self, iAchievement ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t RequestUserStatsDelegate( IntPtr self, SteamId steamIDUser );
+		private delegate SteamAPICall_t FRequestUserStats( IntPtr self, SteamId steamIDUser );
-		private RequestUserStatsDelegate RequestUserStatsDelegatePointer;
+		private FRequestUserStats _RequestUserStats;
 		
 		#endregion
 		internal async Task<UserStatsReceived_t?> RequestUserStats( SteamId steamIDUser )
 		{
-			return await (new Result<UserStatsReceived_t>( RequestUserStatsDelegatePointer( Self, steamIDUser ) )).GetResult();
+			return await (new Result<UserStatsReceived_t>( _RequestUserStats( Self, steamIDUser ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetUserStatDelegate( IntPtr self, SteamId steamIDUser, string pchName, ref int pData );
+		private delegate bool FGetUserStat1( IntPtr self, SteamId steamIDUser, string pchName, ref int pData );
-		private GetUserStatDelegate GetUserStatDelegatePointer;
+		private FGetUserStat1 _GetUserStat1;
 		
 		#endregion
-		internal bool GetUserStat( SteamId steamIDUser, string pchName, ref int pData )
+		internal bool GetUserStat1( SteamId steamIDUser, string pchName, ref int pData )
 		{
-			return GetUserStatDelegatePointer( Self, steamIDUser, pchName, ref pData );
+			return _GetUserStat1( Self, steamIDUser, pchName, ref pData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetUserStat2Delegate( IntPtr self, SteamId steamIDUser, string pchName, ref float pData );
+		private delegate bool FGetUserStat2( IntPtr self, SteamId steamIDUser, string pchName, ref float pData );
-		private GetUserStat2Delegate GetUserStat2DelegatePointer;
+		private FGetUserStat2 _GetUserStat2;
 		
 		#endregion
 		internal bool GetUserStat2( SteamId steamIDUser, string pchName, ref float pData )
 		{
-			return GetUserStat2DelegatePointer( Self, steamIDUser, pchName, ref pData );
+			return _GetUserStat2( Self, steamIDUser, pchName, ref pData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetUserAchievementDelegate( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
+		private delegate bool FGetUserAchievement( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
-		private GetUserAchievementDelegate GetUserAchievementDelegatePointer;
+		private FGetUserAchievement _GetUserAchievement;
 		
 		#endregion
 		internal bool GetUserAchievement( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
 		{
-			return GetUserAchievementDelegatePointer( Self, steamIDUser, pchName, ref pbAchieved );
+			return _GetUserAchievement( Self, steamIDUser, pchName, ref pbAchieved );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetUserAchievementAndUnlockTimeDelegate( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
+		private delegate bool FGetUserAchievementAndUnlockTime( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
-		private GetUserAchievementAndUnlockTimeDelegate GetUserAchievementAndUnlockTimeDelegatePointer;
+		private FGetUserAchievementAndUnlockTime _GetUserAchievementAndUnlockTime;
 		
 		#endregion
 		internal bool GetUserAchievementAndUnlockTime( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
 		{
-			return GetUserAchievementAndUnlockTimeDelegatePointer( Self, steamIDUser, pchName, ref pbAchieved, ref punUnlockTime );
+			return _GetUserAchievementAndUnlockTime( Self, steamIDUser, pchName, ref pbAchieved, ref punUnlockTime );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool ResetAllStatsDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bAchievementsToo );
+		private delegate bool FResetAllStats( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bAchievementsToo );
-		private ResetAllStatsDelegate ResetAllStatsDelegatePointer;
+		private FResetAllStats _ResetAllStats;
 		
 		#endregion
 		internal bool ResetAllStats( [MarshalAs( UnmanagedType.U1 )] bool bAchievementsToo )
 		{
-			return ResetAllStatsDelegatePointer( Self, bAchievementsToo );
+			return _ResetAllStats( Self, bAchievementsToo );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FindOrCreateLeaderboardDelegate( IntPtr self, string pchLeaderboardName, LeaderboardSortMethod eLeaderboardSortMethod, LeaderboardDisplayType eLeaderboardDisplayType );
+		private delegate SteamAPICall_t FFindOrCreateLeaderboard( IntPtr self, string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType );
-		private FindOrCreateLeaderboardDelegate FindOrCreateLeaderboardDelegatePointer;
+		private FFindOrCreateLeaderboard _FindOrCreateLeaderboard;
 		
 		#endregion
-		internal async Task<LeaderboardFindResult_t?> FindOrCreateLeaderboard( string pchLeaderboardName, LeaderboardSortMethod eLeaderboardSortMethod, LeaderboardDisplayType eLeaderboardDisplayType )
+		internal async Task<LeaderboardFindResult_t?> FindOrCreateLeaderboard( string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType )
 		{
-			return await (new Result<LeaderboardFindResult_t>( FindOrCreateLeaderboardDelegatePointer( Self, pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) )).GetResult();
+			return await (new Result<LeaderboardFindResult_t>( _FindOrCreateLeaderboard( Self, pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t FindLeaderboardDelegate( IntPtr self, string pchLeaderboardName );
+		private delegate SteamAPICall_t FFindLeaderboard( IntPtr self, string pchLeaderboardName );
-		private FindLeaderboardDelegate FindLeaderboardDelegatePointer;
+		private FFindLeaderboard _FindLeaderboard;
 		
 		#endregion
 		internal async Task<LeaderboardFindResult_t?> FindLeaderboard( string pchLeaderboardName )
 		{
-			return await (new Result<LeaderboardFindResult_t>( FindLeaderboardDelegatePointer( Self, pchLeaderboardName ) )).GetResult();
+			return await (new Result<LeaderboardFindResult_t>( _FindLeaderboard( Self, pchLeaderboardName ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetLeaderboardNameDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
+		private delegate IntPtr FGetLeaderboardName( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
-		private GetLeaderboardNameDelegate GetLeaderboardNameDelegatePointer;
+		private FGetLeaderboardName _GetLeaderboardName;
 		
 		#endregion
 		internal string GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard )
 		{
-			return GetString( GetLeaderboardNameDelegatePointer( Self, hSteamLeaderboard ) );
+			return GetString( _GetLeaderboardName( Self, hSteamLeaderboard ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetLeaderboardEntryCountDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
+		private delegate int FGetLeaderboardEntryCount( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
-		private GetLeaderboardEntryCountDelegate GetLeaderboardEntryCountDelegatePointer;
+		private FGetLeaderboardEntryCount _GetLeaderboardEntryCount;
 		
 		#endregion
 		internal int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard )
 		{
-			return GetLeaderboardEntryCountDelegatePointer( Self, hSteamLeaderboard );
+			return _GetLeaderboardEntryCount( Self, hSteamLeaderboard );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate LeaderboardSortMethod GetLeaderboardSortMethodDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
+		private delegate LeaderboardSort FGetLeaderboardSortMethod( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
-		private GetLeaderboardSortMethodDelegate GetLeaderboardSortMethodDelegatePointer;
+		private FGetLeaderboardSortMethod _GetLeaderboardSortMethod;
 		
 		#endregion
-		internal LeaderboardSortMethod GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard )
+		internal LeaderboardSort GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard )
 		{
-			return GetLeaderboardSortMethodDelegatePointer( Self, hSteamLeaderboard );
+			return _GetLeaderboardSortMethod( Self, hSteamLeaderboard );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate LeaderboardDisplayType GetLeaderboardDisplayTypeDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
+		private delegate LeaderboardDisplay FGetLeaderboardDisplayType( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
-		private GetLeaderboardDisplayTypeDelegate GetLeaderboardDisplayTypeDelegatePointer;
+		private FGetLeaderboardDisplayType _GetLeaderboardDisplayType;
 		
 		#endregion
-		internal LeaderboardDisplayType GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard )
+		internal LeaderboardDisplay GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard )
 		{
-			return GetLeaderboardDisplayTypeDelegatePointer( Self, hSteamLeaderboard );
+			return _GetLeaderboardDisplayType( Self, hSteamLeaderboard );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t DownloadLeaderboardEntriesDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd );
+		private delegate SteamAPICall_t FDownloadLeaderboardEntries( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd );
-		private DownloadLeaderboardEntriesDelegate DownloadLeaderboardEntriesDelegatePointer;
+		private FDownloadLeaderboardEntries _DownloadLeaderboardEntries;
 		
 		#endregion
 		internal async Task<LeaderboardScoresDownloaded_t?> DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd )
 		{
-			return await (new Result<LeaderboardScoresDownloaded_t>( DownloadLeaderboardEntriesDelegatePointer( Self, hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd ) )).GetResult();
+			return await (new Result<LeaderboardScoresDownloaded_t>( _DownloadLeaderboardEntries( Self, hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t DownloadLeaderboardEntriesForUsersDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, [In,Out] SteamId[]  prgUsers, int cUsers );
+		private delegate SteamAPICall_t FDownloadLeaderboardEntriesForUsers( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, [In,Out] SteamId[]  prgUsers, int cUsers );
-		private DownloadLeaderboardEntriesForUsersDelegate DownloadLeaderboardEntriesForUsersDelegatePointer;
+		private FDownloadLeaderboardEntriesForUsers _DownloadLeaderboardEntriesForUsers;
 		
 		#endregion
 		internal async Task<LeaderboardScoresDownloaded_t?> DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, [In,Out] SteamId[]  prgUsers, int cUsers )
 		{
-			return await (new Result<LeaderboardScoresDownloaded_t>( DownloadLeaderboardEntriesForUsersDelegatePointer( Self, hSteamLeaderboard, prgUsers, cUsers ) )).GetResult();
+			return await (new Result<LeaderboardScoresDownloaded_t>( _DownloadLeaderboardEntriesForUsers( Self, hSteamLeaderboard, prgUsers, cUsers ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetDownloadedLeaderboardEntryDelegate( IntPtr self, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, ref int pDetails, int cDetailsMax );
+		private delegate bool FGetDownloadedLeaderboardEntry( IntPtr self, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In,Out] int[]  pDetails, int cDetailsMax );
-		private GetDownloadedLeaderboardEntryDelegate GetDownloadedLeaderboardEntryDelegatePointer;
+		private FGetDownloadedLeaderboardEntry _GetDownloadedLeaderboardEntry;
 		
 		#endregion
-		internal bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, ref int pDetails, int cDetailsMax )
+		internal bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In,Out] int[]  pDetails, int cDetailsMax )
 		{
-			return GetDownloadedLeaderboardEntryDelegatePointer( Self, hSteamLeaderboardEntries, index, ref pLeaderboardEntry, ref pDetails, cDetailsMax );
+			return _GetDownloadedLeaderboardEntry( Self, hSteamLeaderboardEntries, index, ref pLeaderboardEntry, pDetails, cDetailsMax );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t UploadLeaderboardScoreDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In,Out] int[]  pScoreDetails, int cScoreDetailsCount );
+		private delegate SteamAPICall_t FUploadLeaderboardScore( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In,Out] int[]  pScoreDetails, int cScoreDetailsCount );
-		private UploadLeaderboardScoreDelegate UploadLeaderboardScoreDelegatePointer;
+		private FUploadLeaderboardScore _UploadLeaderboardScore;
 		
 		#endregion
 		internal async Task<LeaderboardScoreUploaded_t?> UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In,Out] int[]  pScoreDetails, int cScoreDetailsCount )
 		{
-			return await (new Result<LeaderboardScoreUploaded_t>( UploadLeaderboardScoreDelegatePointer( Self, hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount ) )).GetResult();
+			return await (new Result<LeaderboardScoreUploaded_t>( _UploadLeaderboardScore( Self, hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t AttachLeaderboardUGCDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC );
+		private delegate SteamAPICall_t FAttachLeaderboardUGC( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC );
-		private AttachLeaderboardUGCDelegate AttachLeaderboardUGCDelegatePointer;
+		private FAttachLeaderboardUGC _AttachLeaderboardUGC;
 		
 		#endregion
 		internal async Task<LeaderboardUGCSet_t?> AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC )
 		{
-			return await (new Result<LeaderboardUGCSet_t>( AttachLeaderboardUGCDelegatePointer( Self, hSteamLeaderboard, hUGC ) )).GetResult();
+			return await (new Result<LeaderboardUGCSet_t>( _AttachLeaderboardUGC( Self, hSteamLeaderboard, hUGC ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t GetNumberOfCurrentPlayersDelegate( IntPtr self );
+		private delegate SteamAPICall_t FGetNumberOfCurrentPlayers( IntPtr self );
-		private GetNumberOfCurrentPlayersDelegate GetNumberOfCurrentPlayersDelegatePointer;
+		private FGetNumberOfCurrentPlayers _GetNumberOfCurrentPlayers;
 		
 		#endregion
 		internal async Task<NumberOfCurrentPlayers_t?> GetNumberOfCurrentPlayers()
 		{
-			return await (new Result<NumberOfCurrentPlayers_t>( GetNumberOfCurrentPlayersDelegatePointer( Self ) )).GetResult();
+			return await (new Result<NumberOfCurrentPlayers_t>( _GetNumberOfCurrentPlayers( Self ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t RequestGlobalAchievementPercentagesDelegate( IntPtr self );
+		private delegate SteamAPICall_t FRequestGlobalAchievementPercentages( IntPtr self );
-		private RequestGlobalAchievementPercentagesDelegate RequestGlobalAchievementPercentagesDelegatePointer;
+		private FRequestGlobalAchievementPercentages _RequestGlobalAchievementPercentages;
 		
 		#endregion
 		internal async Task<GlobalAchievementPercentagesReady_t?> RequestGlobalAchievementPercentages()
 		{
-			return await (new Result<GlobalAchievementPercentagesReady_t>( RequestGlobalAchievementPercentagesDelegatePointer( Self ) )).GetResult();
+			return await (new Result<GlobalAchievementPercentagesReady_t>( _RequestGlobalAchievementPercentages( Self ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetMostAchievedAchievementInfoDelegate( IntPtr self, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
+		private delegate int FGetMostAchievedAchievementInfo( IntPtr self, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
-		private GetMostAchievedAchievementInfoDelegate GetMostAchievedAchievementInfoDelegatePointer;
+		private FGetMostAchievedAchievementInfo _GetMostAchievedAchievementInfo;
 		
 		#endregion
 		internal int GetMostAchievedAchievementInfo( StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
 		{
-			return GetMostAchievedAchievementInfoDelegatePointer( Self, pchName, unNameBufLen, ref pflPercent, ref pbAchieved );
+			return _GetMostAchievedAchievementInfo( Self, pchName, unNameBufLen, ref pflPercent, ref pbAchieved );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetNextMostAchievedAchievementInfoDelegate( IntPtr self, int iIteratorPrevious, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
+		private delegate int FGetNextMostAchievedAchievementInfo( IntPtr self, int iIteratorPrevious, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
-		private GetNextMostAchievedAchievementInfoDelegate GetNextMostAchievedAchievementInfoDelegatePointer;
+		private FGetNextMostAchievedAchievementInfo _GetNextMostAchievedAchievementInfo;
 		
 		#endregion
 		internal int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
 		{
-			return GetNextMostAchievedAchievementInfoDelegatePointer( Self, iIteratorPrevious, pchName, unNameBufLen, ref pflPercent, ref pbAchieved );
+			return _GetNextMostAchievedAchievementInfo( Self, iIteratorPrevious, pchName, unNameBufLen, ref pflPercent, ref pbAchieved );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetAchievementAchievedPercentDelegate( IntPtr self, string pchName, ref float pflPercent );
+		private delegate bool FGetAchievementAchievedPercent( IntPtr self, string pchName, ref float pflPercent );
-		private GetAchievementAchievedPercentDelegate GetAchievementAchievedPercentDelegatePointer;
+		private FGetAchievementAchievedPercent _GetAchievementAchievedPercent;
 		
 		#endregion
 		internal bool GetAchievementAchievedPercent( string pchName, ref float pflPercent )
 		{
-			return GetAchievementAchievedPercentDelegatePointer( Self, pchName, ref pflPercent );
+			return _GetAchievementAchievedPercent( Self, pchName, ref pflPercent );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t RequestGlobalStatsDelegate( IntPtr self, int nHistoryDays );
+		private delegate SteamAPICall_t FRequestGlobalStats( IntPtr self, int nHistoryDays );
-		private RequestGlobalStatsDelegate RequestGlobalStatsDelegatePointer;
+		private FRequestGlobalStats _RequestGlobalStats;
 		
 		#endregion
 		internal async Task<GlobalStatsReceived_t?> RequestGlobalStats( int nHistoryDays )
 		{
-			return await (new Result<GlobalStatsReceived_t>( RequestGlobalStatsDelegatePointer( Self, nHistoryDays ) )).GetResult();
+			return await (new Result<GlobalStatsReceived_t>( _RequestGlobalStats( Self, nHistoryDays ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetGlobalStatDelegate( IntPtr self, string pchStatName, ref long pData );
+		private delegate bool FGetGlobalStat1( IntPtr self, string pchStatName, ref long pData );
-		private GetGlobalStatDelegate GetGlobalStatDelegatePointer;
+		private FGetGlobalStat1 _GetGlobalStat1;
 		
 		#endregion
-		internal bool GetGlobalStat( string pchStatName, ref long pData )
+		internal bool GetGlobalStat1( string pchStatName, ref long pData )
 		{
-			return GetGlobalStatDelegatePointer( Self, pchStatName, ref pData );
+			return _GetGlobalStat1( Self, pchStatName, ref pData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetGlobalStat2Delegate( IntPtr self, string pchStatName, ref double pData );
+		private delegate bool FGetGlobalStat2( IntPtr self, string pchStatName, ref double pData );
-		private GetGlobalStat2Delegate GetGlobalStat2DelegatePointer;
+		private FGetGlobalStat2 _GetGlobalStat2;
 		
 		#endregion
 		internal bool GetGlobalStat2( string pchStatName, ref double pData )
 		{
-			return GetGlobalStat2DelegatePointer( Self, pchStatName, ref pData );
+			return _GetGlobalStat2( Self, pchStatName, ref pData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetGlobalStatHistoryDelegate( IntPtr self, string pchStatName, ref long pData, uint cubData );
+		private delegate int FGetGlobalStatHistory1( IntPtr self, string pchStatName, [In,Out] long[]  pData, uint cubData );
-		private GetGlobalStatHistoryDelegate GetGlobalStatHistoryDelegatePointer;
+		private FGetGlobalStatHistory1 _GetGlobalStatHistory1;
 		
 		#endregion
-		internal int GetGlobalStatHistory( string pchStatName, ref long pData, uint cubData )
+		internal int GetGlobalStatHistory1( string pchStatName, [In,Out] long[]  pData, uint cubData )
 		{
-			return GetGlobalStatHistoryDelegatePointer( Self, pchStatName, ref pData, cubData );
+			return _GetGlobalStatHistory1( Self, pchStatName, pData, cubData );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate int GetGlobalStatHistory2Delegate( IntPtr self, string pchStatName, ref double pData, uint cubData );
+		private delegate int FGetGlobalStatHistory2( IntPtr self, string pchStatName, [In,Out] double[]  pData, uint cubData );
-		private GetGlobalStatHistory2Delegate GetGlobalStatHistory2DelegatePointer;
+		private FGetGlobalStatHistory2 _GetGlobalStatHistory2;
 		
 		#endregion
-		internal int GetGlobalStatHistory2( string pchStatName, ref double pData, uint cubData )
+		internal int GetGlobalStatHistory2( string pchStatName, [In,Out] double[]  pData, uint cubData )
 		{
-			return GetGlobalStatHistory2DelegatePointer( Self, pchStatName, ref pData, cubData );
+			return _GetGlobalStatHistory2( Self, pchStatName, pData, cubData );
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs

@@ -17,378 +17,378 @@ public ISteamUtils( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			GetSecondsSinceAppActiveDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSecondsSinceAppActiveDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_GetSecondsSinceAppActive = Marshal.GetDelegateForFunctionPointer<FGetSecondsSinceAppActive>( Marshal.ReadIntPtr( VTable, 0) );
-			GetSecondsSinceComputerActiveDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSecondsSinceComputerActiveDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_GetSecondsSinceComputerActive = Marshal.GetDelegateForFunctionPointer<FGetSecondsSinceComputerActive>( Marshal.ReadIntPtr( VTable, 8) );
-			GetConnectedUniverseDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetConnectedUniverseDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_GetConnectedUniverse = Marshal.GetDelegateForFunctionPointer<FGetConnectedUniverse>( Marshal.ReadIntPtr( VTable, 16) );
-			GetServerRealTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerRealTimeDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_GetServerRealTime = Marshal.GetDelegateForFunctionPointer<FGetServerRealTime>( Marshal.ReadIntPtr( VTable, 24) );
-			GetIPCountryDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetIPCountryDelegate>( Marshal.ReadIntPtr( VTable, 32) );
+			_GetIPCountry = Marshal.GetDelegateForFunctionPointer<FGetIPCountry>( Marshal.ReadIntPtr( VTable, 32) );
-			GetImageSizeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetImageSizeDelegate>( Marshal.ReadIntPtr( VTable, 40) );
+			_GetImageSize = Marshal.GetDelegateForFunctionPointer<FGetImageSize>( Marshal.ReadIntPtr( VTable, 40) );
-			GetImageRGBADelegatePointer = Marshal.GetDelegateForFunctionPointer<GetImageRGBADelegate>( Marshal.ReadIntPtr( VTable, 48) );
+			_GetImageRGBA = Marshal.GetDelegateForFunctionPointer<FGetImageRGBA>( Marshal.ReadIntPtr( VTable, 48) );
-			GetCSERIPPortDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCSERIPPortDelegate>( Marshal.ReadIntPtr( VTable, 56) );
+			_GetCSERIPPort = Marshal.GetDelegateForFunctionPointer<FGetCSERIPPort>( Marshal.ReadIntPtr( VTable, 56) );
-			GetCurrentBatteryPowerDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCurrentBatteryPowerDelegate>( Marshal.ReadIntPtr( VTable, 64) );
+			_GetCurrentBatteryPower = Marshal.GetDelegateForFunctionPointer<FGetCurrentBatteryPower>( Marshal.ReadIntPtr( VTable, 64) );
-			GetAppIDDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppIDDelegate>( Marshal.ReadIntPtr( VTable, 72) );
+			_GetAppID = Marshal.GetDelegateForFunctionPointer<FGetAppID>( Marshal.ReadIntPtr( VTable, 72) );
-			SetOverlayNotificationPositionDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetOverlayNotificationPositionDelegate>( Marshal.ReadIntPtr( VTable, 80) );
+			_SetOverlayNotificationPosition = Marshal.GetDelegateForFunctionPointer<FSetOverlayNotificationPosition>( Marshal.ReadIntPtr( VTable, 80) );
-			IsAPICallCompletedDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsAPICallCompletedDelegate>( Marshal.ReadIntPtr( VTable, 88) );
+			_IsAPICallCompleted = Marshal.GetDelegateForFunctionPointer<FIsAPICallCompleted>( Marshal.ReadIntPtr( VTable, 88) );
-			GetAPICallFailureReasonDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAPICallFailureReasonDelegate>( Marshal.ReadIntPtr( VTable, 96) );
+			_GetAPICallFailureReason = Marshal.GetDelegateForFunctionPointer<FGetAPICallFailureReason>( Marshal.ReadIntPtr( VTable, 96) );
-			GetAPICallResultDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAPICallResultDelegate>( Marshal.ReadIntPtr( VTable, 104) );
+			_GetAPICallResult = Marshal.GetDelegateForFunctionPointer<FGetAPICallResult>( Marshal.ReadIntPtr( VTable, 104) );
-			RunFrameDelegatePointer = Marshal.GetDelegateForFunctionPointer<RunFrameDelegate>( Marshal.ReadIntPtr( VTable, 112) );
+			_RunFrame = Marshal.GetDelegateForFunctionPointer<FRunFrame>( Marshal.ReadIntPtr( VTable, 112) );
-			GetIPCCallCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetIPCCallCountDelegate>( Marshal.ReadIntPtr( VTable, 120) );
+			_GetIPCCallCount = Marshal.GetDelegateForFunctionPointer<FGetIPCCallCount>( Marshal.ReadIntPtr( VTable, 120) );
-			SetWarningMessageHookDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetWarningMessageHookDelegate>( Marshal.ReadIntPtr( VTable, 128) );
+			_SetWarningMessageHook = Marshal.GetDelegateForFunctionPointer<FSetWarningMessageHook>( Marshal.ReadIntPtr( VTable, 128) );
-			IsOverlayEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsOverlayEnabledDelegate>( Marshal.ReadIntPtr( VTable, 136) );
+			_IsOverlayEnabled = Marshal.GetDelegateForFunctionPointer<FIsOverlayEnabled>( Marshal.ReadIntPtr( VTable, 136) );
-			BOverlayNeedsPresentDelegatePointer = Marshal.GetDelegateForFunctionPointer<BOverlayNeedsPresentDelegate>( Marshal.ReadIntPtr( VTable, 144) );
+			_BOverlayNeedsPresent = Marshal.GetDelegateForFunctionPointer<FBOverlayNeedsPresent>( Marshal.ReadIntPtr( VTable, 144) );
-			CheckFileSignatureDelegatePointer = Marshal.GetDelegateForFunctionPointer<CheckFileSignatureDelegate>( Marshal.ReadIntPtr( VTable, 152) );
+			_CheckFileSignature = Marshal.GetDelegateForFunctionPointer<FCheckFileSignature>( Marshal.ReadIntPtr( VTable, 152) );
-			ShowGamepadTextInputDelegatePointer = Marshal.GetDelegateForFunctionPointer<ShowGamepadTextInputDelegate>( Marshal.ReadIntPtr( VTable, 160) );
+			_ShowGamepadTextInput = Marshal.GetDelegateForFunctionPointer<FShowGamepadTextInput>( Marshal.ReadIntPtr( VTable, 160) );
-			GetEnteredGamepadTextLengthDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEnteredGamepadTextLengthDelegate>( Marshal.ReadIntPtr( VTable, 168) );
+			_GetEnteredGamepadTextLength = Marshal.GetDelegateForFunctionPointer<FGetEnteredGamepadTextLength>( Marshal.ReadIntPtr( VTable, 168) );
-			GetEnteredGamepadTextInputDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEnteredGamepadTextInputDelegate>( Marshal.ReadIntPtr( VTable, 176) );
+			_GetEnteredGamepadTextInput = Marshal.GetDelegateForFunctionPointer<FGetEnteredGamepadTextInput>( Marshal.ReadIntPtr( VTable, 176) );
-			GetSteamUILanguageDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSteamUILanguageDelegate>( Marshal.ReadIntPtr( VTable, 184) );
+			_GetSteamUILanguage = Marshal.GetDelegateForFunctionPointer<FGetSteamUILanguage>( Marshal.ReadIntPtr( VTable, 184) );
-			IsSteamRunningInVRDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsSteamRunningInVRDelegate>( Marshal.ReadIntPtr( VTable, 192) );
+			_IsSteamRunningInVR = Marshal.GetDelegateForFunctionPointer<FIsSteamRunningInVR>( Marshal.ReadIntPtr( VTable, 192) );
-			SetOverlayNotificationInsetDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetOverlayNotificationInsetDelegate>( Marshal.ReadIntPtr( VTable, 200) );
+			_SetOverlayNotificationInset = Marshal.GetDelegateForFunctionPointer<FSetOverlayNotificationInset>( Marshal.ReadIntPtr( VTable, 200) );
-			IsSteamInBigPictureModeDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsSteamInBigPictureModeDelegate>( Marshal.ReadIntPtr( VTable, 208) );
+			_IsSteamInBigPictureMode = Marshal.GetDelegateForFunctionPointer<FIsSteamInBigPictureMode>( Marshal.ReadIntPtr( VTable, 208) );
-			StartVRDashboardDelegatePointer = Marshal.GetDelegateForFunctionPointer<StartVRDashboardDelegate>( Marshal.ReadIntPtr( VTable, 216) );
+			_StartVRDashboard = Marshal.GetDelegateForFunctionPointer<FStartVRDashboard>( Marshal.ReadIntPtr( VTable, 216) );
-			IsVRHeadsetStreamingEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsVRHeadsetStreamingEnabledDelegate>( Marshal.ReadIntPtr( VTable, 224) );
+			_IsVRHeadsetStreamingEnabled = Marshal.GetDelegateForFunctionPointer<FIsVRHeadsetStreamingEnabled>( Marshal.ReadIntPtr( VTable, 224) );
-			SetVRHeadsetStreamingEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetVRHeadsetStreamingEnabledDelegate>( Marshal.ReadIntPtr( VTable, 232) );
+			_SetVRHeadsetStreamingEnabled = Marshal.GetDelegateForFunctionPointer<FSetVRHeadsetStreamingEnabled>( Marshal.ReadIntPtr( VTable, 232) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetSecondsSinceAppActiveDelegate( IntPtr self );
+		private delegate uint FGetSecondsSinceAppActive( IntPtr self );
-		private GetSecondsSinceAppActiveDelegate GetSecondsSinceAppActiveDelegatePointer;
+		private FGetSecondsSinceAppActive _GetSecondsSinceAppActive;
 		
 		#endregion
 		internal uint GetSecondsSinceAppActive()
 		{
-			return GetSecondsSinceAppActiveDelegatePointer( Self );
+			return _GetSecondsSinceAppActive( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetSecondsSinceComputerActiveDelegate( IntPtr self );
+		private delegate uint FGetSecondsSinceComputerActive( IntPtr self );
-		private GetSecondsSinceComputerActiveDelegate GetSecondsSinceComputerActiveDelegatePointer;
+		private FGetSecondsSinceComputerActive _GetSecondsSinceComputerActive;
 		
 		#endregion
 		internal uint GetSecondsSinceComputerActive()
 		{
-			return GetSecondsSinceComputerActiveDelegatePointer( Self );
+			return _GetSecondsSinceComputerActive( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate Universe GetConnectedUniverseDelegate( IntPtr self );
+		private delegate Universe FGetConnectedUniverse( IntPtr self );
-		private GetConnectedUniverseDelegate GetConnectedUniverseDelegatePointer;
+		private FGetConnectedUniverse _GetConnectedUniverse;
 		
 		#endregion
 		internal Universe GetConnectedUniverse()
 		{
-			return GetConnectedUniverseDelegatePointer( Self );
+			return _GetConnectedUniverse( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetServerRealTimeDelegate( IntPtr self );
+		private delegate uint FGetServerRealTime( IntPtr self );
-		private GetServerRealTimeDelegate GetServerRealTimeDelegatePointer;
+		private FGetServerRealTime _GetServerRealTime;
 		
 		#endregion
 		internal uint GetServerRealTime()
 		{
-			return GetServerRealTimeDelegatePointer( Self );
+			return _GetServerRealTime( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetIPCountryDelegate( IntPtr self );
+		private delegate IntPtr FGetIPCountry( IntPtr self );
-		private GetIPCountryDelegate GetIPCountryDelegatePointer;
+		private FGetIPCountry _GetIPCountry;
 		
 		#endregion
 		internal string GetIPCountry()
 		{
-			return GetString( GetIPCountryDelegatePointer( Self ) );
+			return GetString( _GetIPCountry( Self ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetImageSizeDelegate( IntPtr self, int iImage, ref uint pnWidth, ref uint pnHeight );
+		private delegate bool FGetImageSize( IntPtr self, int iImage, ref uint pnWidth, ref uint pnHeight );
-		private GetImageSizeDelegate GetImageSizeDelegatePointer;
+		private FGetImageSize _GetImageSize;
 		
 		#endregion
 		internal bool GetImageSize( int iImage, ref uint pnWidth, ref uint pnHeight )
 		{
-			return GetImageSizeDelegatePointer( Self, iImage, ref pnWidth, ref pnHeight );
+			return _GetImageSize( Self, iImage, ref pnWidth, ref pnHeight );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetImageRGBADelegate( IntPtr self, int iImage, [In,Out] byte[]  pubDest, int nDestBufferSize );
+		private delegate bool FGetImageRGBA( IntPtr self, int iImage, [In,Out] byte[]  pubDest, int nDestBufferSize );
-		private GetImageRGBADelegate GetImageRGBADelegatePointer;
+		private FGetImageRGBA _GetImageRGBA;
 		
 		#endregion
 		internal bool GetImageRGBA( int iImage, [In,Out] byte[]  pubDest, int nDestBufferSize )
 		{
-			return GetImageRGBADelegatePointer( Self, iImage, pubDest, nDestBufferSize );
+			return _GetImageRGBA( Self, iImage, pubDest, nDestBufferSize );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetCSERIPPortDelegate( IntPtr self, ref uint unIP, ref ushort usPort );
+		private delegate bool FGetCSERIPPort( IntPtr self, ref uint unIP, ref ushort usPort );
-		private GetCSERIPPortDelegate GetCSERIPPortDelegatePointer;
+		private FGetCSERIPPort _GetCSERIPPort;
 		
 		#endregion
 		internal bool GetCSERIPPort( ref uint unIP, ref ushort usPort )
 		{
-			return GetCSERIPPortDelegatePointer( Self, ref unIP, ref usPort );
+			return _GetCSERIPPort( Self, ref unIP, ref usPort );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate byte GetCurrentBatteryPowerDelegate( IntPtr self );
+		private delegate byte FGetCurrentBatteryPower( IntPtr self );
-		private GetCurrentBatteryPowerDelegate GetCurrentBatteryPowerDelegatePointer;
+		private FGetCurrentBatteryPower _GetCurrentBatteryPower;
 		
 		#endregion
 		internal byte GetCurrentBatteryPower()
 		{
-			return GetCurrentBatteryPowerDelegatePointer( Self );
+			return _GetCurrentBatteryPower( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetAppIDDelegate( IntPtr self );
+		private delegate uint FGetAppID( IntPtr self );
-		private GetAppIDDelegate GetAppIDDelegatePointer;
+		private FGetAppID _GetAppID;
 		
 		#endregion
 		internal uint GetAppID()
 		{
-			return GetAppIDDelegatePointer( Self );
+			return _GetAppID( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetOverlayNotificationPositionDelegate( IntPtr self, NotificationPosition eNotificationPosition );
+		private delegate void FSetOverlayNotificationPosition( IntPtr self, NotificationPosition eNotificationPosition );
-		private SetOverlayNotificationPositionDelegate SetOverlayNotificationPositionDelegatePointer;
+		private FSetOverlayNotificationPosition _SetOverlayNotificationPosition;
 		
 		#endregion
 		internal void SetOverlayNotificationPosition( NotificationPosition eNotificationPosition )
 		{
-			SetOverlayNotificationPositionDelegatePointer( Self, eNotificationPosition );
+			_SetOverlayNotificationPosition( Self, eNotificationPosition );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsAPICallCompletedDelegate( IntPtr self, SteamAPICall_t hSteamAPICall, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed );
+		private delegate bool FIsAPICallCompleted( IntPtr self, SteamAPICall_t hSteamAPICall, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed );
-		private IsAPICallCompletedDelegate IsAPICallCompletedDelegatePointer;
+		private FIsAPICallCompleted _IsAPICallCompleted;
 		
 		#endregion
 		internal bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed )
 		{
-			return IsAPICallCompletedDelegatePointer( Self, hSteamAPICall, ref pbFailed );
+			return _IsAPICallCompleted( Self, hSteamAPICall, ref pbFailed );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICallFailure GetAPICallFailureReasonDelegate( IntPtr self, SteamAPICall_t hSteamAPICall );
+		private delegate SteamAPICallFailure FGetAPICallFailureReason( IntPtr self, SteamAPICall_t hSteamAPICall );
-		private GetAPICallFailureReasonDelegate GetAPICallFailureReasonDelegatePointer;
+		private FGetAPICallFailureReason _GetAPICallFailureReason;
 		
 		#endregion
 		internal SteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall )
 		{
-			return GetAPICallFailureReasonDelegatePointer( Self, hSteamAPICall );
+			return _GetAPICallFailureReason( Self, hSteamAPICall );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetAPICallResultDelegate( IntPtr self, SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed );
+		private delegate bool FGetAPICallResult( IntPtr self, SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed );
-		private GetAPICallResultDelegate GetAPICallResultDelegatePointer;
+		private FGetAPICallResult _GetAPICallResult;
 		
 		#endregion
 		internal bool GetAPICallResult( SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed )
 		{
-			return GetAPICallResultDelegatePointer( Self, hSteamAPICall, pCallback, cubCallback, iCallbackExpected, ref pbFailed );
+			return _GetAPICallResult( Self, hSteamAPICall, pCallback, cubCallback, iCallbackExpected, ref pbFailed );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void RunFrameDelegate( IntPtr self );
+		private delegate void FRunFrame( IntPtr self );
-		private RunFrameDelegate RunFrameDelegatePointer;
+		private FRunFrame _RunFrame;
 		
 		#endregion
 		internal void RunFrame()
 		{
-			RunFrameDelegatePointer( Self );
+			_RunFrame( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetIPCCallCountDelegate( IntPtr self );
+		private delegate uint FGetIPCCallCount( IntPtr self );
-		private GetIPCCallCountDelegate GetIPCCallCountDelegatePointer;
+		private FGetIPCCallCount _GetIPCCallCount;
 		
 		#endregion
 		internal uint GetIPCCallCount()
 		{
-			return GetIPCCallCountDelegatePointer( Self );
+			return _GetIPCCallCount( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetWarningMessageHookDelegate( IntPtr self, IntPtr pFunction );
+		private delegate void FSetWarningMessageHook( IntPtr self, IntPtr pFunction );
-		private SetWarningMessageHookDelegate SetWarningMessageHookDelegatePointer;
+		private FSetWarningMessageHook _SetWarningMessageHook;
 		
 		#endregion
 		internal void SetWarningMessageHook( IntPtr pFunction )
 		{
-			SetWarningMessageHookDelegatePointer( Self, pFunction );
+			_SetWarningMessageHook( Self, pFunction );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsOverlayEnabledDelegate( IntPtr self );
+		private delegate bool FIsOverlayEnabled( IntPtr self );
-		private IsOverlayEnabledDelegate IsOverlayEnabledDelegatePointer;
+		private FIsOverlayEnabled _IsOverlayEnabled;
 		
 		#endregion
 		internal bool IsOverlayEnabled()
 		{
-			return IsOverlayEnabledDelegatePointer( Self );
+			return _IsOverlayEnabled( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool BOverlayNeedsPresentDelegate( IntPtr self );
+		private delegate bool FBOverlayNeedsPresent( IntPtr self );
-		private BOverlayNeedsPresentDelegate BOverlayNeedsPresentDelegatePointer;
+		private FBOverlayNeedsPresent _BOverlayNeedsPresent;
 		
 		#endregion
 		internal bool BOverlayNeedsPresent()
 		{
-			return BOverlayNeedsPresentDelegatePointer( Self );
+			return _BOverlayNeedsPresent( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate SteamAPICall_t CheckFileSignatureDelegate( IntPtr self, string szFileName );
+		private delegate SteamAPICall_t FCheckFileSignature( IntPtr self, string szFileName );
-		private CheckFileSignatureDelegate CheckFileSignatureDelegatePointer;
+		private FCheckFileSignature _CheckFileSignature;
 		
 		#endregion
 		internal async Task<CheckFileSignature_t?> CheckFileSignature( string szFileName )
 		{
-			return await (new Result<CheckFileSignature_t>( CheckFileSignatureDelegatePointer( Self, szFileName ) )).GetResult();
+			return await (new Result<CheckFileSignature_t>( _CheckFileSignature( Self, szFileName ) )).GetResult();
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool ShowGamepadTextInputDelegate( IntPtr self, GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText );
+		private delegate bool FShowGamepadTextInput( IntPtr self, GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText );
-		private ShowGamepadTextInputDelegate ShowGamepadTextInputDelegatePointer;
+		private FShowGamepadTextInput _ShowGamepadTextInput;
 		
 		#endregion
 		internal bool ShowGamepadTextInput( GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText )
 		{
-			return ShowGamepadTextInputDelegatePointer( Self, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText );
+			return _ShowGamepadTextInput( Self, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate uint GetEnteredGamepadTextLengthDelegate( IntPtr self );
+		private delegate uint FGetEnteredGamepadTextLength( IntPtr self );
-		private GetEnteredGamepadTextLengthDelegate GetEnteredGamepadTextLengthDelegatePointer;
+		private FGetEnteredGamepadTextLength _GetEnteredGamepadTextLength;
 		
 		#endregion
 		internal uint GetEnteredGamepadTextLength()
 		{
-			return GetEnteredGamepadTextLengthDelegatePointer( Self );
+			return _GetEnteredGamepadTextLength( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetEnteredGamepadTextInputDelegate( IntPtr self, StringBuilder pchText, uint cchText );
+		private delegate bool FGetEnteredGamepadTextInput( IntPtr self, StringBuilder pchText, uint cchText );
-		private GetEnteredGamepadTextInputDelegate GetEnteredGamepadTextInputDelegatePointer;
+		private FGetEnteredGamepadTextInput _GetEnteredGamepadTextInput;
 		
 		#endregion
 		internal bool GetEnteredGamepadTextInput( StringBuilder pchText, uint cchText )
 		{
-			return GetEnteredGamepadTextInputDelegatePointer( Self, pchText, cchText );
+			return _GetEnteredGamepadTextInput( Self, pchText, cchText );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate IntPtr GetSteamUILanguageDelegate( IntPtr self );
+		private delegate IntPtr FGetSteamUILanguage( IntPtr self );
-		private GetSteamUILanguageDelegate GetSteamUILanguageDelegatePointer;
+		private FGetSteamUILanguage _GetSteamUILanguage;
 		
 		#endregion
 		internal string GetSteamUILanguage()
 		{
-			return GetString( GetSteamUILanguageDelegatePointer( Self ) );
+			return GetString( _GetSteamUILanguage( Self ) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsSteamRunningInVRDelegate( IntPtr self );
+		private delegate bool FIsSteamRunningInVR( IntPtr self );
-		private IsSteamRunningInVRDelegate IsSteamRunningInVRDelegatePointer;
+		private FIsSteamRunningInVR _IsSteamRunningInVR;
 		
 		#endregion
 		internal bool IsSteamRunningInVR()
 		{
-			return IsSteamRunningInVRDelegatePointer( Self );
+			return _IsSteamRunningInVR( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetOverlayNotificationInsetDelegate( IntPtr self, int nHorizontalInset, int nVerticalInset );
+		private delegate void FSetOverlayNotificationInset( IntPtr self, int nHorizontalInset, int nVerticalInset );
-		private SetOverlayNotificationInsetDelegate SetOverlayNotificationInsetDelegatePointer;
+		private FSetOverlayNotificationInset _SetOverlayNotificationInset;
 		
 		#endregion
 		internal void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset )
 		{
-			SetOverlayNotificationInsetDelegatePointer( Self, nHorizontalInset, nVerticalInset );
+			_SetOverlayNotificationInset( Self, nHorizontalInset, nVerticalInset );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsSteamInBigPictureModeDelegate( IntPtr self );
+		private delegate bool FIsSteamInBigPictureMode( IntPtr self );
-		private IsSteamInBigPictureModeDelegate IsSteamInBigPictureModeDelegatePointer;
+		private FIsSteamInBigPictureMode _IsSteamInBigPictureMode;
 		
 		#endregion
 		internal bool IsSteamInBigPictureMode()
 		{
-			return IsSteamInBigPictureModeDelegatePointer( Self );
+			return _IsSteamInBigPictureMode( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void StartVRDashboardDelegate( IntPtr self );
+		private delegate void FStartVRDashboard( IntPtr self );
-		private StartVRDashboardDelegate StartVRDashboardDelegatePointer;
+		private FStartVRDashboard _StartVRDashboard;
 		
 		#endregion
 		internal void StartVRDashboard()
 		{
-			StartVRDashboardDelegatePointer( Self );
+			_StartVRDashboard( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsVRHeadsetStreamingEnabledDelegate( IntPtr self );
+		private delegate bool FIsVRHeadsetStreamingEnabled( IntPtr self );
-		private IsVRHeadsetStreamingEnabledDelegate IsVRHeadsetStreamingEnabledDelegatePointer;
+		private FIsVRHeadsetStreamingEnabled _IsVRHeadsetStreamingEnabled;
 		
 		#endregion
 		internal bool IsVRHeadsetStreamingEnabled()
 		{
-			return IsVRHeadsetStreamingEnabledDelegatePointer( Self );
+			return _IsVRHeadsetStreamingEnabled( Self );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void SetVRHeadsetStreamingEnabledDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bEnabled );
+		private delegate void FSetVRHeadsetStreamingEnabled( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bEnabled );
-		private SetVRHeadsetStreamingEnabledDelegate SetVRHeadsetStreamingEnabledDelegatePointer;
+		private FSetVRHeadsetStreamingEnabled _SetVRHeadsetStreamingEnabled;
 		
 		#endregion
 		internal void SetVRHeadsetStreamingEnabled( [MarshalAs( UnmanagedType.U1 )] bool bEnabled )
 		{
-			SetVRHeadsetStreamingEnabledDelegatePointer( Self, bEnabled );
+			_SetVRHeadsetStreamingEnabled( Self, bEnabled );
 		}
 		
 	}

Facepunch.Steamworks/Generated/Interfaces/ISteamVideo.cs

@@ -17,56 +17,56 @@ public ISteamVideo( bool server = false ) : base( server )
 		
 		public override void InitInternals()
 		{
-			GetVideoURLDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVideoURLDelegate>( Marshal.ReadIntPtr( VTable, 0) );
+			_GetVideoURL = Marshal.GetDelegateForFunctionPointer<FGetVideoURL>( Marshal.ReadIntPtr( VTable, 0) );
-			IsBroadcastingDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsBroadcastingDelegate>( Marshal.ReadIntPtr( VTable, 8) );
+			_IsBroadcasting = Marshal.GetDelegateForFunctionPointer<FIsBroadcasting>( Marshal.ReadIntPtr( VTable, 8) );
-			GetOPFSettingsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetOPFSettingsDelegate>( Marshal.ReadIntPtr( VTable, 16) );
+			_GetOPFSettings = Marshal.GetDelegateForFunctionPointer<FGetOPFSettings>( Marshal.ReadIntPtr( VTable, 16) );
-			GetOPFStringForAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetOPFStringForAppDelegate>( Marshal.ReadIntPtr( VTable, 24) );
+			_GetOPFStringForApp = Marshal.GetDelegateForFunctionPointer<FGetOPFStringForApp>( Marshal.ReadIntPtr( VTable, 24) );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void GetVideoURLDelegate( IntPtr self, AppId_t unVideoAppID );
+		private delegate void FGetVideoURL( IntPtr self, AppId unVideoAppID );
-		private GetVideoURLDelegate GetVideoURLDelegatePointer;
+		private FGetVideoURL _GetVideoURL;
 		
 		#endregion
-		internal void GetVideoURL( AppId_t unVideoAppID )
+		internal void GetVideoURL( AppId unVideoAppID )
 		{
-			GetVideoURLDelegatePointer( Self, unVideoAppID );
+			_GetVideoURL( Self, unVideoAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool IsBroadcastingDelegate( IntPtr self, ref int pnNumViewers );
+		private delegate bool FIsBroadcasting( IntPtr self, ref int pnNumViewers );
-		private IsBroadcastingDelegate IsBroadcastingDelegatePointer;
+		private FIsBroadcasting _IsBroadcasting;
 		
 		#endregion
 		internal bool IsBroadcasting( ref int pnNumViewers )
 		{
-			return IsBroadcastingDelegatePointer( Self, ref pnNumViewers );
+			return _IsBroadcasting( Self, ref pnNumViewers );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
-		private delegate void GetOPFSettingsDelegate( IntPtr self, AppId_t unVideoAppID );
+		private delegate void FGetOPFSettings( IntPtr self, AppId unVideoAppID );
-		private GetOPFSettingsDelegate GetOPFSettingsDelegatePointer;
+		private FGetOPFSettings _GetOPFSettings;
 		
 		#endregion
-		internal void GetOPFSettings( AppId_t unVideoAppID )
+		internal void GetOPFSettings( AppId unVideoAppID )
 		{
-			GetOPFSettingsDelegatePointer( Self, unVideoAppID );
+			_GetOPFSettings( Self, unVideoAppID );
 		}
 		
 		#region FunctionMeta
 		[UnmanagedFunctionPointer( CallingConvention.ThisCall )]
 		[return: MarshalAs( UnmanagedType.I1 )]
-		private delegate bool GetOPFStringForAppDelegate( IntPtr self, AppId_t unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize );
+		private delegate bool FGetOPFStringForApp( IntPtr self, AppId unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize );
-		private GetOPFStringForAppDelegate GetOPFStringForAppDelegatePointer;
+		private FGetOPFStringForApp _GetOPFStringForApp;
 		
 		#endregion
-		internal bool GetOPFStringForApp( AppId_t unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize )
+		internal bool GetOPFStringForApp( AppId unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize )
 		{
-			return GetOPFStringForAppDelegatePointer( Self, unVideoAppID, pchBuffer, ref pnBufferSize );
+			return _GetOPFStringForApp( Self, unVideoAppID, pchBuffer, ref pnBufferSize );
 		}
 		
 	}

Facepunch.Steamworks/Generated/SteamEnums.cs

@@ -904,24 +904,9 @@ internal enum LeaderboardDataRequest : int
 	//
 	// ELeaderboardSortMethod
 	//
-	internal enum LeaderboardSortMethod : int
-	{
-		None = 0,
-		Ascending = 1,
-		Descending = 2,
-	}
-	
 	//
 	// ELeaderboardDisplayType
 	//
-	internal enum LeaderboardDisplayType : int
-	{
-		None = 0,
-		Numeric = 1,
-		TimeSeconds = 2,
-		TimeMilliSeconds = 3,
-	}
-	
 	//
 	// ELeaderboardUploadScoreMethod
 	//
@@ -1789,7 +1774,7 @@ internal enum SteamControllerLEDFlag : int
 	//
 	// EUGCMatchingUGCType
 	//
-	internal enum UGCMatchingUGCType : int
+	public enum UgcType : int
 	{
 		Items = 0,
 		Items_Mtx = 1,

Facepunch.Steamworks/Generated/SteamStructs.cs

@@ -645,7 +645,7 @@ public struct Pack8
 	internal struct FriendRichPresenceUpdate_t : Steamworks.ISteamCallback
 	{
 		internal ulong SteamIDFriend; // m_steamIDFriend class CSteamID
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.SteamFriends + 36;
@@ -657,7 +657,7 @@ internal struct FriendRichPresenceUpdate_t : Steamworks.ISteamCallback
 		public struct Pack4
 		{
 			internal ulong SteamIDFriend; // m_steamIDFriend class CSteamID
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator FriendRichPresenceUpdate_t ( FriendRichPresenceUpdate_t.Pack4 d ) => new FriendRichPresenceUpdate_t{ SteamIDFriend = d.SteamIDFriend,AppID = d.AppID, };
 		}
@@ -666,7 +666,7 @@ public struct Pack4
 		public struct Pack8
 		{
 			internal ulong SteamIDFriend; // m_steamIDFriend class CSteamID
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator FriendRichPresenceUpdate_t ( FriendRichPresenceUpdate_t.Pack8 d ) => new FriendRichPresenceUpdate_t{ SteamIDFriend = d.SteamIDFriend,AppID = d.AppID, };
 		}
@@ -2246,7 +2246,7 @@ public struct Pack8
 	
 	internal struct RemoteStorageAppSyncedClient_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		internal Result Result; // m_eResult enum EResult
 		internal int NumDownloads; // m_unNumDownloads int
 		
@@ -2259,7 +2259,7 @@ internal struct RemoteStorageAppSyncedClient_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal Result Result; // m_eResult enum EResult
 			internal int NumDownloads; // m_unNumDownloads int
 			
@@ -2269,7 +2269,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal Result Result; // m_eResult enum EResult
 			internal int NumDownloads; // m_unNumDownloads int
 			
@@ -2280,7 +2280,7 @@ public struct Pack8
 	
 	internal struct RemoteStorageAppSyncedServer_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		internal Result Result; // m_eResult enum EResult
 		internal int NumUploads; // m_unNumUploads int
 		
@@ -2293,7 +2293,7 @@ internal struct RemoteStorageAppSyncedServer_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal Result Result; // m_eResult enum EResult
 			internal int NumUploads; // m_unNumUploads int
 			
@@ -2303,7 +2303,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal Result Result; // m_eResult enum EResult
 			internal int NumUploads; // m_unNumUploads int
 			
@@ -2316,7 +2316,7 @@ internal struct RemoteStorageAppSyncProgress_t : Steamworks.ISteamCallback
 	{
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
 		internal string CurrentFile; // m_rgchCurrentFile char [260]
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		internal uint BytesTransferredThisChunk; // m_uBytesTransferredThisChunk uint32
 		internal double DAppPercentComplete; // m_dAppPercentComplete double
 		[MarshalAs(UnmanagedType.I1)]
@@ -2333,7 +2333,7 @@ public struct Pack4
 		{
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
 			internal string CurrentFile; // m_rgchCurrentFile char [260]
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal uint BytesTransferredThisChunk; // m_uBytesTransferredThisChunk uint32
 			internal double DAppPercentComplete; // m_dAppPercentComplete double
 			[MarshalAs(UnmanagedType.I1)]
@@ -2347,7 +2347,7 @@ public struct Pack8
 		{
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
 			internal string CurrentFile; // m_rgchCurrentFile char [260]
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal uint BytesTransferredThisChunk; // m_uBytesTransferredThisChunk uint32
 			internal double DAppPercentComplete; // m_dAppPercentComplete double
 			[MarshalAs(UnmanagedType.I1)]
@@ -2360,7 +2360,7 @@ public struct Pack8
 	
 	internal struct RemoteStorageAppSyncStatusCheck_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		internal Result Result; // m_eResult enum EResult
 		
 		#region ISteamCallback
@@ -2372,7 +2372,7 @@ internal struct RemoteStorageAppSyncStatusCheck_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal Result Result; // m_eResult enum EResult
 			
 			public static implicit operator RemoteStorageAppSyncStatusCheck_t ( RemoteStorageAppSyncStatusCheck_t.Pack4 d ) => new RemoteStorageAppSyncStatusCheck_t{ AppID = d.AppID,Result = d.Result, };
@@ -2381,7 +2381,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal Result Result; // m_eResult enum EResult
 			
 			public static implicit operator RemoteStorageAppSyncStatusCheck_t ( RemoteStorageAppSyncStatusCheck_t.Pack8 d ) => new RemoteStorageAppSyncStatusCheck_t{ AppID = d.AppID,Result = d.Result, };
@@ -2683,7 +2683,7 @@ internal struct RemoteStorageDownloadUGCResult_t : Steamworks.ISteamCallback
 	{
 		internal Result Result; // m_eResult enum EResult
 		internal ulong File; // m_hFile UGCHandle_t
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		internal int SizeInBytes; // m_nSizeInBytes int32
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
 		internal string PchFileName; // m_pchFileName char [260]
@@ -2700,7 +2700,7 @@ public struct Pack4
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal ulong File; // m_hFile UGCHandle_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal int SizeInBytes; // m_nSizeInBytes int32
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
 			internal string PchFileName; // m_pchFileName char [260]
@@ -2714,7 +2714,7 @@ public struct Pack8
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal ulong File; // m_hFile UGCHandle_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal int SizeInBytes; // m_nSizeInBytes int32
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
 			internal string PchFileName; // m_pchFileName char [260]
@@ -2729,8 +2729,8 @@ internal struct RemoteStorageGetPublishedFileDetailsResult_t : Steamworks.ISteam
 	{
 		internal Result Result; // m_eResult enum EResult
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-		internal uint CreatorAppID; // m_nCreatorAppID AppId_t
+		internal AppId CreatorAppID; // m_nCreatorAppID AppId_t
-		internal uint ConsumerAppID; // m_nConsumerAppID AppId_t
+		internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)]
 		internal string Title; // m_rgchTitle char [129]
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8000)]
@@ -2768,8 +2768,8 @@ public struct Pack4
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint CreatorAppID; // m_nCreatorAppID AppId_t
+			internal AppId CreatorAppID; // m_nCreatorAppID AppId_t
-			internal uint ConsumerAppID; // m_nConsumerAppID AppId_t
+			internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)]
 			internal string Title; // m_rgchTitle char [129]
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8000)]
@@ -2804,8 +2804,8 @@ public struct Pack8
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint CreatorAppID; // m_nCreatorAppID AppId_t
+			internal AppId CreatorAppID; // m_nCreatorAppID AppId_t
-			internal uint ConsumerAppID; // m_nConsumerAppID AppId_t
+			internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)]
 			internal string Title; // m_rgchTitle char [129]
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8000)]
@@ -2846,7 +2846,7 @@ internal struct RemoteStorageEnumerateWorkshopFilesResult_t : Steamworks.ISteamC
 		internal PublishedFileId[] GPublishedFileId; // m_rgPublishedFileId PublishedFileId_t [50]
 		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.R4)]
 		internal float[] GScore; // m_rgScore float [50]
-		internal uint AppId; // m_nAppId AppId_t
+		internal AppId AppId; // m_nAppId AppId_t
 		internal uint StartIndex; // m_unStartIndex uint32
 		
 		#region ISteamCallback
@@ -2865,7 +2865,7 @@ public struct Pack4
 			internal PublishedFileId[] GPublishedFileId; // m_rgPublishedFileId PublishedFileId_t [50]
 			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.R4)]
 			internal float[] GScore; // m_rgScore float [50]
-			internal uint AppId; // m_nAppId AppId_t
+			internal AppId AppId; // m_nAppId AppId_t
 			internal uint StartIndex; // m_unStartIndex uint32
 			
 			public static implicit operator RemoteStorageEnumerateWorkshopFilesResult_t ( RemoteStorageEnumerateWorkshopFilesResult_t.Pack4 d ) => new RemoteStorageEnumerateWorkshopFilesResult_t{ Result = d.Result,ResultsReturned = d.ResultsReturned,TotalResultCount = d.TotalResultCount,GPublishedFileId = d.GPublishedFileId,GScore = d.GScore,AppId = d.AppId,StartIndex = d.StartIndex, };
@@ -2881,7 +2881,7 @@ public struct Pack8
 			internal PublishedFileId[] GPublishedFileId; // m_rgPublishedFileId PublishedFileId_t [50]
 			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.R4)]
 			internal float[] GScore; // m_rgScore float [50]
-			internal uint AppId; // m_nAppId AppId_t
+			internal AppId AppId; // m_nAppId AppId_t
 			internal uint StartIndex; // m_unStartIndex uint32
 			
 			public static implicit operator RemoteStorageEnumerateWorkshopFilesResult_t ( RemoteStorageEnumerateWorkshopFilesResult_t.Pack8 d ) => new RemoteStorageEnumerateWorkshopFilesResult_t{ Result = d.Result,ResultsReturned = d.ResultsReturned,TotalResultCount = d.TotalResultCount,GPublishedFileId = d.GPublishedFileId,GScore = d.GScore,AppId = d.AppId,StartIndex = d.StartIndex, };
@@ -2935,7 +2935,7 @@ public struct Pack8
 	internal struct RemoteStoragePublishedFileSubscribed_t : Steamworks.ISteamCallback
 	{
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.ClientRemoteStorage + 21;
@@ -2947,7 +2947,7 @@ internal struct RemoteStoragePublishedFileSubscribed_t : Steamworks.ISteamCallba
 		public struct Pack4
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoteStoragePublishedFileSubscribed_t ( RemoteStoragePublishedFileSubscribed_t.Pack4 d ) => new RemoteStoragePublishedFileSubscribed_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -2956,7 +2956,7 @@ public struct Pack4
 		public struct Pack8
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoteStoragePublishedFileSubscribed_t ( RemoteStoragePublishedFileSubscribed_t.Pack8 d ) => new RemoteStoragePublishedFileSubscribed_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -2966,7 +2966,7 @@ public struct Pack8
 	internal struct RemoteStoragePublishedFileUnsubscribed_t : Steamworks.ISteamCallback
 	{
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.ClientRemoteStorage + 22;
@@ -2978,7 +2978,7 @@ internal struct RemoteStoragePublishedFileUnsubscribed_t : Steamworks.ISteamCall
 		public struct Pack4
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoteStoragePublishedFileUnsubscribed_t ( RemoteStoragePublishedFileUnsubscribed_t.Pack4 d ) => new RemoteStoragePublishedFileUnsubscribed_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -2987,7 +2987,7 @@ public struct Pack4
 		public struct Pack8
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoteStoragePublishedFileUnsubscribed_t ( RemoteStoragePublishedFileUnsubscribed_t.Pack8 d ) => new RemoteStoragePublishedFileUnsubscribed_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -2997,7 +2997,7 @@ public struct Pack8
 	internal struct RemoteStoragePublishedFileDeleted_t : Steamworks.ISteamCallback
 	{
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.ClientRemoteStorage + 23;
@@ -3009,7 +3009,7 @@ internal struct RemoteStoragePublishedFileDeleted_t : Steamworks.ISteamCallback
 		public struct Pack4
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoteStoragePublishedFileDeleted_t ( RemoteStoragePublishedFileDeleted_t.Pack4 d ) => new RemoteStoragePublishedFileDeleted_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -3018,7 +3018,7 @@ public struct Pack4
 		public struct Pack8
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoteStoragePublishedFileDeleted_t ( RemoteStoragePublishedFileDeleted_t.Pack8 d ) => new RemoteStoragePublishedFileDeleted_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -3250,7 +3250,7 @@ public struct Pack8
 	internal struct RemoteStoragePublishedFileUpdated_t : Steamworks.ISteamCallback
 	{
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		internal ulong Unused; // m_ulUnused uint64
 		
 		#region ISteamCallback
@@ -3263,7 +3263,7 @@ internal struct RemoteStoragePublishedFileUpdated_t : Steamworks.ISteamCallback
 		public struct Pack4
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal ulong Unused; // m_ulUnused uint64
 			
 			public static implicit operator RemoteStoragePublishedFileUpdated_t ( RemoteStoragePublishedFileUpdated_t.Pack4 d ) => new RemoteStoragePublishedFileUpdated_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID,Unused = d.Unused, };
@@ -3273,7 +3273,7 @@ public struct Pack4
 		public struct Pack8
 		{
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			internal ulong Unused; // m_ulUnused uint64
 			
 			public static implicit operator RemoteStoragePublishedFileUpdated_t ( RemoteStoragePublishedFileUpdated_t.Pack8 d ) => new RemoteStoragePublishedFileUpdated_t{ PublishedFileId = d.PublishedFileId,AppID = d.AppID,Unused = d.Unused, };
@@ -3835,7 +3835,7 @@ public struct Pack8
 	
 	internal struct DlcInstalled_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.SteamApps + 5;
@@ -3846,7 +3846,7 @@ internal struct DlcInstalled_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator DlcInstalled_t ( DlcInstalled_t.Pack4 d ) => new DlcInstalled_t{ AppID = d.AppID, };
 		}
@@ -3854,7 +3854,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator DlcInstalled_t ( DlcInstalled_t.Pack8 d ) => new DlcInstalled_t{ AppID = d.AppID, };
 		}
@@ -4465,8 +4465,8 @@ internal struct SteamUGCDetails_t
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 		internal Result Result; // m_eResult enum EResult
 		internal WorkshopFileType FileType; // m_eFileType enum EWorkshopFileType
-		internal uint CreatorAppID; // m_nCreatorAppID AppId_t
+		internal AppId CreatorAppID; // m_nCreatorAppID AppId_t
-		internal uint ConsumerAppID; // m_nConsumerAppID AppId_t
+		internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)]
 		internal string Title; // m_rgchTitle char [129]
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8000)]
@@ -4508,8 +4508,8 @@ public struct Pack4
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			internal Result Result; // m_eResult enum EResult
 			internal WorkshopFileType FileType; // m_eFileType enum EWorkshopFileType
-			internal uint CreatorAppID; // m_nCreatorAppID AppId_t
+			internal AppId CreatorAppID; // m_nCreatorAppID AppId_t
-			internal uint ConsumerAppID; // m_nConsumerAppID AppId_t
+			internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)]
 			internal string Title; // m_rgchTitle char [129]
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8000)]
@@ -4549,8 +4549,8 @@ public struct Pack8
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			internal Result Result; // m_eResult enum EResult
 			internal WorkshopFileType FileType; // m_eFileType enum EWorkshopFileType
-			internal uint CreatorAppID; // m_nCreatorAppID AppId_t
+			internal AppId CreatorAppID; // m_nCreatorAppID AppId_t
-			internal uint ConsumerAppID; // m_nConsumerAppID AppId_t
+			internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 129)]
 			internal string Title; // m_rgchTitle char [129]
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8000)]
@@ -4745,7 +4745,7 @@ public struct Pack8
 	
 	internal struct DownloadItemResult_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_unAppID AppId_t
+		internal AppId AppID; // m_unAppID AppId_t
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 		internal Result Result; // m_eResult enum EResult
 		
@@ -4758,7 +4758,7 @@ internal struct DownloadItemResult_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_unAppID AppId_t
+			internal AppId AppID; // m_unAppID AppId_t
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			internal Result Result; // m_eResult enum EResult
 			
@@ -4768,7 +4768,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_unAppID AppId_t
+			internal AppId AppID; // m_unAppID AppId_t
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			internal Result Result; // m_eResult enum EResult
 			
@@ -5028,7 +5028,7 @@ internal struct AddAppDependencyResult_t : Steamworks.ISteamCallback
 	{
 		internal Result Result; // m_eResult enum EResult
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.ClientUGC + 14;
@@ -5041,7 +5041,7 @@ public struct Pack4
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator AddAppDependencyResult_t ( AddAppDependencyResult_t.Pack4 d ) => new AddAppDependencyResult_t{ Result = d.Result,PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -5051,7 +5051,7 @@ public struct Pack8
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator AddAppDependencyResult_t ( AddAppDependencyResult_t.Pack8 d ) => new AddAppDependencyResult_t{ Result = d.Result,PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -5062,7 +5062,7 @@ internal struct RemoveAppDependencyResult_t : Steamworks.ISteamCallback
 	{
 		internal Result Result; // m_eResult enum EResult
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.ClientUGC + 15;
@@ -5075,7 +5075,7 @@ public struct Pack4
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoveAppDependencyResult_t ( RemoveAppDependencyResult_t.Pack4 d ) => new RemoveAppDependencyResult_t{ Result = d.Result,PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -5085,7 +5085,7 @@ public struct Pack8
 		{
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator RemoveAppDependencyResult_t ( RemoveAppDependencyResult_t.Pack8 d ) => new RemoveAppDependencyResult_t{ Result = d.Result,PublishedFileId = d.PublishedFileId,AppID = d.AppID, };
 		}
@@ -5097,7 +5097,7 @@ internal struct GetAppDependenciesResult_t : Steamworks.ISteamCallback
 		internal Result Result; // m_eResult enum EResult
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32, ArraySubType = UnmanagedType.U4)]
-		internal AppId_t[] GAppIDs; // m_rgAppIDs AppId_t [32]
+		internal AppId[] GAppIDs; // m_rgAppIDs AppId_t [32]
 		internal uint NumAppDependencies; // m_nNumAppDependencies uint32
 		internal uint TotalNumAppDependencies; // m_nTotalNumAppDependencies uint32
 		
@@ -5113,7 +5113,7 @@ public struct Pack4
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32, ArraySubType = UnmanagedType.U4)]
-			internal AppId_t[] GAppIDs; // m_rgAppIDs AppId_t [32]
+			internal AppId[] GAppIDs; // m_rgAppIDs AppId_t [32]
 			internal uint NumAppDependencies; // m_nNumAppDependencies uint32
 			internal uint TotalNumAppDependencies; // m_nTotalNumAppDependencies uint32
 			
@@ -5126,7 +5126,7 @@ public struct Pack8
 			internal Result Result; // m_eResult enum EResult
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32, ArraySubType = UnmanagedType.U4)]
-			internal AppId_t[] GAppIDs; // m_rgAppIDs AppId_t [32]
+			internal AppId[] GAppIDs; // m_rgAppIDs AppId_t [32]
 			internal uint NumAppDependencies; // m_nNumAppDependencies uint32
 			internal uint TotalNumAppDependencies; // m_nTotalNumAppDependencies uint32
 			
@@ -5168,7 +5168,7 @@ public struct Pack8
 	
 	internal struct SteamAppInstalled_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.SteamAppList + 1;
@@ -5179,7 +5179,7 @@ internal struct SteamAppInstalled_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator SteamAppInstalled_t ( SteamAppInstalled_t.Pack4 d ) => new SteamAppInstalled_t{ AppID = d.AppID, };
 		}
@@ -5187,7 +5187,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator SteamAppInstalled_t ( SteamAppInstalled_t.Pack8 d ) => new SteamAppInstalled_t{ AppID = d.AppID, };
 		}
@@ -5196,7 +5196,7 @@ public struct Pack8
 	
 	internal struct SteamAppUninstalled_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_nAppID AppId_t
+		internal AppId AppID; // m_nAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.SteamAppList + 2;
@@ -5207,7 +5207,7 @@ internal struct SteamAppUninstalled_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator SteamAppUninstalled_t ( SteamAppUninstalled_t.Pack4 d ) => new SteamAppUninstalled_t{ AppID = d.AppID, };
 		}
@@ -5215,7 +5215,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_nAppID AppId_t
+			internal AppId AppID; // m_nAppID AppId_t
 			
 			public static implicit operator SteamAppUninstalled_t ( SteamAppUninstalled_t.Pack8 d ) => new SteamAppUninstalled_t{ AppID = d.AppID, };
 		}
@@ -6298,7 +6298,7 @@ public struct Pack8
 	internal struct GetVideoURLResult_t : Steamworks.ISteamCallback
 	{
 		internal Result Result; // m_eResult enum EResult
-		internal uint VideoAppID; // m_unVideoAppID AppId_t
+		internal AppId VideoAppID; // m_unVideoAppID AppId_t
 		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
 		internal string URL; // m_rgchURL char [256]
 		
@@ -6312,7 +6312,7 @@ internal struct GetVideoURLResult_t : Steamworks.ISteamCallback
 		public struct Pack4
 		{
 			internal Result Result; // m_eResult enum EResult
-			internal uint VideoAppID; // m_unVideoAppID AppId_t
+			internal AppId VideoAppID; // m_unVideoAppID AppId_t
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
 			internal string URL; // m_rgchURL char [256]
 			
@@ -6323,7 +6323,7 @@ public struct Pack4
 		public struct Pack8
 		{
 			internal Result Result; // m_eResult enum EResult
-			internal uint VideoAppID; // m_unVideoAppID AppId_t
+			internal AppId VideoAppID; // m_unVideoAppID AppId_t
 			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
 			internal string URL; // m_rgchURL char [256]
 			
@@ -6335,7 +6335,7 @@ public struct Pack8
 	internal struct GetOPFSettingsResult_t : Steamworks.ISteamCallback
 	{
 		internal Result Result; // m_eResult enum EResult
-		internal uint VideoAppID; // m_unVideoAppID AppId_t
+		internal AppId VideoAppID; // m_unVideoAppID AppId_t
 		
 		#region ISteamCallback
 		public int GetCallbackId() => CallbackIdentifiers.ClientVideo + 24;
@@ -6347,7 +6347,7 @@ internal struct GetOPFSettingsResult_t : Steamworks.ISteamCallback
 		public struct Pack4
 		{
 			internal Result Result; // m_eResult enum EResult
-			internal uint VideoAppID; // m_unVideoAppID AppId_t
+			internal AppId VideoAppID; // m_unVideoAppID AppId_t
 			
 			public static implicit operator GetOPFSettingsResult_t ( GetOPFSettingsResult_t.Pack4 d ) => new GetOPFSettingsResult_t{ Result = d.Result,VideoAppID = d.VideoAppID, };
 		}
@@ -6356,7 +6356,7 @@ public struct Pack4
 		public struct Pack8
 		{
 			internal Result Result; // m_eResult enum EResult
-			internal uint VideoAppID; // m_unVideoAppID AppId_t
+			internal AppId VideoAppID; // m_unVideoAppID AppId_t
 			
 			public static implicit operator GetOPFSettingsResult_t ( GetOPFSettingsResult_t.Pack8 d ) => new GetOPFSettingsResult_t{ Result = d.Result,VideoAppID = d.VideoAppID, };
 		}
@@ -6894,7 +6894,7 @@ public struct Pack8
 	
 	internal struct ItemInstalled_t : Steamworks.ISteamCallback
 	{
-		internal uint AppID; // m_unAppID AppId_t
+		internal AppId AppID; // m_unAppID AppId_t
 		internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 		
 		#region ISteamCallback
@@ -6906,7 +6906,7 @@ internal struct ItemInstalled_t : Steamworks.ISteamCallback
 		[StructLayout( LayoutKind.Sequential, Pack = 4 )]
 		public struct Pack4
 		{
-			internal uint AppID; // m_unAppID AppId_t
+			internal AppId AppID; // m_unAppID AppId_t
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			
 			public static implicit operator ItemInstalled_t ( ItemInstalled_t.Pack4 d ) => new ItemInstalled_t{ AppID = d.AppID,PublishedFileId = d.PublishedFileId, };
@@ -6915,7 +6915,7 @@ public struct Pack4
 		[StructLayout( LayoutKind.Sequential, Pack = 8 )]
 		public struct Pack8
 		{
-			internal uint AppID; // m_unAppID AppId_t
+			internal AppId AppID; // m_unAppID AppId_t
 			internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t
 			
 			public static implicit operator ItemInstalled_t ( ItemInstalled_t.Pack8 d ) => new ItemInstalled_t{ AppID = d.AppID,PublishedFileId = d.PublishedFileId, };

Facepunch.Steamworks/Generated/SteamTypes.cs

@@ -50,15 +50,6 @@ internal struct BundleId_t
 		public override string ToString() => Value.ToString();
 	}
 	
-	internal struct AppId_t
-	{
-		public uint Value;
-		
-		public static implicit operator AppId_t( uint value ) => new AppId_t(){ Value = value };
-		public static implicit operator uint( AppId_t value ) => value.Value;
-		public override string ToString() => Value.ToString();
-	}
-	
 	internal struct AssetClassId_t
 	{
 		public ulong Value;

Facepunch.Steamworks/ServerList/Base.cs

@@ -56,7 +56,7 @@ internal static ISteamMatchmakingServers Internal
 
 		public Base()
 		{
-			AppId = SteamUtils.AppId; // Default AppId is this 
+			AppId = SteamClient.AppId; // Default AppId is this 
 		}
 
 		/// <summary>

Facepunch.Steamworks/SteamApps.cs

@@ -109,7 +109,7 @@ internal static void InstallEvents()
 		/// </summary>
 		public static IEnumerable<DlcInformation> DlcInformation()
 		{
-			var appid = default( AppId_t );
+			var appid = default( AppId );
 			var available = false;
 
 			for ( int i = 0; i < Internal.GetDLCCount(); i++ )

Facepunch.Steamworks/SteamClient.cs

@@ -25,6 +25,8 @@ public static void Init( uint appid )
 				throw new System.Exception( "SteamApi_Init returned false. Steam isn't running, couldn't find Steam, AppId is ureleased, Don't own AppId." );
 			}
 
+			AppId = appid;
+
 			initialized = true;
 
 			SteamApps.InstallEvents();
@@ -35,15 +37,16 @@ public static void Init( uint appid )
 			SteamUser.InstallEvents();
 			SteamFriends.InstallEvents();
 			SteamScreenshots.InstallEvents();
+			SteamUserStats.InstallEvents();
 
-			RunCallbacks();
+			RunCallbacksAsync();
 		}
 
 		public static bool IsValid => initialized;
 
-		internal static async void RunCallbacks()
+		internal static async void RunCallbacksAsync()
 		{
-			while ( true )
+			while ( IsValid )
 			{
 				await Task.Delay( 16 );
 				try
@@ -107,5 +110,10 @@ internal static void UnregisterCallback( IntPtr intPtr )
 		/// gets the status of the current user
 		/// </summary>
 		public static FriendState State => SteamFriends.Internal.GetPersonaState();
+
+		/// <summary>
+		/// returns the appID of the current process
+		/// </summary>
+		public static AppId AppId { get; internal set; }
 	}
 }

Facepunch.Steamworks/SteamUgc.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Steamworks.Data;
+
+namespace Steamworks
+{
+	/// <summary>
+	/// Functions for accessing and manipulating Steam user information.
+	/// This is also where the APIs for Steam Voice are exposed.
+	/// </summary>
+	public static class SteamUGC
+	{
+		static ISteamUGC _internal;
+		internal static ISteamUGC Internal
+		{
+			get
+			{
+				if ( _internal == null )
+				{
+					_internal = new ISteamUGC();
+				}
+
+				return _internal;
+			}
+		}
+
+		public static async Task<bool> DeleteFileAsync( PublishedFileId fileId )
+		{
+			var r = await Internal.DeleteItem( fileId );
+			return r?.Result == Result.OK;
+		}
+
+		public static bool Download( PublishedFileId fileId, bool highPriority = false )
+		{
+			return Internal.DownloadItem( fileId, highPriority );
+		}
+	}
+}

Facepunch.Steamworks/SteamUserStats.cs

@@ -21,6 +21,47 @@ internal static ISteamUserStats Internal
 			}
 		}
 
+		public static bool StatsRecieved { get; internal set; }
+
+		internal static void InstallEvents()
+		{
+			new Event<UserStatsReceived_t>( x =>
+			{
+				if ( x.SteamIDUser == SteamClient.SteamId )
+					StatsRecieved = true;
+
+				OnUserStatsReceived?.Invoke( x.SteamIDUser, x.Result );
+			} );
+
+			new Event<UserStatsStored_t>( x => OnUserStatsStored?.Invoke( x.Result ) );
+			new Event<UserAchievementStored_t>( x => OnAchievementProgress?.Invoke( x.AchievementName, (int) x.CurProgress, (int)x.MaxProgress ) );
+			new Event<UserStatsUnloaded_t>( x => OnUserStatsUnloaded?.Invoke( x.SteamIDUser ) );
+		}
+
+		/// <summary>
+		/// called when the latests stats and achievements have been received
+		///	from the server
+		/// </summary>
+		public static event Action<SteamId, Result> OnUserStatsReceived;
+
+		/// <summary>
+		/// result of a request to store the user stats for a game
+		/// </summary>
+		public static event Action<Result> OnUserStatsStored;
+
+		/// <summary>
+		/// result of a request to store the achievements for a game, or an 
+		///	"indicate progress" call. If both m_nCurProgress and m_nMaxProgress
+		///	are zero, that means the achievement has been fully unlocked
+		/// </summary>
+		public static event Action<string, int, int> OnAchievementProgress;
+
+
+		/// <summary>
+		/// Callback indicating that a user's stats have been unloaded
+		/// </summary>
+		public static event Action<SteamId> OnUserStatsUnloaded;
+
 		/// <summary>
 		/// Get the available achievements
 		/// </summary>
@@ -47,5 +88,58 @@ public static async Task<int> PlayerCountAsync()
 
 			return result.Value.CPlayers;
 		}
+		
+		/// Send the changed stats and achievements data to the server for permanent storage.
+		/// If this fails then nothing is sent to the server. It's advisable to keep trying until the call is successful.
+		/// This call can be rate limited. Call frequency should be on the order of minutes, rather than seconds.You should only be calling this during major state changes such as the end of a round, the map changing, or the user leaving a server. This call is required to display the achievement unlock notification dialog though, so if you have called SetAchievement then it's advisable to call this soon after that.
+		/// If you have stats or achievements that you have saved locally but haven't uploaded with this function when your application process ends then this function will automatically be called.
+		/// You can find additional debug information written to the %steam_install%\logs\stats_log.txt file.
+		/// This function returns true upon success if :
+		/// RequestCurrentStats has completed and successfully returned its callback AND
+		/// the current game has stats associated with it in the Steamworks Partner backend, and those stats are published.
+		/// </summary>
+		public static bool StoreStats()
+		{
+			return Internal.StoreStats();
+		}
+
+		/// <summary>
+		/// Asynchronously request the user's current stats and achievements from the server.
+		/// You must always call this first to get the initial status of stats and achievements.
+		/// Only after the resulting callback comes back can you start calling the rest of the stats 
+		/// and achievement functions for the current user.
+		/// </summary>
+		public static bool RequestCurrentStats()
+		{
+			return Internal.RequestCurrentStats();
+		}
+
+		/// <summary>
+		/// Gets a leaderboard by name, it will create it if it's not yet created.
+		/// Leaderboards created with this function will not automatically show up in the Steam Community.
+		/// You must manually set the Community Name field in the App Admin panel of the Steamworks website. 
+		/// As such it's generally recommended to prefer creating the leaderboards in the App Admin panel on 
+		/// the Steamworks website and using FindLeaderboard unless you're expected to have a large amount of
+		/// dynamically created leaderboards.
+		/// </summary>
+		public static async Task<Leaderboard?> FindOrCreateLeaderboard( string name, LeaderboardSort sort, LeaderboardDisplay display )
+		{
+			var result = await Internal.FindOrCreateLeaderboard( name, sort, display );
+			if ( !result.HasValue || result.Value.LeaderboardFound == 0 )
+				return null;
+
+			return new Leaderboard { Id = result.Value.SteamLeaderboard };
+		}
+
+
+		public static async Task<Leaderboard?> FindLeaderboard( string name )
+		{
+			var result = await Internal.FindLeaderboard( name );
+			if ( !result.HasValue || result.Value.LeaderboardFound == 0 )
+				return null;
+
+			return new Leaderboard { Id = result.Value.SteamLeaderboard };
+		}
+
 	}
 }

Facepunch.Steamworks/SteamUtils.cs

@@ -121,11 +121,6 @@ public static bool GetImageSize( int image, out uint width, out uint height )
 		/// </summary>
 		public static float CurrentBatteryPower => Math.Min( Internal.GetCurrentBatteryPower() / 100, 1.0f );
 
-		/// <summary>
-		/// returns the appID of the current process
-		/// </summary>
-		public static AppId AppId => Internal.GetAppID();
-
 		static NotificationPosition overlayNotificationPosition = NotificationPosition.BottomRight;
 
 		/// <summary>

Facepunch.Steamworks/Structs/Friend.cs

@@ -16,9 +16,31 @@ public Friend( SteamId steamid )
 			Id = steamid;
 		}
 
+		public override string ToString()
+		{
+			return $"{Name} ({Id.ToString()})";
+		}
+
+
+		/// <summary>
+		/// Returns true if this is the local user
+		/// </summary>
+		public bool IsMe => Id == SteamClient.SteamId;
+
+		/// <summary>
+		/// Return true if this is a friend
+		/// </summary>
 		public bool IsFriend => Relationship == Relationship.Friend;
+
+		/// <summary>
+		/// Returns true if you have this user blocked
+		/// </summary>
 		public bool IsBlocked => Relationship == Relationship.Blocked;
-		public bool IsPlayingThisGame => GameInfo?.GameID == SteamUtils.AppId;
+
+		/// <summary>
+		/// Return true if this user is playing the game we're running
+		/// </summary>
+		public bool IsPlayingThisGame => GameInfo?.GameID == SteamClient.AppId;
 
 		/// <summary>
 		/// Returns true if this friend is online

Facepunch.Steamworks/Structs/Leaderboard.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Steamworks.Data
+{
+	public struct Leaderboard
+	{
+		internal SteamLeaderboard_t Id;
+
+		/// <summary>
+		/// the name of a leaderboard
+		/// </summary>
+		public string Name => SteamUserStats.Internal.GetLeaderboardName( Id );
+		public LeaderboardSort Sort => SteamUserStats.Internal.GetLeaderboardSortMethod( Id );
+		public LeaderboardDisplay Display => SteamUserStats.Internal.GetLeaderboardDisplayType( Id );
+
+		static int[] detailsBuffer = new int[64];
+		static int[] noDetails = new int[0];
+
+		/// <summary>
+		/// Submit your score and replace your old score even if it was better
+		/// </summary>
+		public async Task<LeaderboardUpdate?> ReplaceScore( int score, int[] details = null )
+		{
+			if ( details == null ) details = noDetails;
+
+			var r = await SteamUserStats.Internal.UploadLeaderboardScore( Id, LeaderboardUploadScoreMethod.ForceUpdate, score, details, details.Length );
+			if ( !r.HasValue ) return null;
+
+			return LeaderboardUpdate.From( r.Value );
+		}
+
+		/// <summary>
+		/// Submit your new score, but won't replace your high score if it's lower
+		/// </summary>
+		public async Task<LeaderboardUpdate?> SubmitScore( int score, int[] details = null )
+		{
+			if ( details == null ) details = noDetails;
+
+			var r = await SteamUserStats.Internal.UploadLeaderboardScore( Id, LeaderboardUploadScoreMethod.KeepBest, score, details, details.Length );
+			if ( !r.HasValue ) return null;
+
+			return LeaderboardUpdate.From( r.Value );
+		}
+
+		/// <summary>
+		/// Attaches a piece of user generated content the user's entry on a leaderboard
+		/// </summary>
+		public async Task<Result> AttachUgc( Ugc file )
+		{
+			var r = await SteamUserStats.Internal.AttachLeaderboardUGC( Id, file.Handle );
+			if ( !r.HasValue ) return Result.Fail;
+
+			return r.Value.Result;
+		}
+
+		/// <summary>
+		/// Used to query for a sequential range of leaderboard entries by leaderboard Sort.
+		/// </summary>
+		public async Task<LeaderboardEntry[]> GetScoresAsync( int count, int offset = 1 )
+		{
+			if ( offset <= 0 ) throw new System.ArgumentException( "Should be 1+", nameof( offset ) );
+
+			var r = await SteamUserStats.Internal.DownloadLeaderboardEntries( Id, LeaderboardDataRequest.Global, offset, offset + count );
+			if ( !r.HasValue )
+				return null;
+
+			return await LeaderboardResultToEntries( r.Value );
+		}
+
+		/// <summary>
+		/// Used to retrieve leaderboard entries relative a user's entry. If there are not enough entries in the leaderboard 
+		/// before or after the user's entry, Steam will adjust the range to try to return the number of entries requested.
+		/// For example, if the user is #1 on the leaderboard and start is set to -2, end is set to 2, Steam will return the first 
+		/// 5 entries in the leaderboard. If The current user has no entry, this will return null.
+		/// </summary>
+		public async Task<LeaderboardEntry[]> GetScoresAroundUserAsync( int start = -10, int end = 10 )
+		{
+			var r = await SteamUserStats.Internal.DownloadLeaderboardEntries( Id, LeaderboardDataRequest.GlobalAroundUser, start, end );
+			if ( !r.HasValue )
+				return null;
+
+			return await LeaderboardResultToEntries( r.Value );
+		}
+
+		/// <summary>
+		/// Used to retrieve all leaderboard entries for friends of the current user
+		/// </summary>
+		public async Task<LeaderboardEntry[]> GetScoresFromFriends()
+		{
+			var r = await SteamUserStats.Internal.DownloadLeaderboardEntries( Id, LeaderboardDataRequest.Friends, 0, 0 );
+			if ( !r.HasValue )
+				return null;
+
+			return await LeaderboardResultToEntries( r.Value );
+		}
+
+		#region util
+		internal async Task<LeaderboardEntry[]> LeaderboardResultToEntries( LeaderboardScoresDownloaded_t r )
+		{
+			if ( r.CEntryCount == 0 )
+				return null;
+
+			var output = new LeaderboardEntry[r.CEntryCount];
+			var e = default( LeaderboardEntry_t );
+
+			for ( int i = 0; i < r.CEntryCount; i++ )
+			{
+				if ( SteamUserStats.Internal.GetDownloadedLeaderboardEntry( r.SteamLeaderboardEntries, i, ref e, detailsBuffer, detailsBuffer.Length ) )
+				{
+					output[i] = LeaderboardEntry.From( e, detailsBuffer );
+				}
+			}
+
+			await WaitForUserNames( output );
+
+			return output;
+		}
+
+		internal async Task WaitForUserNames( LeaderboardEntry[] entries)
+		{
+			bool gotAll = false;
+			while ( !gotAll )
+			{
+				gotAll = true;
+
+				foreach ( var entry in entries )
+				{
+					if ( entry.User.Id == 0 ) continue;
+					if ( !SteamFriends.Internal.RequestUserInformation( entry.User.Id, true ) ) continue;
+
+					gotAll = false;
+				}
+
+				await Task.Delay( 1 );
+			}
+		}
+		#endregion
+	}
+}

Facepunch.Steamworks/Structs/LeaderboardEntry.cs

@@ -0,0 +1,31 @@
+using System.Linq;
+
+namespace Steamworks.Data
+{
+	public struct LeaderboardEntry
+	{
+		public Friend User;
+		public int GlobalRank;
+		public int Score;
+		public int[] Details;
+		// UGCHandle_t m_hUGC
+
+		internal static LeaderboardEntry From( LeaderboardEntry_t e, int[] detailsBuffer )
+		{
+			var r = new LeaderboardEntry
+			{
+				User = new Friend( e.SteamIDUser ),
+				GlobalRank = e.GlobalRank,
+				Score = e.Score,
+				Details = null
+			};
+
+			if ( e.CDetails > 0 )
+			{
+				r.Details = detailsBuffer.Take( e.CDetails ).ToArray();
+			}
+
+			return r;
+		}
+	}
+}

Facepunch.Steamworks/Structs/LeaderboardUpdate.cs

@@ -0,0 +1,22 @@
+using System.Linq;
+
+namespace Steamworks.Data
+{
+	public struct LeaderboardUpdate
+	{
+		public int Score;
+		public bool Changed;
+		public int NewGlobalRank;
+		public int OldGlobalRank;
+		public int RankChange => NewGlobalRank - OldGlobalRank;
+
+		internal static LeaderboardUpdate From( LeaderboardScoreUploaded_t e ) =>
+			new LeaderboardUpdate
+			{
+				Score = e.Score,
+				Changed = e.ScoreChanged == 1,
+				NewGlobalRank = e.GlobalRankNew,
+				OldGlobalRank = e.GlobalRankPrevious
+			};
+	}
+}

Facepunch.Steamworks/Structs/Stat.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Steamworks.Data
+{
+	public struct Stat
+	{
+		public string Name { get; internal set; }
+		public SteamId UserId { get; internal set; }
+
+		public Stat( string name )
+		{
+			Name = name;
+			UserId = 0;
+		}
+
+		public Stat( string name, SteamId user )
+		{
+			Name = name;
+			UserId = user;
+		}
+
+		internal void LocalUserOnly( [CallerMemberName] string caller = null )
+		{
+			if ( UserId == 0 ) return;
+			throw new System.Exception( $"Stat.{caller} can only be called for the local user" );
+		}
+
+		public double GetGlobalFloat()
+		{
+			double val = 0.0;
+
+			if ( SteamUserStats.Internal.GetGlobalStat2( Name, ref val ) )
+				return val;
+
+			return 0;
+		}
+
+		public long GetGlobalInt()
+		{
+			long val = 0;
+			SteamUserStats.Internal.GetGlobalStat1( Name, ref val );
+			return val;
+		}
+
+		public async Task<long[]> GetGlobalIntDays( int days )
+		{
+			var result = await SteamUserStats.Internal.RequestGlobalStats( days );
+			if ( result?.Result != Result.OK  ) return null;
+
+			var r = new long[days];
+
+			var rows = SteamUserStats.Internal.GetGlobalStatHistory1( Name, r, (uint) r.Length );
+			
+			if ( days != rows )
+				r = r.Take( rows ).ToArray();
+
+			return r;
+		}
+
+		public async Task<double[]> GetGlobalFloatDays( int days )
+		{
+			var result = await SteamUserStats.Internal.RequestGlobalStats( days );
+			if ( result?.Result != Result.OK ) return null;
+
+			var r = new double[days];
+
+			var rows = SteamUserStats.Internal.GetGlobalStatHistory2( Name, r, (uint)r.Length );
+
+			if ( days != rows )
+				r = r.Take( rows ).ToArray();
+
+			return r;
+		}
+
+		public float GetFloat()
+		{
+			float val = 0.0f;
+
+			if ( UserId > 0 )
+			{
+				SteamUserStats.Internal.GetUserStat2( UserId, Name, ref val );
+			}
+			else
+			{
+				SteamUserStats.Internal.GetStat2( Name, ref val );
+			}
+
+			return 0;
+		}
+
+		public int GetInt()
+		{
+			int val = 0;
+
+			if ( UserId > 0 )
+			{
+				SteamUserStats.Internal.GetUserStat1( UserId, Name, ref val );
+			}
+			else
+			{
+				SteamUserStats.Internal.GetStat1( Name, ref val );
+			}
+
+			return val;
+		}
+
+		public bool Set( int val )
+		{
+			LocalUserOnly();
+			return SteamUserStats.Internal.SetStat1( Name, val );
+		}
+
+		public bool Set( float val )
+		{
+			LocalUserOnly();
+			return SteamUserStats.Internal.SetStat2( Name, val );
+		}
+
+		public bool UpdateAverageRate( float count, float sessionlength )
+		{
+			LocalUserOnly();
+			return SteamUserStats.Internal.UpdateAvgRateStat( Name, count, sessionlength );
+		}
+
+		public bool Store()
+		{
+			LocalUserOnly();
+			return SteamUserStats.Internal.StoreStats();
+		}
+	}
+}

Facepunch.Steamworks/Structs/SteamId.cs

@@ -21,5 +21,7 @@ public static implicit operator ulong( SteamId value )
 		}
 
 		public override string ToString() => Value.ToString();
+
+		public uint AccountId => (uint) (Value & 0xFFFFFFFFul);
 	}
 }

Facepunch.Steamworks/Structs/Ugc.cs

@@ -0,0 +1,9 @@
+using System.Linq;
+
+namespace Steamworks.Data
+{
+	public struct Ugc
+	{
+		internal UGCHandle_t Handle;
+	}
+}

Facepunch.Steamworks/Structs/UgcEditor.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Steamworks.Data;
+
+using QueryType = Steamworks.Ugc.Query;
+
+namespace Steamworks.Ugc
+{
+	public struct Editor
+	{
+		PublishedFileId fileId;
+
+		bool creatingNew;
+		WorkshopFileType creatingType;
+		AppId consumerAppId;
+
+		internal Editor( WorkshopFileType filetype ) : this()
+		{
+			creatingNew = true;
+			creatingType = filetype;
+		}
+
+		/// <summary>
+		/// Create a Normal Workshop item that can be subscribed to
+		/// </summary>
+		public static Editor NewCommunityFile => new Editor( WorkshopFileType.Community );
+
+		/// <summary>
+		/// Workshop item that is meant to be voted on for the purpose of selling in-game
+		/// </summary>
+		public static Editor NewMicrotransactionFile => new Editor( WorkshopFileType.Microtransaction );
+
+		public Editor ForAppId( AppId id ) { this.consumerAppId = id; return this; }
+
+
+		string Title;
+		public Editor WithTitle( string t ) { this.Title = t; return this; }
+
+		string Description;
+		public Editor WithDescription( string t ) { this.Description = t; return this; }
+
+		string MetaData;
+		public Editor WithMetaData( string t ) { this.MetaData = t; return this; }
+
+		string Language;
+		public Editor InLanguage( string t ) { this.Language = t; return this; }
+
+		System.IO.DirectoryInfo ContentFolder;
+		public Editor WithContent( System.IO.DirectoryInfo t ) { this.ContentFolder = t; return this; }
+		public Editor WithContent( string folderName ) { return WithContent( new System.IO.DirectoryInfo( folderName ) ); }
+
+
+		public async Task<PublishResult> SubmitAsync( IProgress<float> progress = null )
+		{
+			var result = default( PublishResult );
+
+			progress?.Report( 0 );
+
+			//
+			// Item Create
+			//
+			if ( creatingNew )
+			{
+				if ( consumerAppId == 0 )
+					consumerAppId = SteamClient.AppId;
+
+				result.Result = Steamworks.Result.Fail;
+
+				var created = await SteamUGC.Internal.CreateItem( consumerAppId, creatingType );
+				if ( !created.HasValue ) return result;
+
+				result.Result = created.Value.Result;
+
+				if ( result.Result != Steamworks.Result.OK )
+					return result;
+
+				fileId = created.Value.PublishedFileId;
+				result.NeedsWorkshopAgreement = created.Value.UserNeedsToAcceptWorkshopLegalAgreement;
+				result.FileId = fileId;
+			}
+
+
+			result.FileId = fileId;
+
+			//
+			// Item Update
+			//
+			{
+				var handle = SteamUGC.Internal.StartItemUpdate( consumerAppId, fileId );
+				if ( handle == 0xffffffffffffffff )
+					return result;
+
+				if ( Title != null ) SteamUGC.Internal.SetItemTitle( handle, Title );
+				if ( Description != null ) SteamUGC.Internal.SetItemDescription( handle, Description );
+				if ( MetaData != null ) SteamUGC.Internal.SetItemMetadata( handle, MetaData );
+				if ( Language != null ) SteamUGC.Internal.SetItemUpdateLanguage( handle, Language );
+				if ( ContentFolder != null ) SteamUGC.Internal.SetItemContent( handle, ContentFolder.FullName );
+
+				result.Result = Steamworks.Result.Fail;
+
+				var updating = SteamUGC.Internal.SubmitItemUpdate( handle, "" );
+
+				while ( !updating.IsCompleted )
+				{
+					if ( progress != null )
+					{
+						ulong total = 0;
+						ulong processed = 0;
+
+						var r = SteamUGC.Internal.GetItemUpdateProgress( handle, ref processed, ref total );
+
+						switch ( r )
+						{
+							case ItemUpdateStatus.PreparingConfig:
+								{
+									progress?.Report( 0.1f );
+									break;
+								}
+
+							case ItemUpdateStatus.PreparingContent:
+								{
+									progress?.Report( 0.2f );
+									break;
+								}
+							case ItemUpdateStatus.UploadingContent:
+								{
+									var uploaded = total > 0 ? ((float)processed / (float)total) : 0.0f;
+									progress?.Report( 0.2f + uploaded * 0.7f );
+									break;
+								}
+							case ItemUpdateStatus.UploadingPreviewFile:
+								{
+									progress?.Report( 8f );
+									break;
+								}
+							case ItemUpdateStatus.CommittingChanges:
+								{
+									progress?.Report( 1 );
+									break;
+								}
+						}
+					}
+
+					await Task.Delay( 1000 / 60 );
+				}
+
+				progress?.Report( 1 );
+
+				var updated = updating.Result;
+
+				if ( !updated.HasValue ) return result;
+
+				result.Result = updated.Value.Result;
+
+				if ( result.Result != Steamworks.Result.OK )
+					return result;
+
+				result.NeedsWorkshopAgreement = updated.Value.UserNeedsToAcceptWorkshopLegalAgreement;
+				result.FileId = fileId;
+
+			}
+
+			return result;
+		}
+	}
+
+	public struct PublishResult
+	{
+		public bool Success => Result == Steamworks.Result.OK;
+
+		public Steamworks.Result Result;
+		public PublishedFileId FileId;
+
+		/// <summary>
+		/// https://partner.steamgames.com/doc/features/workshop/implementation#Legal
+		/// </summary>
+		public bool NeedsWorkshopAgreement;
+	}
+}

Facepunch.Steamworks/Structs/UgcItem.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Steamworks.Data;
+
+using QueryType = Steamworks.Ugc.Query;
+
+namespace Steamworks.Ugc
+{
+	public struct Item
+	{
+		internal enum ItemState : int
+		{
+			None = 0,
+			Subscribed = 1,
+			LegacyItem = 2,
+			Installed = 4,
+			NeedsUpdate = 8,
+			Downloading = 16,
+			DownloadPending = 32,
+		}
+
+		public PublishedFileId Id { get; internal set; }
+
+		public string Title { get; internal set; }
+		public string Description { get; internal set; }
+		public string[] Tags { get; internal set; }
+
+		public bool IsInstalled => (State & ItemState.Installed) == ItemState.Installed;
+		public bool IsDownloading => (State & ItemState.Downloading) == ItemState.Downloading; 
+		public bool IsDownloadPending => (State & ItemState.DownloadPending) == ItemState.DownloadPending; 
+		public bool IsSubscribed => (State & ItemState.Subscribed) == ItemState.Subscribed;
+		public bool NeedsUpdate => (State & ItemState.NeedsUpdate) == ItemState.NeedsUpdate;
+
+		public bool Download( bool highPriority = false )
+		{
+			return SteamUGC.Internal.DownloadItem( Id, highPriority );
+		}
+
+		private ItemState State => (ItemState) SteamUGC.Internal.GetItemState( Id );
+
+		public static async Task<Item?> Get( PublishedFileId id, int maxageseconds = 60 * 30 )
+		{
+			var result = await SteamUGC.Internal.RequestUGCDetails( id, (uint) maxageseconds );
+			if ( !result.HasValue ) return null;
+
+			return From( result.Value.Details );
+		}
+
+		internal static Item From( SteamUGCDetails_t details )
+		{
+			var d = new Item
+			{
+				Id = details.PublishedFileId,
+			//	FileType = details.FileType,
+
+				Title = details.Title,
+				Description = details.Description,
+				Tags = details.Tags.Split( new[] { ',' }, StringSplitOptions.RemoveEmptyEntries )
+
+			};
+
+			return d;
+		}
+
+		/// <summary>
+		/// A case insensitive check for tag
+		/// </summary>
+		public bool HasTag( string find )
+		{
+			if ( Tags.Length == 0 ) return false;
+
+			return Tags.Contains( find, StringComparer.OrdinalIgnoreCase );
+		}
+
+	}
+}

Facepunch.Steamworks/Structs/UgcQuery.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Steamworks.Data;
+
+using QueryType = Steamworks.Ugc.Query;
+
+namespace Steamworks.Ugc
+{
+	public struct Query
+	{
+		UgcType matchingType;
+		UGCQuery queryType;
+		AppId consumerApp;
+		AppId creatorApp;
+
+		public Query( UgcType type ) : this()
+		{
+			matchingType = type;
+		}
+
+		public static Query All => new Query( UgcType.All );
+		public static Query Items => new Query( UgcType.Items );
+		public static Query ItemsMtx => new Query( UgcType.Items_Mtx );
+		public static Query ItemsReadyToUse => new Query( UgcType.Items_ReadyToUse );
+		public static Query Collections => new Query( UgcType.Collections );
+		public static Query Artwork => new Query( UgcType.Artwork );
+		public static Query Videos => new Query( UgcType.Videos );
+		public static Query Screenshots => new Query( UgcType.Screenshots );
+		public static Query AllGuides => new Query( UgcType.AllGuides );
+		public static Query WebGuides => new Query( UgcType.WebGuides );
+		public static Query IntegratedGuides => new Query( UgcType.IntegratedGuides );
+		public static Query UsableInGame => new Query( UgcType.UsableInGame );
+		public static Query ControllerBindings => new Query( UgcType.ControllerBindings );
+		public static Query GameManagedItems => new Query( UgcType.GameManagedItems );
+
+
+		public Query RankedByVote() { queryType = UGCQuery.RankedByVote; return this; }
+		public Query RankedByPublicationDate() { queryType = UGCQuery.RankedByPublicationDate; return this; }
+		public Query RankedByAcceptanceDate() { queryType = UGCQuery.AcceptedForGameRankedByAcceptanceDate; return this; }
+		public Query RankedByTrend() { queryType = UGCQuery.RankedByTrend; return this; }
+		public Query FavoritedByFriends() { queryType = UGCQuery.FavoritedByFriendsRankedByPublicationDate; return this; }
+		public Query CreatedByFriends() { queryType = UGCQuery.CreatedByFriendsRankedByPublicationDate; return this; }
+		public Query RankedByNumTimesReported() { queryType = UGCQuery.RankedByNumTimesReported; return this; }
+		public Query CreatedByFollowedUsers() { queryType = UGCQuery.CreatedByFollowedUsersRankedByPublicationDate; return this; }
+		public Query NotYetRated() { queryType = UGCQuery.NotYetRated; return this; }
+		public Query RankedByTotalVotesAsc() { queryType = UGCQuery.RankedByTotalVotesAsc; return this; }
+		public Query RankedByVotesUp() { queryType = UGCQuery.RankedByVotesUp; return this; }
+		public Query RankedByTextSearch() { queryType = UGCQuery.RankedByTextSearch; return this; }
+		public Query RankedByTotalUniqueSubscriptions() { queryType = UGCQuery.RankedByTotalUniqueSubscriptions; return this; }
+		public Query RankedByPlaytimeTrend() { queryType = UGCQuery.RankedByPlaytimeTrend; return this; }
+		public Query RankedByTotalPlaytime() { queryType = UGCQuery.RankedByTotalPlaytime; return this; }
+		public Query RankedByAveragePlaytimeTrend() { queryType = UGCQuery.RankedByAveragePlaytimeTrend; return this; }
+		public Query RankedByLifetimeAveragePlaytime() { queryType = UGCQuery.RankedByLifetimeAveragePlaytime; return this; }
+		public Query RankedByPlaytimeSessionsTrend() { queryType = UGCQuery.RankedByPlaytimeSessionsTrend; return this; }
+		public Query RankedByLifetimePlaytimeSessions() { queryType = UGCQuery.RankedByLifetimePlaytimeSessions; return this; }
+
+
+		public async Task<ResultPage?> GetPageAsync( int page )
+		{
+			if ( page <= 0 ) throw new System.Exception( "page should be > 0" );
+
+			if ( consumerApp == 0 ) consumerApp = SteamClient.AppId;
+			if ( creatorApp == 0 ) creatorApp = consumerApp;
+
+			UGCQueryHandle_t handle;
+			handle = SteamUGC.Internal.CreateQueryAllUGCRequest1( queryType, matchingType, creatorApp.Value, consumerApp.Value, (uint)page );
+
+			ApplyConstraints( handle );
+
+			var result = await SteamUGC.Internal.SendQueryUGCRequest( handle );
+			if ( !result.HasValue )
+				return null;
+
+			if ( result.Value.Result != Steamworks.Result.OK )
+				return null;
+
+			return new ResultPage
+			{
+				Handle = result.Value.Handle,
+				ResultCount = (int) result.Value.NumResultsReturned,
+				TotalCount = (int)result.Value.TotalMatchingResults,
+				CachedData = result.Value.CachedData
+			};
+		}
+
+
+		#region SharedConstraints
+		public QueryType WithType( UgcType type ){ matchingType = type; return this; }
+		bool? WantsReturnOnlyIDs;
+		public QueryType WithOnlyIDs( bool b ) { WantsReturnOnlyIDs = b; return this; }
+		bool? WantsReturnKeyValueTags;
+		public QueryType WithKeyValueTag( bool b ) { WantsReturnKeyValueTags = b; return this; }
+		bool? WantsReturnLongDescription;
+		public QueryType WithLongDescription( bool b ) { WantsReturnLongDescription = b; return this; }
+		bool? WantsReturnMetadata;
+		public QueryType WithMetadata( bool b ) { WantsReturnMetadata = b; return this; }
+		bool? WantsReturnChildren;
+		public QueryType WithChildren( bool b ) { WantsReturnChildren = b; return this; }
+		bool? WantsReturnAdditionalPreviews;
+		public QueryType WithAdditionalPreviews( bool b ) { WantsReturnAdditionalPreviews = b; return this; }
+		bool? WantsReturnTotalOnly;
+		public QueryType WithTotalOnly( bool b ) { WantsReturnTotalOnly = b; return this; }
+		bool? WantsReturnPlaytimeStats;
+		public QueryType WithPlaytimeStats( bool b ) { WantsReturnPlaytimeStats = b; return this; }
+		int? maxCacheAge;
+		public QueryType AllowCachedResponse( int maxSecondsAge ) { maxCacheAge = maxSecondsAge; return this; }
+		string language;
+		public QueryType InLanguage( string lang ) { language = lang; return this; }
+
+		List<string> requiredTags;
+		bool? matchAnyTag;
+		List<string> excludedTags;
+		Dictionary<string, string> requiredKv;
+
+		/// <summary>
+		/// Found items must have at least one of the defined tags
+		/// </summary>
+		public QueryType MatchAnyTag() { matchAnyTag = true; return this; }
+
+		/// <summary>
+		/// Found items must have all defined tags
+		/// </summary>
+		public QueryType MatchAllTags() { matchAnyTag = false; return this; }
+
+		public QueryType WithTag( string tag )
+		{
+			if ( requiredTags == null ) requiredTags = new List<string>();
+			requiredTags.Add( tag );
+			return this;
+		}
+
+		public QueryType WithoutTag( string tag )
+		{
+			if ( excludedTags == null ) excludedTags = new List<string>();
+			excludedTags.Add( tag );
+			return this;
+		}
+
+		void ApplyConstraints( UGCQueryHandle_t handle )
+		{
+			if ( requiredTags != null )
+			{
+				foreach ( var tag in requiredTags )
+					SteamUGC.Internal.AddRequiredTag( handle, tag );
+			}
+
+			if ( excludedTags != null )
+			{
+				foreach ( var tag in excludedTags )
+					SteamUGC.Internal.AddExcludedTag( handle, tag );
+			}
+
+			if ( requiredKv != null )
+			{
+				foreach ( var tag in requiredKv )
+					SteamUGC.Internal.AddRequiredKeyValueTag( handle, tag.Key, tag.Value );
+			}
+
+			if ( matchAnyTag.HasValue )
+			{
+				SteamUGC.Internal.SetMatchAnyTag( handle, matchAnyTag.Value );
+			}
+		}
+
+		#endregion
+
+	}
+}

Facepunch.Steamworks/Structs/UgcQueryUser.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Steamworks.Data;
+using QueryType = Steamworks.Ugc.UserQuery;
+
+namespace Steamworks.Ugc
+{
+	public struct UserQuery
+	{
+		public UserQuery( UgcType type, SteamId steamid = default ) : this()
+		{
+			if ( steamid == 0 )
+				steamid = SteamClient.SteamId;
+
+			this.steamid = steamid;
+			this.matchingType = type;
+		}
+
+		SteamId steamid;
+
+		UserUGCList userType;
+		UserUGCListSortOrder userSort;
+		UgcType matchingType;
+
+		AppId consumerApp;
+		AppId creatorApp;
+
+		public static UserQuery All => new UserQuery( UgcType.All, 0 );
+		public static UserQuery Items => new UserQuery( UgcType.Items, 0 );
+		/*
+		public static UserQuery ItemsMtx( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.Items_Mtx };
+		public static UserQuery ItemsReadyToUse( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.Items_ReadyToUse };
+		public static UserQuery Collections( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.Collections };
+		public static UserQuery Artwork( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.Artwork };
+		public static UserQuery Videos( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.Videos };
+		public static UserQuery Screenshots( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.Screenshots };
+		public static UserQuery AllGuides( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.AllGuides };
+		public static UserQuery WebGuides( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.WebGuides };
+		public static UserQuery IntegratedGuides( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.IntegratedGuides };
+		public static UserQuery UsableInGame( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.UsableInGame };
+		public static UserQuery ControllerBindings( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.ControllerBindings };
+		public static UserQuery GameManagedItems( SteamId steamid = default ) => new UserQuery( steamid ) { matchingType = UGCMatchingUGCType.GameManagedItems };
+		*/
+
+		public UserQuery SortByCreationDate() { userSort = UserUGCListSortOrder.CreationOrderDesc; return this; }
+		public UserQuery SortByCreationDateAsc() { userSort = UserUGCListSortOrder.CreationOrderAsc; return this; }
+		public UserQuery SortByTitleAsc() { userSort = UserUGCListSortOrder.TitleAsc; return this; }
+		public UserQuery SortByUpdateDate() { userSort = UserUGCListSortOrder.LastUpdatedDesc; return this; }
+		public UserQuery SortBySubscriptionDate() { userSort = UserUGCListSortOrder.SubscriptionDateDesc; return this; }
+		public UserQuery SortByVoteScore() { userSort = UserUGCListSortOrder.VoteScoreDesc; return this; }
+		public UserQuery SortByModeration() { userSort = UserUGCListSortOrder.ForModeration; return this; }
+
+
+		public UserQuery GetPublished() { userType = UserUGCList.Published; return this; }
+
+		public UserQuery FromUser( SteamId steamid )
+		{
+			this.steamid = steamid;
+			return this;
+		}
+
+		public UserQuery FromSelf()
+		{
+			this.steamid = SteamClient.SteamId;
+			return this;
+		}
+
+
+		public async Task<ResultPage?> GetPageAsync( int page )
+		{
+			if ( page <= 0 ) throw new System.Exception( "page should be > 0" );
+
+			if ( consumerApp == 0 ) consumerApp = SteamClient.AppId;
+			if ( creatorApp == 0 ) creatorApp = consumerApp;
+
+			UGCQueryHandle_t handle;
+
+			handle = SteamUGC.Internal.CreateQueryUserUGCRequest( steamid.AccountId, userType, matchingType, userSort, creatorApp.Value, consumerApp.Value, (uint)page );
+
+			ApplyConstraints( handle );
+
+			var result = await SteamUGC.Internal.SendQueryUGCRequest( handle );
+			if ( !result.HasValue )
+				return null;
+
+			if ( result.Value.Result != Steamworks.Result.OK )
+				return null;
+
+			return new ResultPage
+			{
+				Handle = result.Value.Handle,
+				ResultCount = (int) result.Value.NumResultsReturned,
+				TotalCount = (int)result.Value.TotalMatchingResults,
+				CachedData = result.Value.CachedData
+			};
+		}
+
+		#region SharedConstraints
+		public QueryType WithType( UgcType type ) { matchingType = type; return this; }
+		bool? WantsReturnOnlyIDs;
+		public QueryType WithOnlyIDs( bool b ) { WantsReturnOnlyIDs = b; return this; }
+		bool? WantsReturnKeyValueTags;
+		public QueryType WithKeyValueTag( bool b ) { WantsReturnKeyValueTags = b; return this; }
+		bool? WantsReturnLongDescription;
+		public QueryType WithLongDescription( bool b ) { WantsReturnLongDescription = b; return this; }
+		bool? WantsReturnMetadata;
+		public QueryType WithMetadata( bool b ) { WantsReturnMetadata = b; return this; }
+		bool? WantsReturnChildren;
+		public QueryType WithChildren( bool b ) { WantsReturnChildren = b; return this; }
+		bool? WantsReturnAdditionalPreviews;
+		public QueryType WithAdditionalPreviews( bool b ) { WantsReturnAdditionalPreviews = b; return this; }
+		bool? WantsReturnTotalOnly;
+		public QueryType WithTotalOnly( bool b ) { WantsReturnTotalOnly = b; return this; }
+		bool? WantsReturnPlaytimeStats;
+		public QueryType WithPlaytimeStats( bool b ) { WantsReturnPlaytimeStats = b; return this; }
+		int? maxCacheAge;
+		public QueryType AllowCachedResponse( int maxSecondsAge ) { maxCacheAge = maxSecondsAge; return this; }
+		string language;
+		public QueryType InLanguage( string lang ) { language = lang; return this; }
+
+		List<string> requiredTags;
+		bool? matchAnyTag;
+		List<string> excludedTags;
+		Dictionary<string, string> requiredKv;
+
+		/// <summary>
+		/// Found items must have at least one of the defined tags
+		/// </summary>
+		public QueryType MatchAnyTag() { matchAnyTag = true; return this; }
+
+		/// <summary>
+		/// Found items must have all defined tags
+		/// </summary>
+		public QueryType MatchAllTags() { matchAnyTag = false; return this; }
+
+		public QueryType WithTag( string tag )
+		{
+			if ( requiredTags == null ) requiredTags = new List<string>();
+			requiredTags.Add( tag );
+			return this;
+		}
+
+		public QueryType WithoutTag( string tag )
+		{
+			if ( excludedTags == null ) excludedTags = new List<string>();
+			excludedTags.Add( tag );
+			return this;
+		}
+
+		void ApplyConstraints( UGCQueryHandle_t handle )
+		{
+			if ( requiredTags != null )
+			{
+				foreach ( var tag in requiredTags )
+					SteamUGC.Internal.AddRequiredTag( handle, tag );
+			}
+
+			if ( excludedTags != null )
+			{
+				foreach ( var tag in excludedTags )
+					SteamUGC.Internal.AddExcludedTag( handle, tag );
+			}
+
+			if ( requiredKv != null )
+			{
+				foreach ( var tag in requiredKv )
+					SteamUGC.Internal.AddRequiredKeyValueTag( handle, tag.Key, tag.Value );
+			}
+
+			if ( matchAnyTag.HasValue )
+			{
+				SteamUGC.Internal.SetMatchAnyTag( handle, matchAnyTag.Value );
+			}
+		}
+
+		#endregion
+
+	}
+}

Facepunch.Steamworks/Structs/UgcResultPage.cs

@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using Steamworks.Data;
+
+namespace Steamworks.Ugc
+{
+	public struct ResultPage : System.IDisposable
+	{
+		internal UGCQueryHandle_t Handle;
+
+		public int ResultCount;
+		public int TotalCount;
+
+		public bool CachedData;
+
+		public IEnumerable<Item> Entries
+		{
+			get
+			{
+				var details = default( SteamUGCDetails_t );
+				for ( uint i=0; i< ResultCount; i++ )
+				{
+					if ( SteamUGC.Internal.GetQueryUGCResult( Handle, i, ref details ) )
+					{
+						yield return Item.From( details );
+					}
+				}
+			}
+		}
+
+		public void Dispose()
+		{
+			if ( Handle > 0 )
+			{
+				SteamUGC.Internal.ReleaseQueryUGCRequest( Handle );
+				Handle = 0;
+			}
+		}
+	}
+}

Generator/Cleanup.cs

@@ -18,9 +18,11 @@ public static string ConvertType( string type )
 		type = type.Replace( "FriendRelationship", "Relationship" );
 		type = type.Replace( "BeginAuthSessionResult", "BeginAuthResult" );
 		type = type.Replace( "PublishedFileId_t", "PublishedFileId" );
-		
+		type = type.Replace( "PublishedFileId_t", "PublishedFileId" );
-
+		type = type.Replace( "AppId_t", "AppId" );
-		
+		type = type.Replace( "LeaderboardSortMethod", "LeaderboardSort" );
+		type = type.Replace( "LeaderboardDisplayType", "LeaderboardDisplay" );
+		type = type.Replace( "UGCMatchingUGCType", "UgcType" );
 
 		return type;
 	}
@@ -28,7 +30,9 @@ public static string ConvertType( string type )
 	public static bool ShouldCreate( string type )
 	{
 		if ( type == "SteamId" ) return false;
-
+		if ( type == "LeaderboardSort" ) return false;
+		if ( type == "LeaderboardDisplay" ) return false;
+		if ( type == "AppId" ) return false;
 
 		return true;
 	}
@@ -49,6 +53,7 @@ internal static string Expose( string name )
 		if ( name == "BroadcastUploadResult" ) return "public";
 		if ( name == "PublishedFileId" ) return "public";
 		if ( name == "Result" ) return "public";
+		if ( name == "UgcType" ) return "public";
 
 		return "internal";
 	}

Generator/CodeParser/CodeParser.Class.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text.RegularExpressions;
 
 namespace Generator
@@ -14,6 +15,7 @@ public class Class
 			public class Function
 			{
 				public string Name;
+				public string DuplicateName;
 				public Dictionary<string, string> Arguments = new Dictionary<string, string>();
 
 				public string ReturnType;
@@ -51,24 +53,18 @@ internal Function AddFunction( string funcName, string returnType, string args )
 
 			public void PostProcess()
 			{
-				var LastName = "";
+				var duplicateFunctions = Functions
-				var DuplicateCount = 0;
+											.GroupBy( x => x.Name )
+											.Where( x => x.Count() > 1 );
 
-				for (int i=0; i< Functions.Count; i++ )
+				foreach ( var group in duplicateFunctions )
 				{
-					var ThisName = Functions[i].Name;
+					var g = group.ToArray();
-
+					for ( int i=0; i< g.Count(); i++ )
-					if ( Functions[i].Name == LastName)
 					{
-						DuplicateCount++;
+						g[i].DuplicateName = g[i].Name;
-						Functions[i].Name += $"{DuplicateCount + 1}";
+						g[i].Name = $"{g[i].Name}{i+1}";
 					}
-					else
-					{
-						DuplicateCount = 0;
-					}
-
-					LastName = ThisName;
 				}
 			}
 		}

Generator/CodeParser/ParseClasses.cs

@@ -99,7 +99,7 @@ public void ProcessClass( string fulldef, string classname, string inner )
 					var args = f.Groups[3].Value.Trim();
 					//	Console.WriteLine( $"Function: {funcName} returns {returnType} with args {args}" );
 
-
+					if ( funcName == "RequestUGCDetails" ) lastCallResult = "SteamUGCRequestUGCDetailsResult_t";
 					if ( funcName == "DownloadClanActivityCounts" ) lastCallResult = "DownloadClanActivityCountsResult_t";
 
 					if ( funcName.Contains( ' ' ) || funcName.Contains( '*' ) )
@@ -136,6 +136,7 @@ public string RemoveAnnotations( string str )
 			str = Regex.Replace( str, @"STEAM_OUT_STRUCT\((.+?)\) ", "" );
 			str = Regex.Replace( str, @"STEAM_OUT_ARRAY_COUNT\((.+?)\)", "" );
 			str = Regex.Replace( str, @"STEAM_ARRAY_COUNT_D\((.+?)\)", "" );
+			str = Regex.Replace( str, @"STEAM_OUT_STRING_COUNT\((.+?)\)", "" );
 
 			
 

Generator/CodeWriter/ClassVTable.cs

@@ -57,22 +57,67 @@ public void GenerateVTableClass( string className, string filename )
 
 		void WriteFunctionPointerReader( CodeParser.Class clss )
 		{
+			// TODO - we'll probably have to do this PER platform
+
+			int[] locations = new int[clss.Functions.Count];
+
+			for ( int i = 0; i < clss.Functions.Count; i++ )
+			{
+				locations[i] = i * 8;
+			}
+
+			//
+			// MSVC switches the order in the vtable of overloaded functions
+			// I'm not going to try to try to work out how to order shit
+			// so lets just manually fix shit here
+			//
+			if ( clss.Name == "ISteamUserStats" )
+			{
+				Swap( clss, "GetStat1", "GetStat2", locations );
+				Swap( clss, "SetStat1", "SetStat2", locations );
+				Swap( clss, "GetUserStat1", "GetUserStat2", locations );
+				Swap( clss, "GetGlobalStat1", "GetGlobalStat2", locations );
+				Swap( clss, "GetGlobalStatHistory1", "GetGlobalStatHistory2", locations );
+			}
+
+			if ( clss.Name == "ISteamUGC" )
+			{
+				Swap( clss, "CreateQueryAllUGCRequest1", "CreateQueryAllUGCRequest2", locations );
+			}
+
+
 			StartBlock( $"public override void InitInternals()" );
 			{
 				for (int i=0; i< clss.Functions.Count; i++ )
 				{
 					var func = clss.Functions[i];
-					WriteLine( $"{func.Name}DelegatePointer = Marshal.GetDelegateForFunctionPointer<{func.Name}Delegate>( Marshal.ReadIntPtr( VTable, {i*8}) );" ); 
+					WriteLine( $"_{func.Name} = Marshal.GetDelegateForFunctionPointer<F{func.Name}>( Marshal.ReadIntPtr( VTable, {locations[i]}) );" ); 
 				}
 			}
 			EndBlock();
 		}
 
+		private void Swap( CodeParser.Class clss, string v1, string v2, int[] locations )
+		{
+			var a = clss.Functions.IndexOf( clss.Functions.Single( x => x.Name == v1 ) );
+			var b = clss.Functions.IndexOf( clss.Functions.Single( x => x.Name == v2 ) );
+
+			var s = locations[a];
+			locations[a] = locations[b];
+			locations[b] = s;
+		}
+
 		private void WriteFunction( CodeParser.Class clss, CodeParser.Class.Function func )
 		{
 			var returnType = BaseType.Parse( func.ReturnType );
+			returnType.Func = func.Name;
 
-			var args = func.Arguments.Select( x => BaseType.Parse( x.Value, x.Key ) ).ToArray();
+			var args = func.Arguments.Select( x =>
+			{
+				var bt = BaseType.Parse( x.Value, x.Key );
+				bt.Func = func.Name;
+				return bt;
+			} ).ToArray();
 			var argstr = string.Join( ", ", args.Select( x => x.AsArgument() ) );
 			var delegateargstr = string.Join( ", ", args.Select( x => x.AsArgument() ) );
 
@@ -94,8 +139,8 @@ private void WriteFunction( CodeParser.Class clss, CodeParser.Class.Function fun
 			if ( returnType.ReturnAttribute != null)
 				WriteLine( returnType.ReturnAttribute );
 
-			WriteLine( $"private delegate {(returnType.IsReturnedWeird?"void":returnType.TypeNameFrom)} {func.Name}Delegate( IntPtr self, {delegateargstr} );".Replace( "( IntPtr self,  )", "( IntPtr self )" ) );
+			WriteLine( $"private delegate {(returnType.IsReturnedWeird?"void":returnType.TypeNameFrom)} F{func.Name}( IntPtr self, {delegateargstr} );".Replace( "( IntPtr self,  )", "( IntPtr self )" ) );
-			WriteLine( $"private {func.Name}Delegate {func.Name}DelegatePointer;" );
+			WriteLine( $"private F{func.Name} _{func.Name};" );
 			WriteLine();
 			WriteLine( $"#endregion" );
 
@@ -106,16 +151,16 @@ private void WriteFunction( CodeParser.Class clss, CodeParser.Class.Function fun
 				if ( returnType.IsReturnedWeird )
 				{
 					WriteLine( $"var retVal = default( {returnType.TypeName} );" );
-					WriteLine( $"{func.Name}DelegatePointer( Self, ref retVal, {callargs} );".Replace( ",  );", " );" ) );
+					WriteLine( $"_{func.Name}( Self, ref retVal, {callargs} );".Replace( ",  );", " );" ) );
 					WriteLine( $"{returnType.Return( "retVal" )}" );
 				}
 				else if ( returnType.IsVoid )
 				{
-					WriteLine( $"{func.Name}DelegatePointer( Self, {callargs} );".Replace( "( Self,  )", "( Self )" ) );
+					WriteLine( $"_{func.Name}( Self, {callargs} );".Replace( "( Self,  )", "( Self )" ) );
 				}
 				else
 				{
-					var v = $"{func.Name}DelegatePointer( Self, {callargs} )".Replace( "( Self,  )", "( Self )" );
+					var v = $"_{func.Name}( Self, {callargs} )".Replace( "( Self,  )", "( Self )" );
 
 					WriteLine( returnType.Return( v ) );
 				}

Generator/CodeWriter/CodeWriter.cs

@@ -68,6 +68,7 @@ public void ToFolder( string folder )
 				GenerateVTableClass( "ISteamGameServer", $"{folder}../Generated/Interfaces/ISteamGameServer.cs" );
 				GenerateVTableClass( "ISteamScreenshots", $"{folder}../Generated/Interfaces/ISteamScreenshots.cs" );
 				GenerateVTableClass( "ISteamUserStats", $"{folder}../Generated/Interfaces/ISteamUserStats.cs" );
+				GenerateVTableClass( "ISteamUGC", $"{folder}../Generated/Interfaces/ISteamUGC.cs" );
 			}
 		}
 

Generator/CodeWriter/Enums.cs

@@ -27,6 +27,9 @@ private void Enums()
 
 				name = Cleanup.ConvertType( name );
 
+				if ( !Cleanup.ShouldCreate( name ) )
+					continue;
+
                 StartBlock( $"{Cleanup.Expose( name )} enum {name} : int" );
                 {
                     //

Generator/CodeWriter/Struct.cs

@@ -229,10 +229,10 @@ private void StructFields( SteamApiDefinition.StructDef.StructFields[] fields )
                     t = "IntPtr";
                 }
 
-                if (t.StartsWith("AppId_t ") && t.Contains("["))
+                if (t.StartsWith("AppId ") && t.Contains("["))
                 {
-                    var num = t.Replace("AppId_t", "").Trim('[', ']', ' ');
+                    var num = t.Replace("AppId", "").Trim('[', ']', ' ');
-                    t = $"AppId_t[]";
+                    t = $"AppId[]";
                     WriteLine($"[MarshalAs(UnmanagedType.ByValArray, SizeConst = {num}, ArraySubType = UnmanagedType.U4)]");
                 }
 

Generator/CodeWriter/Types.cs

@@ -39,6 +39,9 @@ private void Types()
             {
 				var typeName = Cleanup.ConvertType( o.Name );
 
+				if ( !Cleanup.ShouldCreate( typeName ) )
+					continue;
+
 				if ( SkipTypes.Contains( o.Name ) )
                     continue;
 

Generator/CodeWriter/Types/BaseType.cs

@@ -11,6 +11,8 @@ internal class BaseType
 	public virtual string TypeName => $"{NativeType}";
 	public virtual string TypeNameFrom => TypeName;
 
+	public string Func;
+
 	public static BaseType Parse( string type, string varname = null )
 	{
 		type = Cleanup.ConvertType( type );
@@ -62,6 +64,8 @@ public virtual bool IsVector
 			if ( VarName == "psteamIDClans" ) return true;
 			if ( VarName == "pScoreDetails" ) return true;
 			if ( VarName == "prgUsers" ) return true;
+			if ( VarName == "pDetails" && Func == "GetDownloadedLeaderboardEntry" ) return true;
+			if ( VarName == "pData" && NativeType.EndsWith( "*" ) && Func.StartsWith( "GetGlobalStatHistory" ) ) return true;
 			if ( NativeType.EndsWith( "**" ) ) return true;
 
 			if ( NativeType.EndsWith( "*" ) )

README.md

@@ -17,12 +17,22 @@ C# is meant to make things easier. So lets try to wrap it up in a way that makes
 
 ## What
 
-So say you want to print a list of your friends?
+### Get your own information
 
 ```csharp
-foreach ( var friend in client.Friends.All )
+SteamClient.SteamId // Your SteamId
+SteamClient.Name // Your Name
+```
+
+### View your friends list
+
+```csharp
+foreach ( var friend in SteamFriends.GetFriends() )
 {
-    Console.WriteLine( "{0}: {1}", friend.Id, friend.Name );
+    Console.WriteLine( "{friend.Id}: {friend.Name}" );
+    Console.WriteLine( "{friend.IsOnline} / {friend.SteamLevel}" );
+    
+    friend.SendMessage( "Hello Friend" );
 }
 ```
 
@@ -31,89 +41,174 @@ But what if you want to get a list of friends playing the same game that we're p
 ```csharp
 foreach ( var friend in client.Friends.All.Where( x => x.IsPlayingThisGame ) )
 {
-    Console.WriteLine( "{0}: {1}", friend.Id, friend.Name );
+    // 
 }
 ```
 
-You can view examples of everything in the Facepunch.Steamworks.Test project.
+### App Info
+
+```csharp
+Console.WriteLine( SteamApps.GameLanguage ); // Print the current game language
+var installDir = SteamApps.AppInstallDir( 4000 ); // Get the path to the Garry's Mod install folder
+
+var fileinfo = await SteamApps.GetFileDetailsAsync( "hl2.exe" ); // async get file details
+DoSomething( fileinfo.SizeInBytes, fileinfo.Sha1 );
+```
+
+### Get Avatars
+
+```csharp
+var image = await SteamFriends.GetLargeAvatarAsync( steamid );
+if ( !image.HasValue ) return DefaultImage;
+
+return MakeTextureFromRGBA( image.Data, image.Width, image.Height );
+```
+
+### Get a list of servers
+
+```csharp
+using ( var list = new ServerList.Internet() )
+{
+    list.AddFilter( "map", "de_dust" );
+    await list.RunQueryAsync();
+
+    foreach ( var server in list.Responsive )
+    {
+        Console.WriteLine( $"{server.Address} {server.Name}" );
+    }
+}
+```
+
+### Achievements
+
+List them
+
+```csharp
+foreach ( var a in SteamUserStats.Achievements )
+{
+    Console.WriteLine( $"{a.Name} ({a.State}})" );
+}	
+```
+
+Unlock them
+
+```csharp
+var ach = new Achievement( "GM_PLAYED_WITH_GARRY" );
+ach.Trigger();
+```
+
+### Voice
+
+```csharp
+
+SteamUser.VoiceRecord = KeyDown( "V" );
+
+if ( SteamUser.HasVoiceData )
+{
+    var bytesrwritten = SteamUser.ReadVoiceData( stream );
+    // Send Stream Data To Server or Something
+}
+
+```
+
+
+### Auth
+
+```csharp
+
+// Client sends ticket data to server somehow
+var ticket = SteamUser.GetAuthSessionTicket();
+
+
+// server listens to event
+SteamServer.OnValidateAuthTicketResponse += ( steamid, ownerid, rsponse ) =>
+{
+    if ( rsponse == AuthResponse.OK )
+        TellUserTheyCanBeOnServer( steamid );
+    else
+        KickUser( steamid );
+};
+
+// server gets ticket data from client, calls this function.. which either returns
+// false straight away, or will issue a TicketResponse.
+if ( !SteamServer.BeginAuthSession( ticketData, clientSteamId ) )
+{
+    KickUser( clientSteamId );
+}
+
+//
+// Client is leaving, cancels their ticket OnValidateAuth is called on the server again
+// this time with AuthResponse.AuthTicketCanceled
+//
+ticket.Cancel();
+
+```
+
+### Utils
+
+```csharp
+SteamUtils.SecondsSinceAppActive;
+SteamUtils.SecondsSinceComputerActive;
+SteamUtils.IpCountry;
+SteamUtils.UsingBatteryPower;
+SteamUtils.CurrentBatteryPower;
+SteamUtils.AppId;
+SteamUtils.IsOverlayEnabled;
+SteamUtils.IsSteamRunningInVR;
+SteamUtils.IsSteamInBigPictureMode;
+```
 
 # Usage
 
 ## Client
 
-Compile the Facepunch.Steamworks project and add the library to your Unity project. To create a client you can do this.
+To initialize a client you can do this.
 
 ```csharp
-var client = new Facepunch.Steamworks.Client( 252490 );
+using Steamworks;
+
+// ...
+
+try 
+{
+    SteamClient.Init( 4000 );
+}
+catch ( System.Exception e )
+{
+    // Couldn't init for some reason (steam is closed etc)
+}
 ```
 
-Replace 252490 with the appid of your game. This should be a singleton - you should only create one client, right at the start of your game.
+Replace 4000 with the appid of your game. You shouldn't call any Steam functions before you initialize.
 
-The client is disposable, so when you're closing your game should probably call..
+When you're done, when you're closing your game, just shutdown.
 
 ```csharp
-client.Dispose();
+SteamClient.Shutdown();
 ```
 
-Or use it in a using block if you can.
-
-
 ## Server
 
 To create a server do this.
 
 ```csharp
-ServerInit options = new ServerInit("GameDirectoryName", "GameDescription");
+var serverInit = new SteamServerInit( "gmod", "Garry Mode" )
-```
-
-```csharp
-var server = new Facepunch.Steamworks.Server(252490, options);
-```
-
-This will register a secure server for game 252490, any ip, port 28015. Again, more usage in the Facepunch.Steamworks.Test project.
-
-## Lobby
-
-To create a Lobby do this.
-```csharp
-client.Lobby.Create(Steamworks.Lobby.Type.Public, 10);
-```
-
-Created lobbies are auto-joined, but if you want to find a friend's lobby, you'd call
-```csharp
-client.LobbyList.Refresh();
-//wait for the callback
-client.LobbyList.OnLobbiesUpdated = () =>
 {
-    if (client.LobbyList.Finished)
+    GamePort = 28015,
-    {
+    Secure = true,
-        foreach (LobbyList.Lobby lobby in client.LobbyList.Lobbies)
+    QueryPort = 28016
-        {
-            Console.WriteLine($"Found Lobby: {lobby.Name}");
-        }
-    }
 };
-//join a lobby you found
+
-client.Lobby.Join(LobbyList.Lobbies[0]);
+try
+{
+    Steamworks.SteamServer.Init( 4000, serverInit );
+}
+catch ( System.Exception )
+{
+    // Couldn't init for some reason (dll errors, blocked ports)
+}
 ```
 
-Your can find more examples of Lobby functionality in the Lobby.cs file in the test project. Sending chat messages, assinging lobby data and member data, etc.
-
-
-# Unity
-
-Yeah this works under Unity. That's half the point of it.
-
-There's another repo with an example project with it working in Unity. You can find it [here](https://github.com/Facepunch/Facepunch.Steamworks.Unity/blob/master/Assets/Scripts/SteamTest.cs).
-
-The TLDR is before you create the Client or the Server, call this to let Facepunch.Steamworks know which platform we're on - because it can't tell the difference between osx and linux by itself.
-
-```csharp
-Facepunch.Steamworks.Config.ForUnity( Application.platform.ToString() );
-```
-
-You'll also want to put steam_api64.dll and steam_appid.txt (on windows 64) in your project root next to Assets, and use an editor script like [this](https://github.com/Facepunch/Facepunch.Steamworks.Unity/blob/master/Assets/Scripts/Editor/CopySteamLibraries.cs) to copy them into standalone builds.
-
 # Help
 
 Wanna help? Go for it, pull requests, bug reports, yes, do it.