using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Steamworks.Data;
using Steamworks.Ugc;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyCompany("Garry Newman")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Facepunch.Steamworks.Win64")]
[assembly: AssemblyTitle("Facepunch.Steamworks.Win64")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace Steamworks
{
	internal struct CallResult<T> : INotifyCompletion where T : struct, ICallbackData
	{
		private SteamAPICall_t call;

		private ISteamUtils utils;

		private bool server;

		public bool IsCompleted
		{
			get
			{
				bool pbFailed = false;
				if (utils.IsAPICallCompleted(call, ref pbFailed) || pbFailed)
				{
					return true;
				}
				return false;
			}
		}

		public CallResult(SteamAPICall_t call, bool server)
		{
			this.call = call;
			this.server = server;
			utils = (server ? SteamSharedClass<SteamUtils>.InterfaceServer : SteamSharedClass<SteamUtils>.InterfaceClient) as ISteamUtils;
			if (utils == null)
			{
				utils = SteamSharedClass<SteamUtils>.Interface as ISteamUtils;
			}
		}

		public void OnCompleted(Action continuation)
		{
			Dispatch.OnCallComplete<T>(call, continuation, server);
		}

		public T? GetResult()
		{
			bool pbFailed = false;
			if (!utils.IsAPICallCompleted(call, ref pbFailed) || pbFailed)
			{
				return null;
			}
			T val = default(T);
			int dataSize = val.DataSize;
			IntPtr intPtr = Marshal.AllocHGlobal(dataSize);
			try
			{
				if (!utils.GetAPICallResult(call, intPtr, dataSize, (int)val.CallbackType, ref pbFailed) || pbFailed)
				{
					Dispatch.OnDebugCallback?.Invoke(val.CallbackType, "!GetAPICallResult or failed", server);
					return null;
				}
				Dispatch.OnDebugCallback?.Invoke(val.CallbackType, Dispatch.CallbackToString(val.CallbackType, intPtr, dataSize), server);
				return (T)Marshal.PtrToStructure(intPtr, typeof(T));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		internal CallResult<T> GetAwaiter()
		{
			return this;
		}
	}
	internal interface ICallbackData
	{
		CallbackType CallbackType { get; }

		int DataSize { get; }
	}
	public class AuthTicket : IDisposable
	{
		public byte[] Data;

		public uint Handle;

		public void Cancel()
		{
			if (Handle != 0)
			{
				SteamUser.Internal.CancelAuthTicket(Handle);
			}
			Handle = 0u;
			Data = null;
		}

		public void Dispose()
		{
			Cancel();
		}
	}
	public static class Dispatch
	{
		[StructLayout(LayoutKind.Sequential, Pack = 8)]
		internal struct CallbackMsg_t
		{
			public HSteamUser m_hSteamUser;

			public CallbackType Type;

			public IntPtr Data;

			public int DataSize;
		}

		private struct ResultCallback
		{
			public Action continuation;

			public bool server;
		}

		private struct Callback
		{
			public Action<IntPtr> action;

			public bool server;
		}

		public static Action<CallbackType, string, bool> OnDebugCallback;

		public static Action<Exception> OnException;

		private static bool runningFrame = false;

		private static List<Action<IntPtr>> actionsToCall = new List<Action<IntPtr>>();

		private static Dictionary<ulong, ResultCallback> ResultCallbacks = new Dictionary<ulong, ResultCallback>();

		private static Dictionary<CallbackType, List<Callback>> Callbacks = new Dictionary<CallbackType, List<Callback>>();

		internal static HSteamPipe ClientPipe { get; set; }

		internal static HSteamPipe ServerPipe { get; set; }

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern void SteamAPI_ManualDispatch_Init();

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern void SteamAPI_ManualDispatch_RunFrame(HSteamPipe pipe);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool SteamAPI_ManualDispatch_GetNextCallback(HSteamPipe pipe, [In][Out] ref CallbackMsg_t msg);

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		[return: MarshalAs(UnmanagedType.I1)]
		internal static extern bool SteamAPI_ManualDispatch_FreeLastCallback(HSteamPipe pipe);

		internal static void Init()
		{
			SteamAPI_ManualDispatch_Init();
		}

		internal static void Frame(HSteamPipe pipe)
		{
			if (runningFrame)
			{
				return;
			}
			try
			{
				runningFrame = true;
				SteamAPI_ManualDispatch_RunFrame(pipe);
				SteamNetworkingUtils.OutputDebugMessages();
				CallbackMsg_t msg = default(CallbackMsg_t);
				while (SteamAPI_ManualDispatch_GetNextCallback(pipe, ref msg))
				{
					try
					{
						ProcessCallback(msg, pipe == ServerPipe);
					}
					finally
					{
						SteamAPI_ManualDispatch_FreeLastCallback(pipe);
					}
				}
			}
			catch (Exception obj)
			{
				OnException?.Invoke(obj);
			}
			finally
			{
				runningFrame = false;
			}
		}

		private static void ProcessCallback(CallbackMsg_t msg, bool isServer)
		{
			OnDebugCallback?.Invoke(msg.Type, CallbackToString(msg.Type, msg.Data, msg.DataSize), isServer);
			if (msg.Type == CallbackType.SteamAPICallCompleted)
			{
				ProcessResult(msg);
			}
			else
			{
				if (!Callbacks.TryGetValue(msg.Type, out var value))
				{
					return;
				}
				actionsToCall.Clear();
				foreach (Callback item in value)
				{
					if (item.server == isServer)
					{
						actionsToCall.Add(item.action);
					}
				}
				foreach (Action<IntPtr> item2 in actionsToCall)
				{
					item2(msg.Data);
				}
				actionsToCall.Clear();
			}
		}

		internal static string CallbackToString(CallbackType type, IntPtr data, int expectedsize)
		{
			if (!CallbackTypeFactory.All.TryGetValue(type, out var value))
			{
				return $"[{type} not in sdk]";
			}
			object obj = data.ToType(value);
			if (obj == null)
			{
				return "[null]";
			}
			string text = "";
			FieldInfo[] fields = value.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (fields.Length == 0)
			{
				return "[no fields]";
			}
			int num = fields.Max((FieldInfo x) => x.Name.Length) + 1;
			if (num < 10)
			{
				num = 10;
			}
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				int num2 = num - fieldInfo.Name.Length;
				if (num2 < 0)
				{
					num2 = 0;
				}
				text += $"{new string(' ', num2)}{fieldInfo.Name}: {fieldInfo.GetValue(obj)}\n";
			}
			return text.Trim(new char[1] { '\n' });
		}

		private static void ProcessResult(CallbackMsg_t msg)
		{
			SteamAPICallCompleted_t steamAPICallCompleted_t = msg.Data.ToType<SteamAPICallCompleted_t>();
			if (!ResultCallbacks.TryGetValue(steamAPICallCompleted_t.AsyncCall, out var value))
			{
				OnDebugCallback?.Invoke((CallbackType)steamAPICallCompleted_t.Callback, "[no callback waiting/required]", arg3: false);
				return;
			}
			ResultCallbacks.Remove(steamAPICallCompleted_t.AsyncCall);
			value.continuation();
		}

		internal static async void LoopClientAsync()
		{
			while (ClientPipe != 0)
			{
				Frame(ClientPipe);
				await Task.Delay(16);
			}
		}

		internal static async void LoopServerAsync()
		{
			while (ServerPipe != 0)
			{
				Frame(ServerPipe);
				await Task.Delay(32);
			}
		}

		internal static void OnCallComplete<T>(SteamAPICall_t call, Action continuation, bool server) where T : struct, ICallbackData
		{
			ResultCallbacks[call.Value] = new ResultCallback
			{
				continuation = continuation,
				server = server
			};
		}

		internal static void Install<T>(Action<T> p, bool server = false) where T : ICallbackData
		{
			CallbackType callbackType = default(T).CallbackType;
			if (!Callbacks.TryGetValue(callbackType, out var value))
			{
				value = new List<Callback>();
				Callbacks[callbackType] = value;
			}
			value.Add(new Callback
			{
				action = delegate(IntPtr x)
				{
					p(x.ToType<T>());
				},
				server = server
			});
		}

		internal static void ShutdownServer()
		{
			ServerPipe = 0;
			foreach (KeyValuePair<CallbackType, List<Callback>> callback in Callbacks)
			{
				Callbacks[callback.Key].RemoveAll((Callback x) => x.server);
			}
			ResultCallbacks = ResultCallbacks.Where((KeyValuePair<ulong, ResultCallback> x) => !x.Value.server).ToDictionary((KeyValuePair<ulong, ResultCallback> x) => x.Key, (KeyValuePair<ulong, ResultCallback> x) => x.Value);
		}

		internal static void ShutdownClient()
		{
			ClientPipe = 0;
			foreach (KeyValuePair<CallbackType, List<Callback>> callback in Callbacks)
			{
				Callbacks[callback.Key].RemoveAll((Callback x) => !x.server);
			}
			ResultCallbacks = ResultCallbacks.Where((KeyValuePair<ulong, ResultCallback> x) => x.Value.server).ToDictionary((KeyValuePair<ulong, ResultCallback> x) => x.Key, (KeyValuePair<ulong, ResultCallback> x) => x.Value);
		}
	}
	internal static class SteamAPI
	{
		internal static class Native
		{
			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			[return: MarshalAs(UnmanagedType.I1)]
			public static extern bool SteamAPI_Init();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern void SteamAPI_Shutdown();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern HSteamPipe SteamAPI_GetHSteamPipe();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			[return: MarshalAs(UnmanagedType.I1)]
			public static extern bool SteamAPI_RestartAppIfNecessary(uint unOwnAppID);
		}

		internal static bool Init()
		{
			return Native.SteamAPI_Init();
		}

		internal static void Shutdown()
		{
			Native.SteamAPI_Shutdown();
		}

		internal static HSteamPipe GetHSteamPipe()
		{
			return Native.SteamAPI_GetHSteamPipe();
		}

		internal static bool RestartAppIfNecessary(uint unOwnAppID)
		{
			return Native.SteamAPI_RestartAppIfNecessary(unOwnAppID);
		}
	}
	internal static class SteamGameServer
	{
		internal static class Native
		{
			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern void SteamGameServer_RunCallbacks();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern void SteamGameServer_Shutdown();

			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			public static extern HSteamPipe SteamGameServer_GetHSteamPipe();
		}

		internal static void RunCallbacks()
		{
			Native.SteamGameServer_RunCallbacks();
		}

		internal static void Shutdown()
		{
			Native.SteamGameServer_Shutdown();
		}

		internal static HSteamPipe GetHSteamPipe()
		{
			return Native.SteamGameServer_GetHSteamPipe();
		}
	}
	internal static class SteamInternal
	{
		internal static class Native
		{
			[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
			[return: MarshalAs(UnmanagedType.I1)]
			public static extern bool SteamInternal_GameServer_Init(uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersionString);
		}

		internal static bool GameServer_Init(uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersionString)
		{
			return Native.SteamInternal_GameServer_Init(unIP, usPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
		}
	}
	public enum CallbackType
	{
		SteamServersConnected = 101,
		SteamServerConnectFailure = 102,
		SteamServersDisconnected = 103,
		ClientGameServerDeny = 113,
		GSPolicyResponse = 115,
		IPCFailure = 117,
		LicensesUpdated = 125,
		ValidateAuthTicketResponse = 143,
		MicroTxnAuthorizationResponse = 152,
		EncryptedAppTicketResponse = 154,
		GetAuthSessionTicketResponse = 163,
		GameWebCallback = 164,
		StoreAuthURLResponse = 165,
		MarketEligibilityResponse = 166,
		DurationControl = 167,
		GSClientApprove = 201,
		GSClientDeny = 202,
		GSClientKick = 203,
		GSClientAchievementStatus = 206,
		GSGameplayStats = 207,
		GSClientGroupStatus = 208,
		GSReputation = 209,
		AssociateWithClanResult = 210,
		ComputeNewPlayerCompatibilityResult = 211,
		PersonaStateChange = 304,
		GameOverlayActivated = 331,
		GameServerChangeRequested = 332,
		GameLobbyJoinRequested = 333,
		AvatarImageLoaded = 334,
		ClanOfficerListResponse = 335,
		FriendRichPresenceUpdate = 336,
		GameRichPresenceJoinRequested = 337,
		GameConnectedClanChatMsg = 338,
		GameConnectedChatJoin = 339,
		GameConnectedChatLeave = 340,
		DownloadClanActivityCountsResult = 341,
		JoinClanChatRoomCompletionResult = 342,
		GameConnectedFriendChatMsg = 343,
		FriendsGetFollowerCount = 344,
		FriendsIsFollowing = 345,
		FriendsEnumerateFollowingList = 346,
		SetPersonaNameResponse = 347,
		UnreadChatMessagesChanged = 348,
		FavoritesListChanged = 502,
		LobbyInvite = 503,
		LobbyEnter = 504,
		LobbyDataUpdate = 505,
		LobbyChatUpdate = 506,
		LobbyChatMsg = 507,
		LobbyGameCreated = 509,
		LobbyMatchList = 510,
		LobbyKicked = 512,
		LobbyCreated = 513,
		PSNGameBootInviteResult = 515,
		FavoritesListAccountsUpdated = 516,
		IPCountry = 701,
		LowBatteryPower = 702,
		SteamAPICallCompleted = 703,
		SteamShutdown = 704,
		CheckFileSignature = 705,
		GamepadTextInputDismissed = 714,
		DlcInstalled = 1005,
		RegisterActivationCodeResponse = 1008,
		NewUrlLaunchParameters = 1014,
		AppProofOfPurchaseKeyResponse = 1021,
		FileDetailsResult = 1023,
		UserStatsReceived = 1101,
		UserStatsStored = 1102,
		UserAchievementStored = 1103,
		LeaderboardFindResult = 1104,
		LeaderboardScoresDownloaded = 1105,
		LeaderboardScoreUploaded = 1106,
		NumberOfCurrentPlayers = 1107,
		UserStatsUnloaded = 1108,
		GSStatsUnloaded = 1108,
		UserAchievementIconFetched = 1109,
		GlobalAchievementPercentagesReady = 1110,
		LeaderboardUGCSet = 1111,
		GlobalStatsReceived = 1112,
		P2PSessionRequest = 1202,
		P2PSessionConnectFail = 1203,
		SteamNetConnectionStatusChangedCallback = 1221,
		SteamNetAuthenticationStatus = 1222,
		SteamRelayNetworkStatus = 1281,
		RemoteStorageAppSyncedClient = 1301,
		RemoteStorageAppSyncedServer = 1302,
		RemoteStorageAppSyncProgress = 1303,
		RemoteStorageAppSyncStatusCheck = 1305,
		RemoteStorageFileShareResult = 1307,
		RemoteStoragePublishFileResult = 1309,
		RemoteStorageDeletePublishedFileResult = 1311,
		RemoteStorageEnumerateUserPublishedFilesResult = 1312,
		RemoteStorageSubscribePublishedFileResult = 1313,
		RemoteStorageEnumerateUserSubscribedFilesResult = 1314,
		RemoteStorageUnsubscribePublishedFileResult = 1315,
		RemoteStorageUpdatePublishedFileResult = 1316,
		RemoteStorageDownloadUGCResult = 1317,
		RemoteStorageGetPublishedFileDetailsResult = 1318,
		RemoteStorageEnumerateWorkshopFilesResult = 1319,
		RemoteStorageGetPublishedItemVoteDetailsResult = 1320,
		RemoteStoragePublishedFileSubscribed = 1321,
		RemoteStoragePublishedFileUnsubscribed = 1322,
		RemoteStoragePublishedFileDeleted = 1323,
		RemoteStorageUpdateUserPublishedItemVoteResult = 1324,
		RemoteStorageUserVoteDetails = 1325,
		RemoteStorageEnumerateUserSharedWorkshopFilesResult = 1326,
		RemoteStorageSetUserPublishedFileActionResult = 1327,
		RemoteStorageEnumeratePublishedFilesByUserActionResult = 1328,
		RemoteStoragePublishFileProgress = 1329,
		RemoteStoragePublishedFileUpdated = 1330,
		RemoteStorageFileWriteAsyncComplete = 1331,
		RemoteStorageFileReadAsyncComplete = 1332,
		GSStatsReceived = 1800,
		GSStatsStored = 1801,
		HTTPRequestCompleted = 2101,
		HTTPRequestHeadersReceived = 2102,
		HTTPRequestDataReceived = 2103,
		ScreenshotReady = 2301,
		ScreenshotRequested = 2302,
		SteamUGCQueryCompleted = 3401,
		SteamUGCRequestUGCDetailsResult = 3402,
		CreateItemResult = 3403,
		SubmitItemUpdateResult = 3404,
		ItemInstalled = 3405,
		DownloadItemResult = 3406,
		UserFavoriteItemsListChanged = 3407,
		SetUserItemVoteResult = 3408,
		GetUserItemVoteResult = 3409,
		StartPlaytimeTrackingResult = 3410,
		StopPlaytimeTrackingResult = 3411,
		AddUGCDependencyResult = 3412,
		RemoveUGCDependencyResult = 3413,
		AddAppDependencyResult = 3414,
		RemoveAppDependencyResult = 3415,
		GetAppDependenciesResult = 3416,
		DeleteItemResult = 3417,
		SteamAppInstalled = 3901,
		SteamAppUninstalled = 3902,
		PlaybackStatusHasChanged = 4001,
		VolumeHasChanged = 4002,
		MusicPlayerWantsVolume = 4011,
		MusicPlayerSelectsQueueEntry = 4012,
		MusicPlayerSelectsPlaylistEntry = 4013,
		MusicPlayerRemoteWillActivate = 4101,
		MusicPlayerRemoteWillDeactivate = 4102,
		MusicPlayerRemoteToFront = 4103,
		MusicPlayerWillQuit = 4104,
		MusicPlayerWantsPlay = 4105,
		MusicPlayerWantsPause = 4106,
		MusicPlayerWantsPlayPrevious = 4107,
		MusicPlayerWantsPlayNext = 4108,
		MusicPlayerWantsShuffled = 4109,
		MusicPlayerWantsLooped = 4110,
		MusicPlayerWantsPlayingRepeatStatus = 4114,
		HTML_BrowserReady = 4501,
		HTML_NeedsPaint = 4502,
		HTML_StartRequest = 4503,
		HTML_CloseBrowser = 4504,
		HTML_URLChanged = 4505,
		HTML_FinishedRequest = 4506,
		HTML_OpenLinkInNewTab = 4507,
		HTML_ChangedTitle = 4508,
		HTML_SearchResults = 4509,
		HTML_CanGoBackAndForward = 4510,
		HTML_HorizontalScroll = 4511,
		HTML_VerticalScroll = 4512,
		HTML_LinkAtPosition = 4513,
		HTML_JSAlert = 4514,
		HTML_JSConfirm = 4515,
		HTML_FileOpenDialog = 4516,
		HTML_NewWindow = 4521,
		HTML_SetCursor = 4522,
		HTML_StatusText = 4523,
		HTML_ShowToolTip = 4524,
		HTML_UpdateToolTip = 4525,
		HTML_HideToolTip = 4526,
		HTML_BrowserRestarted = 4527,
		BroadcastUploadStart = 4604,
		BroadcastUploadStop = 4605,
		GetVideoURLResult = 4611,
		GetOPFSettingsResult = 4624,
		SteamInventoryResultReady = 4700,
		SteamInventoryFullUpdate = 4701,
		SteamInventoryDefinitionUpdate = 4702,
		SteamInventoryEligiblePromoItemDefIDs = 4703,
		SteamInventoryStartPurchaseResult = 4704,
		SteamInventoryRequestPricesResult = 4705,
		SteamParentalSettingsChanged = 5001,
		SearchForGameProgressCallback = 5201,
		SearchForGameResultCallback = 5202,
		RequestPlayersForGameProgressCallback = 5211,
		RequestPlayersForGameResultCallback = 5212,
		RequestPlayersForGameFinalResultCallback = 5213,
		SubmitPlayerResultResultCallback = 5214,
		EndGameResultCallback = 5215,
		JoinPartyCallback = 5301,
		CreateBeaconCallback = 5302,
		ReservationNotificationCallback = 5303,
		ChangeNumOpenSlotsCallback = 5304,
		AvailableBeaconLocationsUpdated = 5305,
		ActiveBeaconsUpdated = 5306,
		SteamRemotePlaySessionConnected = 5701,
		SteamRemotePlaySessionDisconnected = 5702
	}
	internal static class CallbackTypeFactory
	{
		internal static Dictionary<CallbackType, Type> All = new Dictionary<CallbackType, Type>
		{
			{
				CallbackType.SteamServersConnected,
				typeof(SteamServersConnected_t)
			},
			{
				CallbackType.SteamServerConnectFailure,
				typeof(SteamServerConnectFailure_t)
			},
			{
				CallbackType.SteamServersDisconnected,
				typeof(SteamServersDisconnected_t)
			},
			{
				CallbackType.ClientGameServerDeny,
				typeof(ClientGameServerDeny_t)
			},
			{
				CallbackType.GSPolicyResponse,
				typeof(GSPolicyResponse_t)
			},
			{
				CallbackType.IPCFailure,
				typeof(IPCFailure_t)
			},
			{
				CallbackType.LicensesUpdated,
				typeof(LicensesUpdated_t)
			},
			{
				CallbackType.ValidateAuthTicketResponse,
				typeof(ValidateAuthTicketResponse_t)
			},
			{
				CallbackType.MicroTxnAuthorizationResponse,
				typeof(MicroTxnAuthorizationResponse_t)
			},
			{
				CallbackType.EncryptedAppTicketResponse,
				typeof(EncryptedAppTicketResponse_t)
			},
			{
				CallbackType.GetAuthSessionTicketResponse,
				typeof(GetAuthSessionTicketResponse_t)
			},
			{
				CallbackType.GameWebCallback,
				typeof(GameWebCallback_t)
			},
			{
				CallbackType.StoreAuthURLResponse,
				typeof(StoreAuthURLResponse_t)
			},
			{
				CallbackType.MarketEligibilityResponse,
				typeof(MarketEligibilityResponse_t)
			},
			{
				CallbackType.DurationControl,
				typeof(DurationControl_t)
			},
			{
				CallbackType.GSClientApprove,
				typeof(GSClientApprove_t)
			},
			{
				CallbackType.GSClientDeny,
				typeof(GSClientDeny_t)
			},
			{
				CallbackType.GSClientKick,
				typeof(GSClientKick_t)
			},
			{
				CallbackType.GSClientAchievementStatus,
				typeof(GSClientAchievementStatus_t)
			},
			{
				CallbackType.GSGameplayStats,
				typeof(GSGameplayStats_t)
			},
			{
				CallbackType.GSClientGroupStatus,
				typeof(GSClientGroupStatus_t)
			},
			{
				CallbackType.GSReputation,
				typeof(GSReputation_t)
			},
			{
				CallbackType.AssociateWithClanResult,
				typeof(AssociateWithClanResult_t)
			},
			{
				CallbackType.ComputeNewPlayerCompatibilityResult,
				typeof(ComputeNewPlayerCompatibilityResult_t)
			},
			{
				CallbackType.PersonaStateChange,
				typeof(PersonaStateChange_t)
			},
			{
				CallbackType.GameOverlayActivated,
				typeof(GameOverlayActivated_t)
			},
			{
				CallbackType.GameServerChangeRequested,
				typeof(GameServerChangeRequested_t)
			},
			{
				CallbackType.GameLobbyJoinRequested,
				typeof(GameLobbyJoinRequested_t)
			},
			{
				CallbackType.AvatarImageLoaded,
				typeof(AvatarImageLoaded_t)
			},
			{
				CallbackType.ClanOfficerListResponse,
				typeof(ClanOfficerListResponse_t)
			},
			{
				CallbackType.FriendRichPresenceUpdate,
				typeof(FriendRichPresenceUpdate_t)
			},
			{
				CallbackType.GameRichPresenceJoinRequested,
				typeof(GameRichPresenceJoinRequested_t)
			},
			{
				CallbackType.GameConnectedClanChatMsg,
				typeof(GameConnectedClanChatMsg_t)
			},
			{
				CallbackType.GameConnectedChatJoin,
				typeof(GameConnectedChatJoin_t)
			},
			{
				CallbackType.GameConnectedChatLeave,
				typeof(GameConnectedChatLeave_t)
			},
			{
				CallbackType.DownloadClanActivityCountsResult,
				typeof(DownloadClanActivityCountsResult_t)
			},
			{
				CallbackType.JoinClanChatRoomCompletionResult,
				typeof(JoinClanChatRoomCompletionResult_t)
			},
			{
				CallbackType.GameConnectedFriendChatMsg,
				typeof(GameConnectedFriendChatMsg_t)
			},
			{
				CallbackType.FriendsGetFollowerCount,
				typeof(FriendsGetFollowerCount_t)
			},
			{
				CallbackType.FriendsIsFollowing,
				typeof(FriendsIsFollowing_t)
			},
			{
				CallbackType.FriendsEnumerateFollowingList,
				typeof(FriendsEnumerateFollowingList_t)
			},
			{
				CallbackType.SetPersonaNameResponse,
				typeof(SetPersonaNameResponse_t)
			},
			{
				CallbackType.UnreadChatMessagesChanged,
				typeof(UnreadChatMessagesChanged_t)
			},
			{
				CallbackType.FavoritesListChanged,
				typeof(FavoritesListChanged_t)
			},
			{
				CallbackType.LobbyInvite,
				typeof(LobbyInvite_t)
			},
			{
				CallbackType.LobbyEnter,
				typeof(LobbyEnter_t)
			},
			{
				CallbackType.LobbyDataUpdate,
				typeof(LobbyDataUpdate_t)
			},
			{
				CallbackType.LobbyChatUpdate,
				typeof(LobbyChatUpdate_t)
			},
			{
				CallbackType.LobbyChatMsg,
				typeof(LobbyChatMsg_t)
			},
			{
				CallbackType.LobbyGameCreated,
				typeof(LobbyGameCreated_t)
			},
			{
				CallbackType.LobbyMatchList,
				typeof(LobbyMatchList_t)
			},
			{
				CallbackType.LobbyKicked,
				typeof(LobbyKicked_t)
			},
			{
				CallbackType.LobbyCreated,
				typeof(LobbyCreated_t)
			},
			{
				CallbackType.PSNGameBootInviteResult,
				typeof(PSNGameBootInviteResult_t)
			},
			{
				CallbackType.FavoritesListAccountsUpdated,
				typeof(FavoritesListAccountsUpdated_t)
			},
			{
				CallbackType.IPCountry,
				typeof(IPCountry_t)
			},
			{
				CallbackType.LowBatteryPower,
				typeof(LowBatteryPower_t)
			},
			{
				CallbackType.SteamAPICallCompleted,
				typeof(SteamAPICallCompleted_t)
			},
			{
				CallbackType.SteamShutdown,
				typeof(SteamShutdown_t)
			},
			{
				CallbackType.CheckFileSignature,
				typeof(CheckFileSignature_t)
			},
			{
				CallbackType.GamepadTextInputDismissed,
				typeof(GamepadTextInputDismissed_t)
			},
			{
				CallbackType.DlcInstalled,
				typeof(DlcInstalled_t)
			},
			{
				CallbackType.RegisterActivationCodeResponse,
				typeof(RegisterActivationCodeResponse_t)
			},
			{
				CallbackType.NewUrlLaunchParameters,
				typeof(NewUrlLaunchParameters_t)
			},
			{
				CallbackType.AppProofOfPurchaseKeyResponse,
				typeof(AppProofOfPurchaseKeyResponse_t)
			},
			{
				CallbackType.FileDetailsResult,
				typeof(FileDetailsResult_t)
			},
			{
				CallbackType.UserStatsReceived,
				typeof(UserStatsReceived_t)
			},
			{
				CallbackType.UserStatsStored,
				typeof(UserStatsStored_t)
			},
			{
				CallbackType.UserAchievementStored,
				typeof(UserAchievementStored_t)
			},
			{
				CallbackType.LeaderboardFindResult,
				typeof(LeaderboardFindResult_t)
			},
			{
				CallbackType.LeaderboardScoresDownloaded,
				typeof(LeaderboardScoresDownloaded_t)
			},
			{
				CallbackType.LeaderboardScoreUploaded,
				typeof(LeaderboardScoreUploaded_t)
			},
			{
				CallbackType.NumberOfCurrentPlayers,
				typeof(NumberOfCurrentPlayers_t)
			},
			{
				CallbackType.UserStatsUnloaded,
				typeof(UserStatsUnloaded_t)
			},
			{
				CallbackType.UserAchievementIconFetched,
				typeof(UserAchievementIconFetched_t)
			},
			{
				CallbackType.GlobalAchievementPercentagesReady,
				typeof(GlobalAchievementPercentagesReady_t)
			},
			{
				CallbackType.LeaderboardUGCSet,
				typeof(LeaderboardUGCSet_t)
			},
			{
				CallbackType.GlobalStatsReceived,
				typeof(GlobalStatsReceived_t)
			},
			{
				CallbackType.P2PSessionRequest,
				typeof(P2PSessionRequest_t)
			},
			{
				CallbackType.P2PSessionConnectFail,
				typeof(P2PSessionConnectFail_t)
			},
			{
				CallbackType.SteamNetConnectionStatusChangedCallback,
				typeof(SteamNetConnectionStatusChangedCallback_t)
			},
			{
				CallbackType.SteamNetAuthenticationStatus,
				typeof(SteamNetAuthenticationStatus_t)
			},
			{
				CallbackType.SteamRelayNetworkStatus,
				typeof(SteamRelayNetworkStatus_t)
			},
			{
				CallbackType.RemoteStorageAppSyncedClient,
				typeof(RemoteStorageAppSyncedClient_t)
			},
			{
				CallbackType.RemoteStorageAppSyncedServer,
				typeof(RemoteStorageAppSyncedServer_t)
			},
			{
				CallbackType.RemoteStorageAppSyncProgress,
				typeof(RemoteStorageAppSyncProgress_t)
			},
			{
				CallbackType.RemoteStorageAppSyncStatusCheck,
				typeof(RemoteStorageAppSyncStatusCheck_t)
			},
			{
				CallbackType.RemoteStorageFileShareResult,
				typeof(RemoteStorageFileShareResult_t)
			},
			{
				CallbackType.RemoteStoragePublishFileResult,
				typeof(RemoteStoragePublishFileResult_t)
			},
			{
				CallbackType.RemoteStorageDeletePublishedFileResult,
				typeof(RemoteStorageDeletePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageEnumerateUserPublishedFilesResult,
				typeof(RemoteStorageEnumerateUserPublishedFilesResult_t)
			},
			{
				CallbackType.RemoteStorageSubscribePublishedFileResult,
				typeof(RemoteStorageSubscribePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageEnumerateUserSubscribedFilesResult,
				typeof(RemoteStorageEnumerateUserSubscribedFilesResult_t)
			},
			{
				CallbackType.RemoteStorageUnsubscribePublishedFileResult,
				typeof(RemoteStorageUnsubscribePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageUpdatePublishedFileResult,
				typeof(RemoteStorageUpdatePublishedFileResult_t)
			},
			{
				CallbackType.RemoteStorageDownloadUGCResult,
				typeof(RemoteStorageDownloadUGCResult_t)
			},
			{
				CallbackType.RemoteStorageGetPublishedFileDetailsResult,
				typeof(RemoteStorageGetPublishedFileDetailsResult_t)
			},
			{
				CallbackType.RemoteStorageEnumerateWorkshopFilesResult,
				typeof(RemoteStorageEnumerateWorkshopFilesResult_t)
			},
			{
				CallbackType.RemoteStorageGetPublishedItemVoteDetailsResult,
				typeof(RemoteStorageGetPublishedItemVoteDetailsResult_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileSubscribed,
				typeof(RemoteStoragePublishedFileSubscribed_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileUnsubscribed,
				typeof(RemoteStoragePublishedFileUnsubscribed_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileDeleted,
				typeof(RemoteStoragePublishedFileDeleted_t)
			},
			{
				CallbackType.RemoteStorageUpdateUserPublishedItemVoteResult,
				typeof(RemoteStorageUpdateUserPublishedItemVoteResult_t)
			},
			{
				CallbackType.RemoteStorageUserVoteDetails,
				typeof(RemoteStorageUserVoteDetails_t)
			},
			{
				CallbackType.RemoteStorageEnumerateUserSharedWorkshopFilesResult,
				typeof(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t)
			},
			{
				CallbackType.RemoteStorageSetUserPublishedFileActionResult,
				typeof(RemoteStorageSetUserPublishedFileActionResult_t)
			},
			{
				CallbackType.RemoteStorageEnumeratePublishedFilesByUserActionResult,
				typeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t)
			},
			{
				CallbackType.RemoteStoragePublishFileProgress,
				typeof(RemoteStoragePublishFileProgress_t)
			},
			{
				CallbackType.RemoteStoragePublishedFileUpdated,
				typeof(RemoteStoragePublishedFileUpdated_t)
			},
			{
				CallbackType.RemoteStorageFileWriteAsyncComplete,
				typeof(RemoteStorageFileWriteAsyncComplete_t)
			},
			{
				CallbackType.RemoteStorageFileReadAsyncComplete,
				typeof(RemoteStorageFileReadAsyncComplete_t)
			},
			{
				CallbackType.GSStatsReceived,
				typeof(GSStatsReceived_t)
			},
			{
				CallbackType.GSStatsStored,
				typeof(GSStatsStored_t)
			},
			{
				CallbackType.HTTPRequestCompleted,
				typeof(HTTPRequestCompleted_t)
			},
			{
				CallbackType.HTTPRequestHeadersReceived,
				typeof(HTTPRequestHeadersReceived_t)
			},
			{
				CallbackType.HTTPRequestDataReceived,
				typeof(HTTPRequestDataReceived_t)
			},
			{
				CallbackType.ScreenshotReady,
				typeof(ScreenshotReady_t)
			},
			{
				CallbackType.ScreenshotRequested,
				typeof(ScreenshotRequested_t)
			},
			{
				CallbackType.SteamUGCQueryCompleted,
				typeof(SteamUGCQueryCompleted_t)
			},
			{
				CallbackType.SteamUGCRequestUGCDetailsResult,
				typeof(SteamUGCRequestUGCDetailsResult_t)
			},
			{
				CallbackType.CreateItemResult,
				typeof(CreateItemResult_t)
			},
			{
				CallbackType.SubmitItemUpdateResult,
				typeof(SubmitItemUpdateResult_t)
			},
			{
				CallbackType.ItemInstalled,
				typeof(ItemInstalled_t)
			},
			{
				CallbackType.DownloadItemResult,
				typeof(DownloadItemResult_t)
			},
			{
				CallbackType.UserFavoriteItemsListChanged,
				typeof(UserFavoriteItemsListChanged_t)
			},
			{
				CallbackType.SetUserItemVoteResult,
				typeof(SetUserItemVoteResult_t)
			},
			{
				CallbackType.GetUserItemVoteResult,
				typeof(GetUserItemVoteResult_t)
			},
			{
				CallbackType.StartPlaytimeTrackingResult,
				typeof(StartPlaytimeTrackingResult_t)
			},
			{
				CallbackType.StopPlaytimeTrackingResult,
				typeof(StopPlaytimeTrackingResult_t)
			},
			{
				CallbackType.AddUGCDependencyResult,
				typeof(AddUGCDependencyResult_t)
			},
			{
				CallbackType.RemoveUGCDependencyResult,
				typeof(RemoveUGCDependencyResult_t)
			},
			{
				CallbackType.AddAppDependencyResult,
				typeof(AddAppDependencyResult_t)
			},
			{
				CallbackType.RemoveAppDependencyResult,
				typeof(RemoveAppDependencyResult_t)
			},
			{
				CallbackType.GetAppDependenciesResult,
				typeof(GetAppDependenciesResult_t)
			},
			{
				CallbackType.DeleteItemResult,
				typeof(DeleteItemResult_t)
			},
			{
				CallbackType.SteamAppInstalled,
				typeof(SteamAppInstalled_t)
			},
			{
				CallbackType.SteamAppUninstalled,
				typeof(SteamAppUninstalled_t)
			},
			{
				CallbackType.PlaybackStatusHasChanged,
				typeof(PlaybackStatusHasChanged_t)
			},
			{
				CallbackType.VolumeHasChanged,
				typeof(VolumeHasChanged_t)
			},
			{
				CallbackType.MusicPlayerWantsVolume,
				typeof(MusicPlayerWantsVolume_t)
			},
			{
				CallbackType.MusicPlayerSelectsQueueEntry,
				typeof(MusicPlayerSelectsQueueEntry_t)
			},
			{
				CallbackType.MusicPlayerSelectsPlaylistEntry,
				typeof(MusicPlayerSelectsPlaylistEntry_t)
			},
			{
				CallbackType.MusicPlayerRemoteWillActivate,
				typeof(MusicPlayerRemoteWillActivate_t)
			},
			{
				CallbackType.MusicPlayerRemoteWillDeactivate,
				typeof(MusicPlayerRemoteWillDeactivate_t)
			},
			{
				CallbackType.MusicPlayerRemoteToFront,
				typeof(MusicPlayerRemoteToFront_t)
			},
			{
				CallbackType.MusicPlayerWillQuit,
				typeof(MusicPlayerWillQuit_t)
			},
			{
				CallbackType.MusicPlayerWantsPlay,
				typeof(MusicPlayerWantsPlay_t)
			},
			{
				CallbackType.MusicPlayerWantsPause,
				typeof(MusicPlayerWantsPause_t)
			},
			{
				CallbackType.MusicPlayerWantsPlayPrevious,
				typeof(MusicPlayerWantsPlayPrevious_t)
			},
			{
				CallbackType.MusicPlayerWantsPlayNext,
				typeof(MusicPlayerWantsPlayNext_t)
			},
			{
				CallbackType.MusicPlayerWantsShuffled,
				typeof(MusicPlayerWantsShuffled_t)
			},
			{
				CallbackType.MusicPlayerWantsLooped,
				typeof(MusicPlayerWantsLooped_t)
			},
			{
				CallbackType.MusicPlayerWantsPlayingRepeatStatus,
				typeof(MusicPlayerWantsPlayingRepeatStatus_t)
			},
			{
				CallbackType.HTML_BrowserReady,
				typeof(HTML_BrowserReady_t)
			},
			{
				CallbackType.HTML_NeedsPaint,
				typeof(HTML_NeedsPaint_t)
			},
			{
				CallbackType.HTML_StartRequest,
				typeof(HTML_StartRequest_t)
			},
			{
				CallbackType.HTML_CloseBrowser,
				typeof(HTML_CloseBrowser_t)
			},
			{
				CallbackType.HTML_URLChanged,
				typeof(HTML_URLChanged_t)
			},
			{
				CallbackType.HTML_FinishedRequest,
				typeof(HTML_FinishedRequest_t)
			},
			{
				CallbackType.HTML_OpenLinkInNewTab,
				typeof(HTML_OpenLinkInNewTab_t)
			},
			{
				CallbackType.HTML_ChangedTitle,
				typeof(HTML_ChangedTitle_t)
			},
			{
				CallbackType.HTML_SearchResults,
				typeof(HTML_SearchResults_t)
			},
			{
				CallbackType.HTML_CanGoBackAndForward,
				typeof(HTML_CanGoBackAndForward_t)
			},
			{
				CallbackType.HTML_HorizontalScroll,
				typeof(HTML_HorizontalScroll_t)
			},
			{
				CallbackType.HTML_VerticalScroll,
				typeof(HTML_VerticalScroll_t)
			},
			{
				CallbackType.HTML_LinkAtPosition,
				typeof(HTML_LinkAtPosition_t)
			},
			{
				CallbackType.HTML_JSAlert,
				typeof(HTML_JSAlert_t)
			},
			{
				CallbackType.HTML_JSConfirm,
				typeof(HTML_JSConfirm_t)
			},
			{
				CallbackType.HTML_FileOpenDialog,
				typeof(HTML_FileOpenDialog_t)
			},
			{
				CallbackType.HTML_NewWindow,
				typeof(HTML_NewWindow_t)
			},
			{
				CallbackType.HTML_SetCursor,
				typeof(HTML_SetCursor_t)
			},
			{
				CallbackType.HTML_StatusText,
				typeof(HTML_StatusText_t)
			},
			{
				CallbackType.HTML_ShowToolTip,
				typeof(HTML_ShowToolTip_t)
			},
			{
				CallbackType.HTML_UpdateToolTip,
				typeof(HTML_UpdateToolTip_t)
			},
			{
				CallbackType.HTML_HideToolTip,
				typeof(HTML_HideToolTip_t)
			},
			{
				CallbackType.HTML_BrowserRestarted,
				typeof(HTML_BrowserRestarted_t)
			},
			{
				CallbackType.BroadcastUploadStart,
				typeof(BroadcastUploadStart_t)
			},
			{
				CallbackType.BroadcastUploadStop,
				typeof(BroadcastUploadStop_t)
			},
			{
				CallbackType.GetVideoURLResult,
				typeof(GetVideoURLResult_t)
			},
			{
				CallbackType.GetOPFSettingsResult,
				typeof(GetOPFSettingsResult_t)
			},
			{
				CallbackType.SteamInventoryResultReady,
				typeof(SteamInventoryResultReady_t)
			},
			{
				CallbackType.SteamInventoryFullUpdate,
				typeof(SteamInventoryFullUpdate_t)
			},
			{
				CallbackType.SteamInventoryDefinitionUpdate,
				typeof(SteamInventoryDefinitionUpdate_t)
			},
			{
				CallbackType.SteamInventoryEligiblePromoItemDefIDs,
				typeof(SteamInventoryEligiblePromoItemDefIDs_t)
			},
			{
				CallbackType.SteamInventoryStartPurchaseResult,
				typeof(SteamInventoryStartPurchaseResult_t)
			},
			{
				CallbackType.SteamInventoryRequestPricesResult,
				typeof(SteamInventoryRequestPricesResult_t)
			},
			{
				CallbackType.SteamParentalSettingsChanged,
				typeof(SteamParentalSettingsChanged_t)
			},
			{
				CallbackType.SearchForGameProgressCallback,
				typeof(SearchForGameProgressCallback_t)
			},
			{
				CallbackType.SearchForGameResultCallback,
				typeof(SearchForGameResultCallback_t)
			},
			{
				CallbackType.RequestPlayersForGameProgressCallback,
				typeof(RequestPlayersForGameProgressCallback_t)
			},
			{
				CallbackType.RequestPlayersForGameResultCallback,
				typeof(RequestPlayersForGameResultCallback_t)
			},
			{
				CallbackType.RequestPlayersForGameFinalResultCallback,
				typeof(RequestPlayersForGameFinalResultCallback_t)
			},
			{
				CallbackType.SubmitPlayerResultResultCallback,
				typeof(SubmitPlayerResultResultCallback_t)
			},
			{
				CallbackType.EndGameResultCallback,
				typeof(EndGameResultCallback_t)
			},
			{
				CallbackType.JoinPartyCallback,
				typeof(JoinPartyCallback_t)
			},
			{
				CallbackType.CreateBeaconCallback,
				typeof(CreateBeaconCallback_t)
			},
			{
				CallbackType.ReservationNotificationCallback,
				typeof(ReservationNotificationCallback_t)
			},
			{
				CallbackType.ChangeNumOpenSlotsCallback,
				typeof(ChangeNumOpenSlotsCallback_t)
			},
			{
				CallbackType.AvailableBeaconLocationsUpdated,
				typeof(AvailableBeaconLocationsUpdated_t)
			},
			{
				CallbackType.ActiveBeaconsUpdated,
				typeof(ActiveBeaconsUpdated_t)
			},
			{
				CallbackType.SteamRemotePlaySessionConnected,
				typeof(SteamRemotePlaySessionConnected_t)
			},
			{
				CallbackType.SteamRemotePlaySessionDisconnected,
				typeof(SteamRemotePlaySessionDisconnected_t)
			}
		};
	}
	internal class ISteamAppList : SteamInterface
	{
		internal ISteamAppList(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamAppList_v001();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamAppList_v001();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetNumInstalledApps")]
		private static extern uint _GetNumInstalledApps(IntPtr self);

		internal uint GetNumInstalledApps()
		{
			return _GetNumInstalledApps(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetInstalledApps")]
		private static extern uint _GetInstalledApps(IntPtr self, [In][Out] AppId[] pvecAppID, uint unMaxAppIDs);

		internal uint GetInstalledApps([In][Out] AppId[] pvecAppID, uint unMaxAppIDs)
		{
			return _GetInstalledApps(Self, pvecAppID, unMaxAppIDs);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetAppName")]
		private static extern int _GetAppName(IntPtr self, AppId nAppID, IntPtr pchName, int cchNameMax);

		internal int GetAppName(AppId nAppID, out string pchName)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetAppName(Self, nAppID, intPtr, 32768);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetAppInstallDir")]
		private static extern int _GetAppInstallDir(IntPtr self, AppId nAppID, IntPtr pchDirectory, int cchNameMax);

		internal int GetAppInstallDir(AppId nAppID, out string pchDirectory)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetAppInstallDir(Self, nAppID, intPtr, 32768);
			pchDirectory = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamAppList_GetAppBuildId")]
		private static extern int _GetAppBuildId(IntPtr self, AppId nAppID);

		internal int GetAppBuildId(AppId nAppID)
		{
			return _GetAppBuildId(Self, nAppID);
		}
	}
	internal class ISteamApps : SteamInterface
	{
		internal ISteamApps(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamApps_v008();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamApps_v008();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamGameServerApps_v008();

		public override IntPtr GetServerInterfacePointer()
		{
			return SteamAPI_SteamGameServerApps_v008();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribed")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribed(IntPtr self);

		internal bool BIsSubscribed()
		{
			return _BIsSubscribed(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsLowViolence")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsLowViolence(IntPtr self);

		internal bool BIsLowViolence()
		{
			return _BIsLowViolence(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsCybercafe")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsCybercafe(IntPtr self);

		internal bool BIsCybercafe()
		{
			return _BIsCybercafe(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsVACBanned")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsVACBanned(IntPtr self);

		internal bool BIsVACBanned()
		{
			return _BIsVACBanned(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetCurrentGameLanguage")]
		private static extern Utf8StringPointer _GetCurrentGameLanguage(IntPtr self);

		internal string GetCurrentGameLanguage()
		{
			Utf8StringPointer utf8StringPointer = _GetCurrentGameLanguage(Self);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAvailableGameLanguages")]
		private static extern Utf8StringPointer _GetAvailableGameLanguages(IntPtr self);

		internal string GetAvailableGameLanguages()
		{
			Utf8StringPointer utf8StringPointer = _GetAvailableGameLanguages(Self);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribedApp")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribedApp(IntPtr self, AppId appID);

		internal bool BIsSubscribedApp(AppId appID)
		{
			return _BIsSubscribedApp(Self, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsDlcInstalled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsDlcInstalled(IntPtr self, AppId appID);

		internal bool BIsDlcInstalled(AppId appID)
		{
			return _BIsDlcInstalled(Self, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime")]
		private static extern uint _GetEarliestPurchaseUnixTime(IntPtr self, AppId nAppID);

		internal uint GetEarliestPurchaseUnixTime(AppId nAppID)
		{
			return _GetEarliestPurchaseUnixTime(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribedFromFreeWeekend(IntPtr self);

		internal bool BIsSubscribedFromFreeWeekend()
		{
			return _BIsSubscribedFromFreeWeekend(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetDLCCount")]
		private static extern int _GetDLCCount(IntPtr self);

		internal int GetDLCCount()
		{
			return _GetDLCCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BGetDLCDataByIndex")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BGetDLCDataByIndex(IntPtr self, int iDLC, ref AppId pAppID, [MarshalAs(UnmanagedType.U1)] ref bool pbAvailable, IntPtr pchName, int cchNameBufferSize);

		internal bool BGetDLCDataByIndex(int iDLC, ref AppId pAppID, [MarshalAs(UnmanagedType.U1)] ref bool pbAvailable, out string pchName)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _BGetDLCDataByIndex(Self, iDLC, ref pAppID, ref pbAvailable, intPtr, 32768);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_InstallDLC")]
		private static extern void _InstallDLC(IntPtr self, AppId nAppID);

		internal void InstallDLC(AppId nAppID)
		{
			_InstallDLC(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_UninstallDLC")]
		private static extern void _UninstallDLC(IntPtr self, AppId nAppID);

		internal void UninstallDLC(AppId nAppID)
		{
			_UninstallDLC(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey")]
		private static extern void _RequestAppProofOfPurchaseKey(IntPtr self, AppId nAppID);

		internal void RequestAppProofOfPurchaseKey(AppId nAppID)
		{
			_RequestAppProofOfPurchaseKey(Self, nAppID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetCurrentBetaName")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetCurrentBetaName(IntPtr self, IntPtr pchName, int cchNameBufferSize);

		internal bool GetCurrentBetaName(out string pchName)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			bool result = _GetCurrentBetaName(Self, intPtr, 32768);
			pchName = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_MarkContentCorrupt")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _MarkContentCorrupt(IntPtr self, [MarshalAs(UnmanagedType.U1)] bool bMissingFilesOnly);

		internal bool MarkContentCorrupt([MarshalAs(UnmanagedType.U1)] bool bMissingFilesOnly)
		{
			return _MarkContentCorrupt(Self, bMissingFilesOnly);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetInstalledDepots")]
		private static extern uint _GetInstalledDepots(IntPtr self, AppId appID, [In][Out] DepotId_t[] pvecDepots, uint cMaxDepots);

		internal uint GetInstalledDepots(AppId appID, [In][Out] DepotId_t[] pvecDepots, uint cMaxDepots)
		{
			return _GetInstalledDepots(Self, appID, pvecDepots, cMaxDepots);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAppInstallDir")]
		private static extern uint _GetAppInstallDir(IntPtr self, AppId appID, IntPtr pchFolder, uint cchFolderBufferSize);

		internal uint GetAppInstallDir(AppId appID, out string pchFolder)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			uint result = _GetAppInstallDir(Self, appID, intPtr, 32768u);
			pchFolder = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsAppInstalled")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsAppInstalled(IntPtr self, AppId appID);

		internal bool BIsAppInstalled(AppId appID)
		{
			return _BIsAppInstalled(Self, appID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAppOwner")]
		private static extern SteamId _GetAppOwner(IntPtr self);

		internal SteamId GetAppOwner()
		{
			return _GetAppOwner(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetLaunchQueryParam")]
		private static extern Utf8StringPointer _GetLaunchQueryParam(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey);

		internal string GetLaunchQueryParam([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchKey)
		{
			Utf8StringPointer utf8StringPointer = _GetLaunchQueryParam(Self, pchKey);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetDlcDownloadProgress")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetDlcDownloadProgress(IntPtr self, AppId nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal);

		internal bool GetDlcDownloadProgress(AppId nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal)
		{
			return _GetDlcDownloadProgress(Self, nAppID, ref punBytesDownloaded, ref punBytesTotal);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetAppBuildId")]
		private static extern int _GetAppBuildId(IntPtr self);

		internal int GetAppBuildId()
		{
			return _GetAppBuildId(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys")]
		private static extern void _RequestAllProofOfPurchaseKeys(IntPtr self);

		internal void RequestAllProofOfPurchaseKeys()
		{
			_RequestAllProofOfPurchaseKeys(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetFileDetails")]
		private static extern SteamAPICall_t _GetFileDetails(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszFileName);

		internal CallResult<FileDetailsResult_t> GetFileDetails([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszFileName)
		{
			SteamAPICall_t call = _GetFileDetails(Self, pszFileName);
			return new CallResult<FileDetailsResult_t>(call, base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_GetLaunchCommandLine")]
		private static extern int _GetLaunchCommandLine(IntPtr self, IntPtr pszCommandLine, int cubCommandLine);

		internal int GetLaunchCommandLine(out string pszCommandLine)
		{
			IntPtr intPtr = Helpers.TakeMemory();
			int result = _GetLaunchCommandLine(Self, intPtr, 32768);
			pszCommandLine = Helpers.MemoryToString(intPtr);
			return result;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BIsSubscribedFromFamilySharing(IntPtr self);

		internal bool BIsSubscribedFromFamilySharing()
		{
			return _BIsSubscribedFromFamilySharing(Self);
		}
	}
	internal class ISteamClient : SteamInterface
	{
		internal ISteamClient(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_CreateSteamPipe")]
		private static extern HSteamPipe _CreateSteamPipe(IntPtr self);

		internal HSteamPipe CreateSteamPipe()
		{
			return _CreateSteamPipe(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_BReleaseSteamPipe")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BReleaseSteamPipe(IntPtr self, HSteamPipe hSteamPipe);

		internal bool BReleaseSteamPipe(HSteamPipe hSteamPipe)
		{
			return _BReleaseSteamPipe(Self, hSteamPipe);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_ConnectToGlobalUser")]
		private static extern HSteamUser _ConnectToGlobalUser(IntPtr self, HSteamPipe hSteamPipe);

		internal HSteamUser ConnectToGlobalUser(HSteamPipe hSteamPipe)
		{
			return _ConnectToGlobalUser(Self, hSteamPipe);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_CreateLocalUser")]
		private static extern HSteamUser _CreateLocalUser(IntPtr self, ref HSteamPipe phSteamPipe, AccountType eAccountType);

		internal HSteamUser CreateLocalUser(ref HSteamPipe phSteamPipe, AccountType eAccountType)
		{
			return _CreateLocalUser(Self, ref phSteamPipe, eAccountType);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_ReleaseUser")]
		private static extern void _ReleaseUser(IntPtr self, HSteamPipe hSteamPipe, HSteamUser hUser);

		internal void ReleaseUser(HSteamPipe hSteamPipe, HSteamUser hUser)
		{
			_ReleaseUser(Self, hSteamPipe, hUser);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUser")]
		private static extern IntPtr _GetISteamUser(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUser(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUser(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameServer")]
		private static extern IntPtr _GetISteamGameServer(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGameServer(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGameServer(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_SetLocalIPBinding")]
		private static extern void _SetLocalIPBinding(IntPtr self, ref SteamIPAddress unIP, ushort usPort);

		internal void SetLocalIPBinding(ref SteamIPAddress unIP, ushort usPort)
		{
			_SetLocalIPBinding(Self, ref unIP, usPort);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamFriends")]
		private static extern IntPtr _GetISteamFriends(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamFriends(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamFriends(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUtils")]
		private static extern IntPtr _GetISteamUtils(IntPtr self, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUtils(HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUtils(Self, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMatchmaking")]
		private static extern IntPtr _GetISteamMatchmaking(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMatchmaking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMatchmaking(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMatchmakingServers")]
		private static extern IntPtr _GetISteamMatchmakingServers(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMatchmakingServers(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMatchmakingServers(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGenericInterface")]
		private static extern IntPtr _GetISteamGenericInterface(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGenericInterface(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGenericInterface(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUserStats")]
		private static extern IntPtr _GetISteamUserStats(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUserStats(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUserStats(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameServerStats")]
		private static extern IntPtr _GetISteamGameServerStats(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGameServerStats(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGameServerStats(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamApps")]
		private static extern IntPtr _GetISteamApps(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamApps(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamApps(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamNetworking")]
		private static extern IntPtr _GetISteamNetworking(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamNetworking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamNetworking(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamRemoteStorage")]
		private static extern IntPtr _GetISteamRemoteStorage(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamRemoteStorage(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamRemoteStorage(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamScreenshots")]
		private static extern IntPtr _GetISteamScreenshots(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamScreenshots(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamScreenshots(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameSearch")]
		private static extern IntPtr _GetISteamGameSearch(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamGameSearch(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamGameSearch(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetIPCCallCount")]
		private static extern uint _GetIPCCallCount(IntPtr self);

		internal uint GetIPCCallCount()
		{
			return _GetIPCCallCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_SetWarningMessageHook")]
		private static extern void _SetWarningMessageHook(IntPtr self, IntPtr pFunction);

		internal void SetWarningMessageHook(IntPtr pFunction)
		{
			_SetWarningMessageHook(Self, pFunction);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_BShutdownIfAllPipesClosed")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _BShutdownIfAllPipesClosed(IntPtr self);

		internal bool BShutdownIfAllPipesClosed()
		{
			return _BShutdownIfAllPipesClosed(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamHTTP")]
		private static extern IntPtr _GetISteamHTTP(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamHTTP(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamHTTP(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamController")]
		private static extern IntPtr _GetISteamController(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamController(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamController(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamUGC")]
		private static extern IntPtr _GetISteamUGC(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamUGC(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamUGC(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamAppList")]
		private static extern IntPtr _GetISteamAppList(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamAppList(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamAppList(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMusic")]
		private static extern IntPtr _GetISteamMusic(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMusic(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMusic(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamMusicRemote")]
		private static extern IntPtr _GetISteamMusicRemote(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamMusicRemote(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamHTMLSurface")]
		private static extern IntPtr _GetISteamHTMLSurface(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamHTMLSurface(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamInventory")]
		private static extern IntPtr _GetISteamInventory(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamInventory(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamInventory(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamVideo")]
		private static extern IntPtr _GetISteamVideo(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamVideo(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamVideo(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamParentalSettings")]
		private static extern IntPtr _GetISteamParentalSettings(IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamParentalSettings(HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamParentalSettings(Self, hSteamuser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamInput")]
		private static extern IntPtr _GetISteamInput(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamInput(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamInput(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamParties")]
		private static extern IntPtr _GetISteamParties(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamParties(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamParties(Self, hSteamUser, hSteamPipe, pchVersion);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamClient_GetISteamRemotePlay")]
		private static extern IntPtr _GetISteamRemotePlay(IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion);

		internal IntPtr GetISteamRemotePlay(HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchVersion)
		{
			return _GetISteamRemotePlay(Self, hSteamUser, hSteamPipe, pchVersion);
		}
	}
	internal class ISteamController : SteamInterface
	{
		internal ISteamController(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamController_v007();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamController_v007();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_Init")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Init(IntPtr self);

		internal bool Init()
		{
			return _Init(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_Shutdown")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _Shutdown(IntPtr self);

		internal bool Shutdown()
		{
			return _Shutdown(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_RunFrame")]
		private static extern void _RunFrame(IntPtr self);

		internal void RunFrame()
		{
			_RunFrame(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetConnectedControllers")]
		private static extern int _GetConnectedControllers(IntPtr self, [In][Out] ControllerHandle_t[] handlesOut);

		internal int GetConnectedControllers([In][Out] ControllerHandle_t[] handlesOut)
		{
			return _GetConnectedControllers(Self, handlesOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetActionSetHandle")]
		private static extern ControllerActionSetHandle_t _GetActionSetHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionSetName);

		internal ControllerActionSetHandle_t GetActionSetHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionSetName)
		{
			return _GetActionSetHandle(Self, pszActionSetName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_ActivateActionSet")]
		private static extern void _ActivateActionSet(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle);

		internal void ActivateActionSet(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle)
		{
			_ActivateActionSet(Self, controllerHandle, actionSetHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetCurrentActionSet")]
		private static extern ControllerActionSetHandle_t _GetCurrentActionSet(IntPtr self, ControllerHandle_t controllerHandle);

		internal ControllerActionSetHandle_t GetCurrentActionSet(ControllerHandle_t controllerHandle)
		{
			return _GetCurrentActionSet(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_ActivateActionSetLayer")]
		private static extern void _ActivateActionSetLayer(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle);

		internal void ActivateActionSetLayer(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
		{
			_ActivateActionSetLayer(Self, controllerHandle, actionSetLayerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_DeactivateActionSetLayer")]
		private static extern void _DeactivateActionSetLayer(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle);

		internal void DeactivateActionSetLayer(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle)
		{
			_DeactivateActionSetLayer(Self, controllerHandle, actionSetLayerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_DeactivateAllActionSetLayers")]
		private static extern void _DeactivateAllActionSetLayers(IntPtr self, ControllerHandle_t controllerHandle);

		internal void DeactivateAllActionSetLayers(ControllerHandle_t controllerHandle)
		{
			_DeactivateAllActionSetLayers(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetActiveActionSetLayers")]
		private static extern int _GetActiveActionSetLayers(IntPtr self, ControllerHandle_t controllerHandle, [In][Out] ControllerActionSetHandle_t[] handlesOut);

		internal int GetActiveActionSetLayers(ControllerHandle_t controllerHandle, [In][Out] ControllerActionSetHandle_t[] handlesOut)
		{
			return _GetActiveActionSetLayers(Self, controllerHandle, handlesOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionHandle")]
		private static extern ControllerDigitalActionHandle_t _GetDigitalActionHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName);

		internal ControllerDigitalActionHandle_t GetDigitalActionHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName)
		{
			return _GetDigitalActionHandle(Self, pszActionName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionData")]
		private static extern DigitalState _GetDigitalActionData(IntPtr self, ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle);

		internal DigitalState GetDigitalActionData(ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle)
		{
			return _GetDigitalActionData(Self, controllerHandle, digitalActionHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionOrigins")]
		private static extern int _GetDigitalActionOrigins(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, ref ControllerActionOrigin originsOut);

		internal int GetDigitalActionOrigins(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, ref ControllerActionOrigin originsOut)
		{
			return _GetDigitalActionOrigins(Self, controllerHandle, actionSetHandle, digitalActionHandle, ref originsOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionHandle")]
		private static extern ControllerAnalogActionHandle_t _GetAnalogActionHandle(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName);

		internal ControllerAnalogActionHandle_t GetAnalogActionHandle([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pszActionName)
		{
			return _GetAnalogActionHandle(Self, pszActionName);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionData")]
		private static extern AnalogState _GetAnalogActionData(IntPtr self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle);

		internal AnalogState GetAnalogActionData(ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle)
		{
			return _GetAnalogActionData(Self, controllerHandle, analogActionHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionOrigins")]
		private static extern int _GetAnalogActionOrigins(IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, ref ControllerActionOrigin originsOut);

		internal int GetAnalogActionOrigins(ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, ref ControllerActionOrigin originsOut)
		{
			return _GetAnalogActionOrigins(Self, controllerHandle, actionSetHandle, analogActionHandle, ref originsOut);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetGlyphForActionOrigin")]
		private static extern Utf8StringPointer _GetGlyphForActionOrigin(IntPtr self, ControllerActionOrigin eOrigin);

		internal string GetGlyphForActionOrigin(ControllerActionOrigin eOrigin)
		{
			Utf8StringPointer utf8StringPointer = _GetGlyphForActionOrigin(Self, eOrigin);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetStringForActionOrigin")]
		private static extern Utf8StringPointer _GetStringForActionOrigin(IntPtr self, ControllerActionOrigin eOrigin);

		internal string GetStringForActionOrigin(ControllerActionOrigin eOrigin)
		{
			Utf8StringPointer utf8StringPointer = _GetStringForActionOrigin(Self, eOrigin);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_StopAnalogActionMomentum")]
		private static extern void _StopAnalogActionMomentum(IntPtr self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction);

		internal void StopAnalogActionMomentum(ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction)
		{
			_StopAnalogActionMomentum(Self, controllerHandle, eAction);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetMotionData")]
		private static extern MotionState _GetMotionData(IntPtr self, ControllerHandle_t controllerHandle);

		internal MotionState GetMotionData(ControllerHandle_t controllerHandle)
		{
			return _GetMotionData(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TriggerHapticPulse")]
		private static extern void _TriggerHapticPulse(IntPtr self, ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec);

		internal void TriggerHapticPulse(ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec)
		{
			_TriggerHapticPulse(Self, controllerHandle, eTargetPad, usDurationMicroSec);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TriggerRepeatedHapticPulse")]
		private static extern void _TriggerRepeatedHapticPulse(IntPtr self, ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags);

		internal void TriggerRepeatedHapticPulse(ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags)
		{
			_TriggerRepeatedHapticPulse(Self, controllerHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TriggerVibration")]
		private static extern void _TriggerVibration(IntPtr self, ControllerHandle_t controllerHandle, ushort usLeftSpeed, ushort usRightSpeed);

		internal void TriggerVibration(ControllerHandle_t controllerHandle, ushort usLeftSpeed, ushort usRightSpeed)
		{
			_TriggerVibration(Self, controllerHandle, usLeftSpeed, usRightSpeed);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_SetLEDColor")]
		private static extern void _SetLEDColor(IntPtr self, ControllerHandle_t controllerHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags);

		internal void SetLEDColor(ControllerHandle_t controllerHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags)
		{
			_SetLEDColor(Self, controllerHandle, nColorR, nColorG, nColorB, nFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_ShowBindingPanel")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _ShowBindingPanel(IntPtr self, ControllerHandle_t controllerHandle);

		internal bool ShowBindingPanel(ControllerHandle_t controllerHandle)
		{
			return _ShowBindingPanel(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetInputTypeForHandle")]
		private static extern InputType _GetInputTypeForHandle(IntPtr self, ControllerHandle_t controllerHandle);

		internal InputType GetInputTypeForHandle(ControllerHandle_t controllerHandle)
		{
			return _GetInputTypeForHandle(Self, controllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetControllerForGamepadIndex")]
		private static extern ControllerHandle_t _GetControllerForGamepadIndex(IntPtr self, int nIndex);

		internal ControllerHandle_t GetControllerForGamepadIndex(int nIndex)
		{
			return _GetControllerForGamepadIndex(Self, nIndex);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetGamepadIndexForController")]
		private static extern int _GetGamepadIndexForController(IntPtr self, ControllerHandle_t ulControllerHandle);

		internal int GetGamepadIndexForController(ControllerHandle_t ulControllerHandle)
		{
			return _GetGamepadIndexForController(Self, ulControllerHandle);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetStringForXboxOrigin")]
		private static extern Utf8StringPointer _GetStringForXboxOrigin(IntPtr self, XboxOrigin eOrigin);

		internal string GetStringForXboxOrigin(XboxOrigin eOrigin)
		{
			Utf8StringPointer utf8StringPointer = _GetStringForXboxOrigin(Self, eOrigin);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetGlyphForXboxOrigin")]
		private static extern Utf8StringPointer _GetGlyphForXboxOrigin(IntPtr self, XboxOrigin eOrigin);

		internal string GetGlyphForXboxOrigin(XboxOrigin eOrigin)
		{
			Utf8StringPointer utf8StringPointer = _GetGlyphForXboxOrigin(Self, eOrigin);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetActionOriginFromXboxOrigin")]
		private static extern ControllerActionOrigin _GetActionOriginFromXboxOrigin(IntPtr self, ControllerHandle_t controllerHandle, XboxOrigin eOrigin);

		internal ControllerActionOrigin GetActionOriginFromXboxOrigin(ControllerHandle_t controllerHandle, XboxOrigin eOrigin)
		{
			return _GetActionOriginFromXboxOrigin(Self, controllerHandle, eOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_TranslateActionOrigin")]
		private static extern ControllerActionOrigin _TranslateActionOrigin(IntPtr self, InputType eDestinationInputType, ControllerActionOrigin eSourceOrigin);

		internal ControllerActionOrigin TranslateActionOrigin(InputType eDestinationInputType, ControllerActionOrigin eSourceOrigin)
		{
			return _TranslateActionOrigin(Self, eDestinationInputType, eSourceOrigin);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamController_GetControllerBindingRevision")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetControllerBindingRevision(IntPtr self, ControllerHandle_t controllerHandle, ref int pMajor, ref int pMinor);

		internal bool GetControllerBindingRevision(ControllerHandle_t controllerHandle, ref int pMajor, ref int pMinor)
		{
			return _GetControllerBindingRevision(Self, controllerHandle, ref pMajor, ref pMinor);
		}
	}
	internal class ISteamFriends : SteamInterface
	{
		internal ISteamFriends(bool IsGameServer)
		{
			SetupInterface(IsGameServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl)]
		internal static extern IntPtr SteamAPI_SteamFriends_v017();

		public override IntPtr GetUserInterfacePointer()
		{
			return SteamAPI_SteamFriends_v017();
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetPersonaName")]
		private static extern Utf8StringPointer _GetPersonaName(IntPtr self);

		internal string GetPersonaName()
		{
			Utf8StringPointer utf8StringPointer = _GetPersonaName(Self);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SetPersonaName")]
		private static extern SteamAPICall_t _SetPersonaName(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPersonaName);

		internal CallResult<SetPersonaNameResponse_t> SetPersonaName([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchPersonaName)
		{
			SteamAPICall_t call = _SetPersonaName(Self, pchPersonaName);
			return new CallResult<SetPersonaNameResponse_t>(call, base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetPersonaState")]
		private static extern FriendState _GetPersonaState(IntPtr self);

		internal FriendState GetPersonaState()
		{
			return _GetPersonaState(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendCount")]
		private static extern int _GetFriendCount(IntPtr self, int iFriendFlags);

		internal int GetFriendCount(int iFriendFlags)
		{
			return _GetFriendCount(Self, iFriendFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendByIndex")]
		private static extern SteamId _GetFriendByIndex(IntPtr self, int iFriend, int iFriendFlags);

		internal SteamId GetFriendByIndex(int iFriend, int iFriendFlags)
		{
			return _GetFriendByIndex(Self, iFriend, iFriendFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendRelationship")]
		private static extern Relationship _GetFriendRelationship(IntPtr self, SteamId steamIDFriend);

		internal Relationship GetFriendRelationship(SteamId steamIDFriend)
		{
			return _GetFriendRelationship(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendPersonaState")]
		private static extern FriendState _GetFriendPersonaState(IntPtr self, SteamId steamIDFriend);

		internal FriendState GetFriendPersonaState(SteamId steamIDFriend)
		{
			return _GetFriendPersonaState(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendPersonaName")]
		private static extern Utf8StringPointer _GetFriendPersonaName(IntPtr self, SteamId steamIDFriend);

		internal string GetFriendPersonaName(SteamId steamIDFriend)
		{
			Utf8StringPointer utf8StringPointer = _GetFriendPersonaName(Self, steamIDFriend);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendGamePlayed")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetFriendGamePlayed(IntPtr self, SteamId steamIDFriend, ref FriendGameInfo_t pFriendGameInfo);

		internal bool GetFriendGamePlayed(SteamId steamIDFriend, ref FriendGameInfo_t pFriendGameInfo)
		{
			return _GetFriendGamePlayed(Self, steamIDFriend, ref pFriendGameInfo);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendPersonaNameHistory")]
		private static extern Utf8StringPointer _GetFriendPersonaNameHistory(IntPtr self, SteamId steamIDFriend, int iPersonaName);

		internal string GetFriendPersonaNameHistory(SteamId steamIDFriend, int iPersonaName)
		{
			Utf8StringPointer utf8StringPointer = _GetFriendPersonaNameHistory(Self, steamIDFriend, iPersonaName);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendSteamLevel")]
		private static extern int _GetFriendSteamLevel(IntPtr self, SteamId steamIDFriend);

		internal int GetFriendSteamLevel(SteamId steamIDFriend)
		{
			return _GetFriendSteamLevel(Self, steamIDFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetPlayerNickname")]
		private static extern Utf8StringPointer _GetPlayerNickname(IntPtr self, SteamId steamIDPlayer);

		internal string GetPlayerNickname(SteamId steamIDPlayer)
		{
			Utf8StringPointer utf8StringPointer = _GetPlayerNickname(Self, steamIDPlayer);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupCount")]
		private static extern int _GetFriendsGroupCount(IntPtr self);

		internal int GetFriendsGroupCount()
		{
			return _GetFriendsGroupCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex")]
		private static extern FriendsGroupID_t _GetFriendsGroupIDByIndex(IntPtr self, int iFG);

		internal FriendsGroupID_t GetFriendsGroupIDByIndex(int iFG)
		{
			return _GetFriendsGroupIDByIndex(Self, iFG);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupName")]
		private static extern Utf8StringPointer _GetFriendsGroupName(IntPtr self, FriendsGroupID_t friendsGroupID);

		internal string GetFriendsGroupName(FriendsGroupID_t friendsGroupID)
		{
			Utf8StringPointer utf8StringPointer = _GetFriendsGroupName(Self, friendsGroupID);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupMembersCount")]
		private static extern int _GetFriendsGroupMembersCount(IntPtr self, FriendsGroupID_t friendsGroupID);

		internal int GetFriendsGroupMembersCount(FriendsGroupID_t friendsGroupID)
		{
			return _GetFriendsGroupMembersCount(Self, friendsGroupID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendsGroupMembersList")]
		private static extern void _GetFriendsGroupMembersList(IntPtr self, FriendsGroupID_t friendsGroupID, [In][Out] SteamId[] pOutSteamIDMembers, int nMembersCount);

		internal void GetFriendsGroupMembersList(FriendsGroupID_t friendsGroupID, [In][Out] SteamId[] pOutSteamIDMembers, int nMembersCount)
		{
			_GetFriendsGroupMembersList(Self, friendsGroupID, pOutSteamIDMembers, nMembersCount);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_HasFriend")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _HasFriend(IntPtr self, SteamId steamIDFriend, int iFriendFlags);

		internal bool HasFriend(SteamId steamIDFriend, int iFriendFlags)
		{
			return _HasFriend(Self, steamIDFriend, iFriendFlags);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanCount")]
		private static extern int _GetClanCount(IntPtr self);

		internal int GetClanCount()
		{
			return _GetClanCount(Self);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanByIndex")]
		private static extern SteamId _GetClanByIndex(IntPtr self, int iClan);

		internal SteamId GetClanByIndex(int iClan)
		{
			return _GetClanByIndex(Self, iClan);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanName")]
		private static extern Utf8StringPointer _GetClanName(IntPtr self, SteamId steamIDClan);

		internal string GetClanName(SteamId steamIDClan)
		{
			Utf8StringPointer utf8StringPointer = _GetClanName(Self, steamIDClan);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanTag")]
		private static extern Utf8StringPointer _GetClanTag(IntPtr self, SteamId steamIDClan);

		internal string GetClanTag(SteamId steamIDClan)
		{
			Utf8StringPointer utf8StringPointer = _GetClanTag(Self, steamIDClan);
			return utf8StringPointer;
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetClanActivityCounts")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _GetClanActivityCounts(IntPtr self, SteamId steamIDClan, ref int pnOnline, ref int pnInGame, ref int pnChatting);

		internal bool GetClanActivityCounts(SteamId steamIDClan, ref int pnOnline, ref int pnInGame, ref int pnChatting)
		{
			return _GetClanActivityCounts(Self, steamIDClan, ref pnOnline, ref pnInGame, ref pnChatting);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_DownloadClanActivityCounts")]
		private static extern SteamAPICall_t _DownloadClanActivityCounts(IntPtr self, [In][Out] SteamId[] psteamIDClans, int cClansToRequest);

		internal CallResult<DownloadClanActivityCountsResult_t> DownloadClanActivityCounts([In][Out] SteamId[] psteamIDClans, int cClansToRequest)
		{
			SteamAPICall_t call = _DownloadClanActivityCounts(Self, psteamIDClans, cClansToRequest);
			return new CallResult<DownloadClanActivityCountsResult_t>(call, base.IsServer);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendCountFromSource")]
		private static extern int _GetFriendCountFromSource(IntPtr self, SteamId steamIDSource);

		internal int GetFriendCountFromSource(SteamId steamIDSource)
		{
			return _GetFriendCountFromSource(Self, steamIDSource);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_GetFriendFromSourceByIndex")]
		private static extern SteamId _GetFriendFromSourceByIndex(IntPtr self, SteamId steamIDSource, int iFriend);

		internal SteamId GetFriendFromSourceByIndex(SteamId steamIDSource, int iFriend)
		{
			return _GetFriendFromSourceByIndex(Self, steamIDSource, iFriend);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_IsUserInSource")]
		[return: MarshalAs(UnmanagedType.I1)]
		private static extern bool _IsUserInSource(IntPtr self, SteamId steamIDUser, SteamId steamIDSource);

		internal bool IsUserInSource(SteamId steamIDUser, SteamId steamIDSource)
		{
			return _IsUserInSource(Self, steamIDUser, steamIDSource);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_SetInGameVoiceSpeaking")]
		private static extern void _SetInGameVoiceSpeaking(IntPtr self, SteamId steamIDUser, [MarshalAs(UnmanagedType.U1)] bool bSpeaking);

		internal void SetInGameVoiceSpeaking(SteamId steamIDUser, [MarshalAs(UnmanagedType.U1)] bool bSpeaking)
		{
			_SetInGameVoiceSpeaking(Self, steamIDUser, bSpeaking);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlay")]
		private static extern void _ActivateGameOverlay(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog);

		internal void ActivateGameOverlay([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog)
		{
			_ActivateGameOverlay(Self, pchDialog);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayToUser")]
		private static extern void _ActivateGameOverlayToUser(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog, SteamId steamID);

		internal void ActivateGameOverlayToUser([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchDialog, SteamId steamID)
		{
			_ActivateGameOverlayToUser(Self, pchDialog, steamID);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage")]
		private static extern void _ActivateGameOverlayToWebPage(IntPtr self, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchURL, ActivateGameOverlayToWebPageMode eMode);

		internal void ActivateGameOverlayToWebPage([MarshalAs(UnmanagedType.CustomMarshaler, MarshalType = "Steamworks.Utf8StringToNative")] string pchURL, ActivateGameOverlayToWebPageMode eMode)
		{
			_ActivateGameOverlayToWebPage(Self, pchURL, eMode);
		}

		[DllImport("steam_api64", CallingConvention = CallingConvention.Cdecl, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayToStore")]
		private static extern void _ActivateGameOverlayToStore(IntPtr self, AppId nAppID, OverlayToStoreFlag eFlag);

		inte