EpicVoiceTest/Assets/Plugins/EpicOnlineServices/Source/Generated/Sessions/SessionsInterface.cs

// Copyright Epic Games, Inc. All Rights Reserved.
// This file is automatically generated. Changes to this file may be overwritten.

namespace Epic.OnlineServices.Sessions
{
	public sealed partial class SessionsInterface : Handle
	{
		public SessionsInterface()
		{
		}

		public SessionsInterface(System.IntPtr innerHandle) : base(innerHandle)
		{
		}

		/// <summary>
		/// The most recent version of the <see cref="AddNotifyJoinSessionAccepted" /> API.
		/// </summary>
		public const int AddnotifyjoinsessionacceptedApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="AddNotifySessionInviteAccepted" /> API.
		/// </summary>
		public const int AddnotifysessioninviteacceptedApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="AddNotifySessionInviteReceived" /> API.
		/// </summary>
		public const int AddnotifysessioninvitereceivedApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="AttributeData" /> struct.
		/// </summary>
		public const int AttributedataApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="CopyActiveSessionHandle" /> API.
		/// </summary>
		public const int CopyactivesessionhandleApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="CopySessionHandleByInviteId" /> API.
		/// </summary>
		public const int CopysessionhandlebyinviteidApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="CopySessionHandleByUiEventId" /> API.
		/// </summary>
		public const int CopysessionhandlebyuieventidApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="CopySessionHandleForPresence" /> API.
		/// </summary>
		public const int CopysessionhandleforpresenceApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="CreateSessionModification" /> API.
		/// </summary>
		public const int CreatesessionmodificationApiLatest = 4;

		/// <summary>
		/// The most recent version of the <see cref="CreateSessionSearch" /> API.
		/// </summary>
		public const int CreatesessionsearchApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="DestroySession" /> API.
		/// </summary>
		public const int DestroysessionApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="DumpSessionState" /> API.
		/// </summary>
		public const int DumpsessionstateApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="EndSession" /> API.
		/// </summary>
		public const int EndsessionApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="GetInviteCount" /> API.
		/// </summary>
		public const int GetinvitecountApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="GetInviteIdByIndex" /> API.
		/// </summary>
		public const int GetinviteidbyindexApiLatest = 1;

		/// <summary>
		/// Max length of an invite ID
		/// </summary>
		public const int InviteidMaxLength = 64;

		/// <summary>
		/// The most recent version of the <see cref="IsUserInSession" /> API.
		/// </summary>
		public const int IsuserinsessionApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="JoinSession" /> API.
		/// </summary>
		public const int JoinsessionApiLatest = 2;

		/// <summary>
		/// Maximum number of search results allowed with a given query
		/// </summary>
		public const int MaxSearchResults = 200;

		/// <summary>
		/// Maximum number of players allowed in a single session
		/// </summary>
		public const int Maxregisteredplayers = 1000;

		/// <summary>
		/// The most recent version of the <see cref="QueryInvites" /> API.
		/// </summary>
		public const int QueryinvitesApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="RegisterPlayers" /> API.
		/// </summary>
		public const int RegisterplayersApiLatest = 2;

		/// <summary>
		/// The most recent version of the <see cref="RejectInvite" /> API.
		/// </summary>
		public const int RejectinviteApiLatest = 1;

		/// <summary>
		/// Search for a matching bucket ID (value is string)
		/// </summary>
		public static readonly Utf8String SearchBucketId = "bucket";

		/// <summary>
		/// Search for empty servers only (value is true/false)
		/// </summary>
		public static readonly Utf8String SearchEmptyServersOnly = "emptyonly";

		/// <summary>
		/// Search for a match with min free space (value is int)
		/// </summary>
		public static readonly Utf8String SearchMinslotsavailable = "minslotsavailable";

		/// <summary>
		/// Search for non empty servers only (value is true/false)
		/// </summary>
		public static readonly Utf8String SearchNonemptyServersOnly = "nonemptyonly";

		/// <summary>
		/// The most recent version of the <see cref="SendInvite" /> API.
		/// </summary>
		public const int SendinviteApiLatest = 1;

		/// <summary>
		/// DEPRECATED! Use <see cref="SessionDetails.SessiondetailsAttributeApiLatest" /> instead.
		/// </summary>
		public const int SessionattributeApiLatest = SessionDetails.SessiondetailsAttributeApiLatest;

		/// <summary>
		/// DEPRECATED! Use <see cref="AttributedataApiLatest" /> instead.
		/// </summary>
		public const int SessionattributedataApiLatest = AttributedataApiLatest;

		/// <summary>
		/// The most recent version of the <see cref="StartSession" /> API.
		/// </summary>
		public const int StartsessionApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="UnregisterPlayers" /> API.
		/// </summary>
		public const int UnregisterplayersApiLatest = 2;

		/// <summary>
		/// The most recent version of the <see cref="UpdateSession" /> API.
		/// </summary>
		public const int UpdatesessionApiLatest = 1;

		/// <summary>
		/// The most recent version of the <see cref="UpdateSessionModification" /> API.
		/// </summary>
		public const int UpdatesessionmodificationApiLatest = 1;

		/// <summary>
		/// Register to receive notifications when a user accepts a session join game via the social overlay.
		/// must call RemoveNotifyJoinSessionAccepted to remove the notification
		/// </summary>
		/// <param name="options">Structure containing information about the request.</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate.</param>
		/// <param name="notificationFn">A callback that is fired when a a notification is received.</param>
		/// <returns>
		/// handle representing the registered callback
		/// </returns>
		public ulong AddNotifyJoinSessionAccepted(ref AddNotifyJoinSessionAcceptedOptions options, object clientData, OnJoinSessionAcceptedCallback notificationFn)
		{
			AddNotifyJoinSessionAcceptedOptionsInternal optionsInternal = new AddNotifyJoinSessionAcceptedOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var notificationFnInternal = new OnJoinSessionAcceptedCallbackInternal(OnJoinSessionAcceptedCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, notificationFn, notificationFnInternal);

			var funcResult = Bindings.EOS_Sessions_AddNotifyJoinSessionAccepted(InnerHandle, ref optionsInternal, clientDataAddress, notificationFnInternal);

			Helper.Dispose(ref optionsInternal);

			Helper.AssignNotificationIdToCallback(clientDataAddress, funcResult);

			return funcResult;
		}

		/// <summary>
		/// Register to receive notifications when a user accepts a session invite via the social overlay.
		/// must call RemoveNotifySessionInviteAccepted to remove the notification
		/// </summary>
		/// <param name="options">Structure containing information about the request.</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate.</param>
		/// <param name="notificationFn">A callback that is fired when a a notification is received.</param>
		/// <returns>
		/// handle representing the registered callback
		/// </returns>
		public ulong AddNotifySessionInviteAccepted(ref AddNotifySessionInviteAcceptedOptions options, object clientData, OnSessionInviteAcceptedCallback notificationFn)
		{
			AddNotifySessionInviteAcceptedOptionsInternal optionsInternal = new AddNotifySessionInviteAcceptedOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var notificationFnInternal = new OnSessionInviteAcceptedCallbackInternal(OnSessionInviteAcceptedCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, notificationFn, notificationFnInternal);

			var funcResult = Bindings.EOS_Sessions_AddNotifySessionInviteAccepted(InnerHandle, ref optionsInternal, clientDataAddress, notificationFnInternal);

			Helper.Dispose(ref optionsInternal);

			Helper.AssignNotificationIdToCallback(clientDataAddress, funcResult);

			return funcResult;
		}

		/// <summary>
		/// Register to receive session invites.
		/// must call RemoveNotifySessionInviteReceived to remove the notification
		/// </summary>
		/// <param name="options">Structure containing information about the session invite notification</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="notificationFn">A callback that is fired when a session invite for a user has been received</param>
		/// <returns>
		/// handle representing the registered callback
		/// </returns>
		public ulong AddNotifySessionInviteReceived(ref AddNotifySessionInviteReceivedOptions options, object clientData, OnSessionInviteReceivedCallback notificationFn)
		{
			AddNotifySessionInviteReceivedOptionsInternal optionsInternal = new AddNotifySessionInviteReceivedOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var notificationFnInternal = new OnSessionInviteReceivedCallbackInternal(OnSessionInviteReceivedCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, notificationFn, notificationFnInternal);

			var funcResult = Bindings.EOS_Sessions_AddNotifySessionInviteReceived(InnerHandle, ref optionsInternal, clientDataAddress, notificationFnInternal);

			Helper.Dispose(ref optionsInternal);

			Helper.AssignNotificationIdToCallback(clientDataAddress, funcResult);

			return funcResult;
		}

		/// <summary>
		/// Create a handle to an existing active session.
		/// </summary>
		/// <param name="options">Structure containing information about the active session to retrieve</param>
		/// <param name="outSessionHandle">The new active session handle or null if there was an error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the session handle was created successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.IncompatibleVersion" /> if the API version passed in is incorrect
		/// <see cref="Result.NotFound" /> if the active session doesn't exist
		/// </returns>
		public Result CopyActiveSessionHandle(ref CopyActiveSessionHandleOptions options, out ActiveSession outSessionHandle)
		{
			CopyActiveSessionHandleOptionsInternal optionsInternal = new CopyActiveSessionHandleOptionsInternal();
			optionsInternal.Set(ref options);

			var outSessionHandleAddress = System.IntPtr.Zero;

			var funcResult = Bindings.EOS_Sessions_CopyActiveSessionHandle(InnerHandle, ref optionsInternal, ref outSessionHandleAddress);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outSessionHandleAddress, out outSessionHandle);

			return funcResult;
		}

		/// <summary>
		/// <see cref="CopySessionHandleByInviteId" /> is used to immediately retrieve a handle to the session information from after notification of an invite
		/// If the call returns an <see cref="Result.Success" /> result, the out parameter, OutSessionHandle, must be passed to <see cref="SessionDetails.Release" /> to release the memory associated with it.
		/// <seealso cref="CopySessionHandleByInviteIdOptions" />
		/// <seealso cref="SessionDetails.Release" />
		/// </summary>
		/// <param name="options">Structure containing the input parameters</param>
		/// <param name="outSessionHandle">out parameter used to receive the session handle</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the information is available and passed out in OutSessionHandle
		/// <see cref="Result.InvalidParameters" /> if you pass an invalid invite ID or a null pointer for the out parameter
		/// <see cref="Result.IncompatibleVersion" /> if the API version passed in is incorrect
		/// <see cref="Result.NotFound" /> if the invite ID cannot be found
		/// </returns>
		public Result CopySessionHandleByInviteId(ref CopySessionHandleByInviteIdOptions options, out SessionDetails outSessionHandle)
		{
			CopySessionHandleByInviteIdOptionsInternal optionsInternal = new CopySessionHandleByInviteIdOptionsInternal();
			optionsInternal.Set(ref options);

			var outSessionHandleAddress = System.IntPtr.Zero;

			var funcResult = Bindings.EOS_Sessions_CopySessionHandleByInviteId(InnerHandle, ref optionsInternal, ref outSessionHandleAddress);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outSessionHandleAddress, out outSessionHandle);

			return funcResult;
		}

		/// <summary>
		/// <see cref="CopySessionHandleByUiEventId" /> is used to immediately retrieve a handle to the session information from after notification of a join game event.
		/// If the call returns an <see cref="Result.Success" /> result, the out parameter, OutSessionHandle, must be passed to <see cref="SessionDetails.Release" /> to release the memory associated with it.
		/// <seealso cref="CopySessionHandleByUiEventIdOptions" />
		/// <seealso cref="SessionDetails.Release" />
		/// </summary>
		/// <param name="options">Structure containing the input parameters</param>
		/// <param name="outSessionHandle">out parameter used to receive the session handle</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the information is available and passed out in OutSessionHandle
		/// <see cref="Result.InvalidParameters" /> if you pass an invalid invite ID or a null pointer for the out parameter
		/// <see cref="Result.IncompatibleVersion" /> if the API version passed in is incorrect
		/// <see cref="Result.NotFound" /> if the invite ID cannot be found
		/// </returns>
		public Result CopySessionHandleByUiEventId(ref CopySessionHandleByUiEventIdOptions options, out SessionDetails outSessionHandle)
		{
			CopySessionHandleByUiEventIdOptionsInternal optionsInternal = new CopySessionHandleByUiEventIdOptionsInternal();
			optionsInternal.Set(ref options);

			var outSessionHandleAddress = System.IntPtr.Zero;

			var funcResult = Bindings.EOS_Sessions_CopySessionHandleByUiEventId(InnerHandle, ref optionsInternal, ref outSessionHandleAddress);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outSessionHandleAddress, out outSessionHandle);

			return funcResult;
		}

		/// <summary>
		/// <see cref="CopySessionHandleForPresence" /> is used to immediately retrieve a handle to the session information which was marked with bPresenceEnabled on create or join.
		/// If the call returns an <see cref="Result.Success" /> result, the out parameter, OutSessionHandle, must be passed to <see cref="SessionDetails.Release" /> to release the memory associated with it.
		/// <seealso cref="CopySessionHandleForPresenceOptions" />
		/// <seealso cref="SessionDetails.Release" />
		/// </summary>
		/// <param name="options">Structure containing the input parameters</param>
		/// <param name="outSessionHandle">out parameter used to receive the session handle</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the information is available and passed out in OutSessionHandle
		/// <see cref="Result.InvalidParameters" /> if you pass an invalid invite ID or a null pointer for the out parameter
		/// <see cref="Result.IncompatibleVersion" /> if the API version passed in is incorrect
		/// <see cref="Result.NotFound" /> if there is no session with bPresenceEnabled
		/// </returns>
		public Result CopySessionHandleForPresence(ref CopySessionHandleForPresenceOptions options, out SessionDetails outSessionHandle)
		{
			CopySessionHandleForPresenceOptionsInternal optionsInternal = new CopySessionHandleForPresenceOptionsInternal();
			optionsInternal.Set(ref options);

			var outSessionHandleAddress = System.IntPtr.Zero;

			var funcResult = Bindings.EOS_Sessions_CopySessionHandleForPresence(InnerHandle, ref optionsInternal, ref outSessionHandleAddress);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outSessionHandleAddress, out outSessionHandle);

			return funcResult;
		}

		/// <summary>
		/// Creates a session modification handle (<see cref="SessionModification" />). The session modification handle is used to build a new session and can be applied with <see cref="UpdateSession" />
		/// The <see cref="SessionModification" /> must be released by calling <see cref="SessionModification.Release" /> once it no longer needed.
		/// <seealso cref="SessionModification.Release" />
		/// <seealso cref="UpdateSession" />
		/// <seealso cref="SessionModification" />
		/// </summary>
		/// <param name="options">Required fields for the creation of a session such as a name, bucketid, and max players</param>
		/// <param name="outSessionModificationHandle">Pointer to a Session Modification Handle only set if successful</param>
		/// <returns>
		/// <see cref="Result.Success" /> if we successfully created the Session Modification Handle pointed at in OutSessionModificationHandle, or an error result if the input data was invalid
		/// </returns>
		public Result CreateSessionModification(ref CreateSessionModificationOptions options, out SessionModification outSessionModificationHandle)
		{
			CreateSessionModificationOptionsInternal optionsInternal = new CreateSessionModificationOptionsInternal();
			optionsInternal.Set(ref options);

			var outSessionModificationHandleAddress = System.IntPtr.Zero;

			var funcResult = Bindings.EOS_Sessions_CreateSessionModification(InnerHandle, ref optionsInternal, ref outSessionModificationHandleAddress);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outSessionModificationHandleAddress, out outSessionModificationHandle);

			return funcResult;
		}

		/// <summary>
		/// Create a session search handle. This handle may be modified to include various search parameters.
		/// Searching is possible in three methods, all mutually exclusive
		/// - set the session ID to find a specific session
		/// - set the target user ID to find a specific user
		/// - set session parameters to find an array of sessions that match the search criteria
		/// </summary>
		/// <param name="options">Structure containing required parameters such as the maximum number of search results</param>
		/// <param name="outSessionSearchHandle">The new search handle or null if there was an error creating the search handle</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the search creation completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// </returns>
		public Result CreateSessionSearch(ref CreateSessionSearchOptions options, out SessionSearch outSessionSearchHandle)
		{
			CreateSessionSearchOptionsInternal optionsInternal = new CreateSessionSearchOptionsInternal();
			optionsInternal.Set(ref options);

			var outSessionSearchHandleAddress = System.IntPtr.Zero;

			var funcResult = Bindings.EOS_Sessions_CreateSessionSearch(InnerHandle, ref optionsInternal, ref outSessionSearchHandleAddress);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outSessionSearchHandleAddress, out outSessionSearchHandle);

			return funcResult;
		}

		/// <summary>
		/// Destroy a session given a session name
		/// </summary>
		/// <param name="options">Structure containing information about the session to be destroyed</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the destroy operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the destroy completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.AlreadyPending" /> if the session is already marked for destroy
		/// <see cref="Result.NotFound" /> if a session to be destroyed does not exist
		/// </returns>
		public void DestroySession(ref DestroySessionOptions options, object clientData, OnDestroySessionCallback completionDelegate)
		{
			DestroySessionOptionsInternal optionsInternal = new DestroySessionOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnDestroySessionCallbackInternal(OnDestroySessionCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_DestroySession(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Dump the contents of active sessions that exist locally to the log output, purely for debug purposes
		/// </summary>
		/// <param name="options">Options related to dumping session state such as the session name</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the output operation completes successfully
		/// <see cref="Result.NotFound" /> if the session specified does not exist
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// </returns>
		public Result DumpSessionState(ref DumpSessionStateOptions options)
		{
			DumpSessionStateOptionsInternal optionsInternal = new DumpSessionStateOptionsInternal();
			optionsInternal.Set(ref options);

			var funcResult = Bindings.EOS_Sessions_DumpSessionState(InnerHandle, ref optionsInternal);

			Helper.Dispose(ref optionsInternal);

			return funcResult;
		}

		/// <summary>
		/// Mark a session as ended, making it available to find if "join in progress" was disabled. The session may be started again if desired
		/// </summary>
		/// <param name="options">Structure containing information about the session to be ended</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the end operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the end completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.SessionsOutOfSync" /> if the session is out of sync and will be updated on the next connection with the backend
		/// <see cref="Result.NotFound" /> if a session to be ended does not exist
		/// </returns>
		public void EndSession(ref EndSessionOptions options, object clientData, OnEndSessionCallback completionDelegate)
		{
			EndSessionOptionsInternal optionsInternal = new EndSessionOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnEndSessionCallbackInternal(OnEndSessionCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_EndSession(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Get the number of known invites for a given user
		/// </summary>
		/// <param name="options">the Options associated with retrieving the current invite count</param>
		/// <returns>
		/// number of known invites for a given user or 0 if there is an error
		/// </returns>
		public uint GetInviteCount(ref GetInviteCountOptions options)
		{
			GetInviteCountOptionsInternal optionsInternal = new GetInviteCountOptionsInternal();
			optionsInternal.Set(ref options);

			var funcResult = Bindings.EOS_Sessions_GetInviteCount(InnerHandle, ref optionsInternal);

			Helper.Dispose(ref optionsInternal);

			return funcResult;
		}

		/// <summary>
		/// Retrieve an invite ID from a list of active invites for a given user
		/// <seealso cref="GetInviteCount" />
		/// <seealso cref="CopySessionHandleByInviteId" />
		/// </summary>
		/// <param name="options">Structure containing the input parameters</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the input is valid and an invite ID was returned
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.NotFound" /> if the invite doesn't exist
		/// </returns>
		public Result GetInviteIdByIndex(ref GetInviteIdByIndexOptions options, out Utf8String outBuffer)
		{
			GetInviteIdByIndexOptionsInternal optionsInternal = new GetInviteIdByIndexOptionsInternal();
			optionsInternal.Set(ref options);

			int inOutBufferLength = InviteidMaxLength + 1;
			System.IntPtr outBufferAddress = Helper.AddAllocation(inOutBufferLength);

			var funcResult = Bindings.EOS_Sessions_GetInviteIdByIndex(InnerHandle, ref optionsInternal, outBufferAddress, ref inOutBufferLength);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outBufferAddress, out outBuffer);
			Helper.Dispose(ref outBufferAddress);

			return funcResult;
		}

		/// <summary>
		/// <see cref="IsUserInSession" /> returns whether or not a given user can be found in a specified session
		/// </summary>
		/// <param name="options">Structure containing the input parameters</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the user is found in the specified session
		/// <see cref="Result.NotFound" /> if the user is not found in the specified session
		/// <see cref="Result.InvalidParameters" /> if you pass an invalid invite ID or a null pointer for the out parameter
		/// <see cref="Result.IncompatibleVersion" /> if the API version passed in is incorrect
		/// <see cref="Result.InvalidProductUserID" /> if an invalid target user is specified
		/// <see cref="Result.SessionsInvalidSession" /> if the session specified is invalid
		/// </returns>
		public Result IsUserInSession(ref IsUserInSessionOptions options)
		{
			IsUserInSessionOptionsInternal optionsInternal = new IsUserInSessionOptionsInternal();
			optionsInternal.Set(ref options);

			var funcResult = Bindings.EOS_Sessions_IsUserInSession(InnerHandle, ref optionsInternal);

			Helper.Dispose(ref optionsInternal);

			return funcResult;
		}

		/// <summary>
		/// Join a session, creating a local session under a given session name. Backend will validate various conditions to make sure it is possible to join the session.
		/// </summary>
		/// <param name="options">Structure containing information about the session to be joined</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the join operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the join completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.SessionsSessionAlreadyExists" /> if the session is already exists or is in the process of being joined
		/// </returns>
		public void JoinSession(ref JoinSessionOptions options, object clientData, OnJoinSessionCallback completionDelegate)
		{
			JoinSessionOptionsInternal optionsInternal = new JoinSessionOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnJoinSessionCallbackInternal(OnJoinSessionCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_JoinSession(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Retrieve all existing invites for a single user
		/// </summary>
		/// <param name="options">Structure containing information about the invites to query</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the query invites operation completes, either successfully or in error</param>
		public void QueryInvites(ref QueryInvitesOptions options, object clientData, OnQueryInvitesCallback completionDelegate)
		{
			QueryInvitesOptionsInternal optionsInternal = new QueryInvitesOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnQueryInvitesCallbackInternal(OnQueryInvitesCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_QueryInvites(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Register a group of players with the session, allowing them to invite others or otherwise indicate they are part of the session for determining a full session
		/// </summary>
		/// <param name="options">Structure containing information about the session and players to be registered</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the registration operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the register completes successfully
		/// <see cref="Result.NoChange" /> if the players to register registered previously
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.SessionsOutOfSync" /> if the session is out of sync and will be updated on the next connection with the backend
		/// <see cref="Result.NotFound" /> if a session to register players does not exist
		/// </returns>
		public void RegisterPlayers(ref RegisterPlayersOptions options, object clientData, OnRegisterPlayersCallback completionDelegate)
		{
			RegisterPlayersOptionsInternal optionsInternal = new RegisterPlayersOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnRegisterPlayersCallbackInternal(OnRegisterPlayersCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_RegisterPlayers(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Reject an invite from another player.
		/// </summary>
		/// <param name="options">Structure containing information about the invite to reject</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the reject invite operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the invite rejection completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.NotFound" /> if the invite does not exist
		/// </returns>
		public void RejectInvite(ref RejectInviteOptions options, object clientData, OnRejectInviteCallback completionDelegate)
		{
			RejectInviteOptionsInternal optionsInternal = new RejectInviteOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnRejectInviteCallbackInternal(OnRejectInviteCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_RejectInvite(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Unregister from receiving notifications when a user accepts a session join game via the social overlay.
		/// </summary>
		/// <param name="inId">Handle representing the registered callback</param>
		public void RemoveNotifyJoinSessionAccepted(ulong inId)
		{
			Bindings.EOS_Sessions_RemoveNotifyJoinSessionAccepted(InnerHandle, inId);

			Helper.RemoveCallbackByNotificationId(inId);
		}

		/// <summary>
		/// Unregister from receiving notifications when a user accepts a session invite via the social overlay.
		/// </summary>
		/// <param name="inId">Handle representing the registered callback</param>
		public void RemoveNotifySessionInviteAccepted(ulong inId)
		{
			Bindings.EOS_Sessions_RemoveNotifySessionInviteAccepted(InnerHandle, inId);

			Helper.RemoveCallbackByNotificationId(inId);
		}

		/// <summary>
		/// Unregister from receiving session invites.
		/// </summary>
		/// <param name="inId">Handle representing the registered callback</param>
		public void RemoveNotifySessionInviteReceived(ulong inId)
		{
			Bindings.EOS_Sessions_RemoveNotifySessionInviteReceived(InnerHandle, inId);

			Helper.RemoveCallbackByNotificationId(inId);
		}

		/// <summary>
		/// Send an invite to another player. User must have created the session or be registered in the session or else the call will fail
		/// </summary>
		/// <param name="options">Structure containing information about the session and player to invite</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the send invite operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the send invite completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.NotFound" /> if the session to send the invite from does not exist
		/// </returns>
		public void SendInvite(ref SendInviteOptions options, object clientData, OnSendInviteCallback completionDelegate)
		{
			SendInviteOptionsInternal optionsInternal = new SendInviteOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnSendInviteCallbackInternal(OnSendInviteCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_SendInvite(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Mark a session as started, making it unable to find if session properties indicate "join in progress" is not available
		/// </summary>
		/// <param name="options">Structure containing information about the session to be started</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the start operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the start completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.SessionsOutOfSync" /> if the session is out of sync and will be updated on the next connection with the backend
		/// <see cref="Result.NotFound" /> if a session to be started does not exist
		/// </returns>
		public void StartSession(ref StartSessionOptions options, object clientData, OnStartSessionCallback completionDelegate)
		{
			StartSessionOptionsInternal optionsInternal = new StartSessionOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnStartSessionCallbackInternal(OnStartSessionCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_StartSession(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Unregister a group of players with the session, freeing up space for others to join
		/// </summary>
		/// <param name="options">Structure containing information about the session and players to be unregistered</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the unregistration operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the unregister completes successfully
		/// <see cref="Result.NoChange" /> if the players to unregister were not found
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.SessionsOutOfSync" /> if the session is out of sync and will be updated on the next connection with the backend
		/// <see cref="Result.NotFound" /> if a session to be unregister players does not exist
		/// </returns>
		public void UnregisterPlayers(ref UnregisterPlayersOptions options, object clientData, OnUnregisterPlayersCallback completionDelegate)
		{
			UnregisterPlayersOptionsInternal optionsInternal = new UnregisterPlayersOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnUnregisterPlayersCallbackInternal(OnUnregisterPlayersCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_UnregisterPlayers(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Update a session given a session modification handle created by <see cref="CreateSessionModification" /> or <see cref="UpdateSessionModification" />
		/// </summary>
		/// <param name="options">Structure containing information about the session to be updated</param>
		/// <param name="clientData">Arbitrary data that is passed back to you in the CompletionDelegate</param>
		/// <param name="completionDelegate">A callback that is fired when the update operation completes, either successfully or in error</param>
		/// <returns>
		/// <see cref="Result.Success" /> if the update completes successfully
		/// <see cref="Result.InvalidParameters" /> if any of the options are incorrect
		/// <see cref="Result.SessionsOutOfSync" /> if the session is out of sync and will be updated on the next connection with the backend
		/// <see cref="Result.NotFound" /> if a session to be updated does not exist
		/// </returns>
		public void UpdateSession(ref UpdateSessionOptions options, object clientData, OnUpdateSessionCallback completionDelegate)
		{
			UpdateSessionOptionsInternal optionsInternal = new UpdateSessionOptionsInternal();
			optionsInternal.Set(ref options);

			var clientDataAddress = System.IntPtr.Zero;

			var completionDelegateInternal = new OnUpdateSessionCallbackInternal(OnUpdateSessionCallbackInternalImplementation);
			Helper.AddCallback(out clientDataAddress, clientData, completionDelegate, completionDelegateInternal);

			Bindings.EOS_Sessions_UpdateSession(InnerHandle, ref optionsInternal, clientDataAddress, completionDelegateInternal);

			Helper.Dispose(ref optionsInternal);
		}

		/// <summary>
		/// Creates a session modification handle (<see cref="SessionModification" />). The session modification handle is used to modify an existing session and can be applied with <see cref="UpdateSession" />.
		/// The <see cref="SessionModification" /> must be released by calling <see cref="SessionModification.Release" /> once it is no longer needed.
		/// <seealso cref="SessionModification.Release" />
		/// <seealso cref="UpdateSession" />
		/// <seealso cref="SessionModification" />
		/// </summary>
		/// <param name="options">Required fields such as session name</param>
		/// <param name="outSessionModificationHandle">Pointer to a Session Modification Handle only set if successful</param>
		/// <returns>
		/// <see cref="Result.Success" /> if we successfully created the Session Modification Handle pointed at in OutSessionModificationHandle, or an error result if the input data was invalid
		/// </returns>
		public Result UpdateSessionModification(ref UpdateSessionModificationOptions options, out SessionModification outSessionModificationHandle)
		{
			UpdateSessionModificationOptionsInternal optionsInternal = new UpdateSessionModificationOptionsInternal();
			optionsInternal.Set(ref options);

			var outSessionModificationHandleAddress = System.IntPtr.Zero;

			var funcResult = Bindings.EOS_Sessions_UpdateSessionModification(InnerHandle, ref optionsInternal, ref outSessionModificationHandleAddress);

			Helper.Dispose(ref optionsInternal);

			Helper.Get(outSessionModificationHandleAddress, out outSessionModificationHandle);

			return funcResult;
		}

		[MonoPInvokeCallback(typeof(OnDestroySessionCallbackInternal))]
		internal static void OnDestroySessionCallbackInternalImplementation(ref DestroySessionCallbackInfoInternal data)
		{
			OnDestroySessionCallback callback;
			DestroySessionCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnEndSessionCallbackInternal))]
		internal static void OnEndSessionCallbackInternalImplementation(ref EndSessionCallbackInfoInternal data)
		{
			OnEndSessionCallback callback;
			EndSessionCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnJoinSessionAcceptedCallbackInternal))]
		internal static void OnJoinSessionAcceptedCallbackInternalImplementation(ref JoinSessionAcceptedCallbackInfoInternal data)
		{
			OnJoinSessionAcceptedCallback callback;
			JoinSessionAcceptedCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnJoinSessionCallbackInternal))]
		internal static void OnJoinSessionCallbackInternalImplementation(ref JoinSessionCallbackInfoInternal data)
		{
			OnJoinSessionCallback callback;
			JoinSessionCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnQueryInvitesCallbackInternal))]
		internal static void OnQueryInvitesCallbackInternalImplementation(ref QueryInvitesCallbackInfoInternal data)
		{
			OnQueryInvitesCallback callback;
			QueryInvitesCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnRegisterPlayersCallbackInternal))]
		internal static void OnRegisterPlayersCallbackInternalImplementation(ref RegisterPlayersCallbackInfoInternal data)
		{
			OnRegisterPlayersCallback callback;
			RegisterPlayersCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnRejectInviteCallbackInternal))]
		internal static void OnRejectInviteCallbackInternalImplementation(ref RejectInviteCallbackInfoInternal data)
		{
			OnRejectInviteCallback callback;
			RejectInviteCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnSendInviteCallbackInternal))]
		internal static void OnSendInviteCallbackInternalImplementation(ref SendInviteCallbackInfoInternal data)
		{
			OnSendInviteCallback callback;
			SendInviteCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnSessionInviteAcceptedCallbackInternal))]
		internal static void OnSessionInviteAcceptedCallbackInternalImplementation(ref SessionInviteAcceptedCallbackInfoInternal data)
		{
			OnSessionInviteAcceptedCallback callback;
			SessionInviteAcceptedCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnSessionInviteReceivedCallbackInternal))]
		internal static void OnSessionInviteReceivedCallbackInternalImplementation(ref SessionInviteReceivedCallbackInfoInternal data)
		{
			OnSessionInviteReceivedCallback callback;
			SessionInviteReceivedCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnStartSessionCallbackInternal))]
		internal static void OnStartSessionCallbackInternalImplementation(ref StartSessionCallbackInfoInternal data)
		{
			OnStartSessionCallback callback;
			StartSessionCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnUnregisterPlayersCallbackInternal))]
		internal static void OnUnregisterPlayersCallbackInternalImplementation(ref UnregisterPlayersCallbackInfoInternal data)
		{
			OnUnregisterPlayersCallback callback;
			UnregisterPlayersCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}

		[MonoPInvokeCallback(typeof(OnUpdateSessionCallbackInternal))]
		internal static void OnUpdateSessionCallbackInternalImplementation(ref UpdateSessionCallbackInfoInternal data)
		{
			OnUpdateSessionCallback callback;
			UpdateSessionCallbackInfo callbackInfo;
			if (Helper.TryGetAndRemoveCallback(ref data, out callback, out callbackInfo))
			{
				callback(ref callbackInfo);
			}
		}
	}
}