// 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 = 3;

		/// <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 = 1;

		/// <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 const string SearchBucketId = "bucket";

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

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

		/// <summary>
		/// Search for non empty servers only (value is true/false)
		/// </summary>
		public const string 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 = 1;

		/// <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.
		/// @note 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(AddNotifyJoinSessionAcceptedOptions options, object clientData, OnJoinSessionAcceptedCallback notificationFn)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<AddNotifyJoinSessionAcceptedOptionsInternal, AddNotifyJoinSessionAcceptedOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryAssignNotificationIdToCallback(clientDataAddress, funcResult);

			return funcResult;
		}

		/// <summary>
		/// Register to receive notifications when a user accepts a session invite via the social overlay.
		/// @note 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(AddNotifySessionInviteAcceptedOptions options, object clientData, OnSessionInviteAcceptedCallback notificationFn)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<AddNotifySessionInviteAcceptedOptionsInternal, AddNotifySessionInviteAcceptedOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryAssignNotificationIdToCallback(clientDataAddress, funcResult);

			return funcResult;
		}

		/// <summary>
		/// Register to receive session invites.
		/// @note 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(AddNotifySessionInviteReceivedOptions options, object clientData, OnSessionInviteReceivedCallback notificationFn)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<AddNotifySessionInviteReceivedOptionsInternal, AddNotifySessionInviteReceivedOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryAssignNotificationIdToCallback(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(CopyActiveSessionHandleOptions options, out ActiveSession outSessionHandle)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<CopyActiveSessionHandleOptionsInternal, CopyActiveSessionHandleOptions>(ref optionsAddress, options);

			var outSessionHandleAddress = System.IntPtr.Zero;

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(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(CopySessionHandleByInviteIdOptions options, out SessionDetails outSessionHandle)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<CopySessionHandleByInviteIdOptionsInternal, CopySessionHandleByInviteIdOptions>(ref optionsAddress, options);

			var outSessionHandleAddress = System.IntPtr.Zero;

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(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(CopySessionHandleByUiEventIdOptions options, out SessionDetails outSessionHandle)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<CopySessionHandleByUiEventIdOptionsInternal, CopySessionHandleByUiEventIdOptions>(ref optionsAddress, options);

			var outSessionHandleAddress = System.IntPtr.Zero;

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(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(CopySessionHandleForPresenceOptions options, out SessionDetails outSessionHandle)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<CopySessionHandleForPresenceOptionsInternal, CopySessionHandleForPresenceOptions>(ref optionsAddress, options);

			var outSessionHandleAddress = System.IntPtr.Zero;

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(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(CreateSessionModificationOptions options, out SessionModification outSessionModificationHandle)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<CreateSessionModificationOptionsInternal, CreateSessionModificationOptions>(ref optionsAddress, options);

			var outSessionModificationHandleAddress = System.IntPtr.Zero;

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(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(CreateSessionSearchOptions options, out SessionSearch outSessionSearchHandle)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<CreateSessionSearchOptionsInternal, CreateSessionSearchOptions>(ref optionsAddress, options);

			var outSessionSearchHandleAddress = System.IntPtr.Zero;

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(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(DestroySessionOptions options, object clientData, OnDestroySessionCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<DestroySessionOptionsInternal, DestroySessionOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_DestroySession(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(DumpSessionStateOptions options)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<DumpSessionStateOptionsInternal, DumpSessionStateOptions>(ref optionsAddress, options);

			var funcResult = Bindings.EOS_Sessions_DumpSessionState(InnerHandle, optionsAddress);

			Helper.TryMarshalDispose(ref optionsAddress);

			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(EndSessionOptions options, object clientData, OnEndSessionCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<EndSessionOptionsInternal, EndSessionOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_EndSession(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(GetInviteCountOptions options)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<GetInviteCountOptionsInternal, GetInviteCountOptions>(ref optionsAddress, options);

			var funcResult = Bindings.EOS_Sessions_GetInviteCount(InnerHandle, optionsAddress);

			Helper.TryMarshalDispose(ref optionsAddress);

			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(GetInviteIdByIndexOptions options, out string outBuffer)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<GetInviteIdByIndexOptionsInternal, GetInviteIdByIndexOptions>(ref optionsAddress, options);

			System.IntPtr outBufferAddress = System.IntPtr.Zero;
			int inOutBufferLength = InviteidMaxLength + 1;
			Helper.TryMarshalAllocate(ref outBufferAddress, inOutBufferLength);

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(outBufferAddress, out outBuffer);
			Helper.TryMarshalDispose(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(IsUserInSessionOptions options)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<IsUserInSessionOptionsInternal, IsUserInSessionOptions>(ref optionsAddress, options);

			var funcResult = Bindings.EOS_Sessions_IsUserInSession(InnerHandle, optionsAddress);

			Helper.TryMarshalDispose(ref optionsAddress);

			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(JoinSessionOptions options, object clientData, OnJoinSessionCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<JoinSessionOptionsInternal, JoinSessionOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_JoinSession(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(QueryInvitesOptions options, object clientData, OnQueryInvitesCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<QueryInvitesOptionsInternal, QueryInvitesOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_QueryInvites(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(RegisterPlayersOptions options, object clientData, OnRegisterPlayersCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<RegisterPlayersOptionsInternal, RegisterPlayersOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_RegisterPlayers(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(RejectInviteOptions options, object clientData, OnRejectInviteCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<RejectInviteOptionsInternal, RejectInviteOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_RejectInvite(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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)
		{
			Helper.TryRemoveCallbackByNotificationId(inId);

			Bindings.EOS_Sessions_RemoveNotifyJoinSessionAccepted(InnerHandle, 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)
		{
			Helper.TryRemoveCallbackByNotificationId(inId);

			Bindings.EOS_Sessions_RemoveNotifySessionInviteAccepted(InnerHandle, inId);
		}

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

			Bindings.EOS_Sessions_RemoveNotifySessionInviteReceived(InnerHandle, 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(SendInviteOptions options, object clientData, OnSendInviteCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<SendInviteOptionsInternal, SendInviteOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_SendInvite(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(StartSessionOptions options, object clientData, OnStartSessionCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<StartSessionOptionsInternal, StartSessionOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_StartSession(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(UnregisterPlayersOptions options, object clientData, OnUnregisterPlayersCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<UnregisterPlayersOptionsInternal, UnregisterPlayersOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_UnregisterPlayers(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(UpdateSessionOptions options, object clientData, OnUpdateSessionCallback completionDelegate)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<UpdateSessionOptionsInternal, UpdateSessionOptions>(ref optionsAddress, options);

			var clientDataAddress = System.IntPtr.Zero;

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

			Bindings.EOS_Sessions_UpdateSession(InnerHandle, optionsAddress, clientDataAddress, completionDelegateInternal);

			Helper.TryMarshalDispose(ref optionsAddress);
		}

		/// <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(UpdateSessionModificationOptions options, out SessionModification outSessionModificationHandle)
		{
			var optionsAddress = System.IntPtr.Zero;
			Helper.TryMarshalSet<UpdateSessionModificationOptionsInternal, UpdateSessionModificationOptions>(ref optionsAddress, options);

			var outSessionModificationHandleAddress = System.IntPtr.Zero;

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

			Helper.TryMarshalDispose(ref optionsAddress);

			Helper.TryMarshalGet(outSessionModificationHandleAddress, out outSessionModificationHandle);

			return funcResult;
		}

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

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

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

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

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

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

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

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

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

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

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

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

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