connected-spaces-platform.unity.core 4.10.0-prerelease3

package/Source/Systems/Users/UserSystem.cs

@@ -0,0 +1,1468 @@
+// WARNING: DO NOT EDIT THIS FILE! IT IS A GENERATED FILE AND
+//   ANY CHANGES YOU MAKE WILL BE OVERWRITTEN ON THE NEXT BUILD
+
+#nullable enable annotations
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Threading.Tasks;
+
+namespace Csp.Systems
+{
+    /// @ingroup User System
+    /// <summary>Public facing system that allows interfacing with Magnopus Connected Services' user service.</summary>
+    /// <remarks>Offers methods for creating accounts, authenticating, and retrieving user profiles.</remarks>
+
+    public class UserSystem : Csp.Systems.SystemBase
+    {
+        internal override string _safeTypeName { get; } = "csp_systems_UserSystem";
+
+        #region P/Invoke
+#pragma warning disable IDE1006
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_SetNewLoginTokenReceivedCallback_void_NewLoginTokenReceivedCallback(
+            IntPtr @class,
+            SetNewLoginTokenReceivedCallbackCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_Dtor(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_UserSystem_GetLoginStateC_LoginStateRC(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_Login_void_StringRC_StringRC_StringRC_LoginStateResultCallback(
+            IntPtr @class,
+            string UserName,
+            string Email,
+            string Password,
+            LoginCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_LoginWithToken_void_StringRC_StringRC_LoginStateResultCallback(
+            IntPtr @class,
+            string UserId,
+            string LoginToken,
+            LoginWithTokenCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_LoginAsGuest_void_LoginStateResultCallback(
+            IntPtr @class,
+            LoginAsGuestCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_UserSystem_GetSupportedThirdPartyAuthenticationProvidersC_Array(
+            IntPtr @class
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_GetThirdPartyProviderAuthoriseURL_void_EThirdPartyAuthenticationProviders_StringRC_StringResultCallback(
+            IntPtr @class,
+            EThirdPartyAuthenticationProviders AuthProvider,
+            string RedirectURL,
+            GetThirdPartyProviderAuthoriseURLCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_LoginToThirdPartyAuthenticationProvider_void_StringRC_StringRC_LoginStateResultCallback(
+            IntPtr @class,
+            string ThirdPartyToken,
+            string ThirdPartyStateId,
+            LoginToThirdPartyAuthenticationProviderCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_LoginAsGuestWithId_void_StringRC_LoginStateResultCallback(
+            IntPtr @class,
+            string DeviceId,
+            LoginAsGuestWithIdCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_ExchangeKey_void_StringRC_StringRC_LoginStateResultCallback(
+            IntPtr @class,
+            string UserId,
+            string Key,
+            ExchangeKeyCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_Logout_void_LogoutResultCallback(
+            IntPtr @class,
+            LogoutCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_CreateUser_void_StringRC_StringRC_StringRC_StringRC_bool_StringRC_StringRC_ProfileResultCallback(
+            IntPtr @class,
+            string UserName,
+            string DisplayName,
+            string Email,
+            string Password,
+            bool ReceiveNewsletter,
+            string RedirectUrl,
+            string InviteToken,
+            CreateUserCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_UpgradeGuestAccount_void_StringRC_StringRC_StringRC_StringRC_ProfileResultCallback(
+            IntPtr @class,
+            string UserName,
+            string DisplayName,
+            string Email,
+            string Password,
+            UpgradeGuestAccountCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_ConfirmUserEmail_void_NullResultCallback(
+            IntPtr @class,
+            ConfirmUserEmailCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_ResetUserPassword_void_StringRC_StringRC_NullResultCallback(
+            IntPtr @class,
+            string Token,
+            string NewPassword,
+            ResetUserPasswordCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_UpdateUserDisplayName_void_StringRC_StringRC_NullResultCallback(
+            IntPtr @class,
+            string UserId,
+            string NewUserDisplayName,
+            UpdateUserDisplayNameCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_DeleteUser_void_StringRC_NullResultCallback(
+            IntPtr @class,
+            string UserId,
+            DeleteUserCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_ForgotPassword_void_StringRC_StringRC_bool_NullResultCallback(
+            IntPtr @class,
+            string Email,
+            string RedirectUrl,
+            bool UseTokenChangePasswordUrl,
+            ForgotPasswordCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_GetProfileByUserId_void_StringRC_ProfileResultCallback(
+            IntPtr @class,
+            string InUserId,
+            GetProfileByUserIdCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_GetProfilesByUserId_void_ArrayRC_BasicProfilesResultCallback(
+            IntPtr @class,
+            IntPtr InUserIds,
+            GetProfilesByUserIdCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_Ping_void_PingResponseReceivedCallback(
+            IntPtr @class,
+            PingCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_UserSystem_GetAgoraUserToken_void_AgoraUserTokenParamsRC_UserTokenResultCallback(
+            IntPtr @class,
+            IntPtr Params,
+            GetAgoraUserTokenCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_UserSystem_Ctor();
+
+#pragma warning restore IDE1006
+        #endregion
+
+        internal UserSystem(NativePointer ptr) : base(ptr) { }
+
+        public UserSystem(Csp.Systems.SystemBase baseInstance)
+            : base(new NativePointer(baseInstance._ptr, baseInstance._ownsPtr ? (byte)1 : (byte)0))
+        {
+            // Prevent previous instance from freeing underlying pointer when destroyed
+            baseInstance._ownsPtr = false;
+        }
+
+        delegate void SetNewLoginTokenReceivedCallbackCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void LoginCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void LoginWithTokenCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void LoginAsGuestCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetThirdPartyProviderAuthoriseURLCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void LoginToThirdPartyAuthenticationProviderCallbackDelegate(
+            IntPtr _StateObject__,
+            NativePointer Result
+        );
+
+        delegate void LoginAsGuestWithIdCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void ExchangeKeyCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void LogoutCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void CreateUserCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpgradeGuestAccountCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void ConfirmUserEmailCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void ResetUserPasswordCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateUserDisplayNameCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void DeleteUserCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void ForgotPasswordCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetProfileByUserIdCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetProfilesByUserIdCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void PingCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetAgoraUserTokenCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        readonly List<GCHandle> eventHandles = new List<GCHandle>();
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (SetNewLoginTokenReceivedCallbackCallbackDelegate))]
+#endif
+        static void SetNewLoginTokenReceivedCallbackCallbackDelegateFunction(
+            IntPtr _StateObject__,
+            NativePointer _Result
+        ) {
+            var _handle = (GCHandle)_StateObject__;
+            var _this = (UserSystem)_handle.Target;
+            _this.RealOnNewLoginTokenReceived?.Invoke(_this, new Csp.Systems.LoginTokenReceived(_Result));
+        }
+
+        static readonly SetNewLoginTokenReceivedCallbackCallbackDelegate OnNewLoginTokenReceivedDelegateInstance =
+            SetNewLoginTokenReceivedCallbackCallbackDelegateFunction;
+
+        bool OnNewLoginTokenReceivedInitialised = false;
+        event EventHandler<Csp.Systems.LoginTokenReceived>? RealOnNewLoginTokenReceived;
+        public event EventHandler<Csp.Systems.LoginTokenReceived> OnNewLoginTokenReceived
+        {
+            add
+            {
+                if (!OnNewLoginTokenReceivedInitialised)
+                {
+                    var handle = GCHandle.Alloc(this);
+                    csp_systems_UserSystem_SetNewLoginTokenReceivedCallback_void_NewLoginTokenReceivedCallback(
+                        _ptr,
+                        OnNewLoginTokenReceivedDelegateInstance,
+                        (IntPtr)handle
+                    );
+                    eventHandles.Add(handle);
+                    OnNewLoginTokenReceivedInitialised = true;
+                }
+
+                RealOnNewLoginTokenReceived += value;
+            }
+            remove { RealOnNewLoginTokenReceived -= value; }
+        }
+
+        ~UserSystem()
+        {
+            //RealDispose();
+        }
+
+        void RealDispose()
+        {
+            if (_ownsPtr && !_disposed)
+            {
+                csp_systems_UserSystem_Dtor(_ptr);
+                _disposed = true;
+            }
+
+            _disposed = true;
+        }
+
+        new public void Dispose()
+        {
+            RealDispose();
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>Get the current login state.</summary>
+        /// <returns>Current login state</returns>
+
+
+        public Csp.Systems.LoginState GetLoginState()
+        {
+            var _result = new Csp.Systems.LoginState(csp_systems_UserSystem_GetLoginStateC_LoginStateRC(_ptr));
+
+            return _result;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (LoginCallbackDelegate))]
+#endif
+        static void LoginCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.LoginStateResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.LoginStateResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly LoginCallbackDelegate LoginDelegateInstance = LoginCallbackDelegateFunction;
+
+        /// <summary>Log in to Magnopus Connected Services services using a username-password or email-password combination.</summary>
+                /// <param name="UserName">Csp::common::string</param>
+                /// <param name="Email">Csp::common::string</param>
+                /// <param name="Password">Csp::common::string</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.LoginStateResult> Login(string UserName, string Email, string Password)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.LoginStateResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_Login_void_StringRC_StringRC_StringRC_LoginStateResultCallback(
+                _ptr,
+                UserName,
+                Email,
+                Password,
+                LoginDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (LoginWithTokenCallbackDelegate))]
+#endif
+        static void LoginWithTokenCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.LoginStateResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.LoginStateResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly LoginWithTokenCallbackDelegate LoginWithTokenDelegateInstance =
+            LoginWithTokenCallbackDelegateFunction;
+
+        /// <summary>Log in to Magnopus Connected Services using a login token</summary>
+                /// <remarks>The login token can be obtained after using the Login API with credentials and having registered a callback through</remarks>
+                /// <remarks>SetNewLoginTokenReceivedCallback. If the login is successful in the callback result the token and it's expiration time will be provided.</remarks>
+                /// <param name="UserId">The user id associated with this login token</param>
+                /// <param name="LoginToken">Token to be used for authenticating</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.LoginStateResult> LoginWithToken(string UserId, string LoginToken)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.LoginStateResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_LoginWithToken_void_StringRC_StringRC_LoginStateResultCallback(
+                _ptr,
+                UserId,
+                LoginToken,
+                LoginWithTokenDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (LoginAsGuestCallbackDelegate))]
+#endif
+        static void LoginAsGuestCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.LoginStateResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.LoginStateResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly LoginAsGuestCallbackDelegate LoginAsGuestDelegateInstance =
+            LoginAsGuestCallbackDelegateFunction;
+
+        /// <summary>Log in to Magnopus Connected Services as a guest.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.LoginStateResult> LoginAsGuest()
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.LoginStateResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_LoginAsGuest_void_LoginStateResultCallback(
+                _ptr,
+                LoginAsGuestDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        /// @ingroup Third Party Authentication
+        /// <summary>As a Connected Spaces Platform user the 3rd party authentication flow consists of two steps, first calling</summary>
+        /// <remarks>GetThirdPartyProviderAuthoriseURL followed by LoginToThirdPartyAuthenticationProvider You can see a Sequence Diagram with all the parties</remarks>
+        /// <remarks>involved including what a Client should be calling and when here https://miro.com/app/board/uXjVPflpu98=/.</remarks>
+        /// <summary>API to retrieve the Connected Spaces Platform supported 3rd party authentication providers</summary>
+        /// <returns>Array of Connected Spaces Platform supported 3rd party authentication providers</returns>
+
+
+        public Csp.Common.Array<Csp.Systems.EThirdPartyAuthenticationProviders> GetSupportedThirdPartyAuthenticationProviders()
+        {
+            var _result = new Csp.Common.Array<Csp.Systems.EThirdPartyAuthenticationProviders>(
+                csp_systems_UserSystem_GetSupportedThirdPartyAuthenticationProvidersC_Array(_ptr)
+            );
+
+            return _result;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetThirdPartyProviderAuthoriseURLCallbackDelegate))]
+#endif
+        static void GetThirdPartyProviderAuthoriseURLCallbackDelegateFunction(
+            IntPtr _StateObject__,
+            NativePointer _Result
+        ) {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.StringResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.StringResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetThirdPartyProviderAuthoriseURLCallbackDelegate GetThirdPartyProviderAuthoriseURLDelegateInstance =
+            GetThirdPartyProviderAuthoriseURLCallbackDelegateFunction;
+
+        /// <summary>First step of the 3rd party authentication flow</summary>
+                /// <remarks>If you call this API but for some reason you'd like to call this again, this is supported, the params you pass second time will replace the</remarks>
+                /// <remarks>ones you've passed initially</remarks>
+                /// <param name="AuthProvider">One of the supported authentication providers</param>
+                /// <param name="RedirectURL">The redirecturl you want to be used for this authentication flow</param>
+                /// <param name="Callback">Callback that contains the authorise url that the client should be navigating next before moving to the</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.StringResult> GetThirdPartyProviderAuthoriseURL(
+            Csp.Systems.EThirdPartyAuthenticationProviders AuthProvider,
+            string RedirectURL
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.StringResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_GetThirdPartyProviderAuthoriseURL_void_EThirdPartyAuthenticationProviders_StringRC_StringResultCallback(
+                _ptr,
+                AuthProvider,
+                RedirectURL,
+                GetThirdPartyProviderAuthoriseURLDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (LoginToThirdPartyAuthenticationProviderCallbackDelegate))]
+#endif
+        static void LoginToThirdPartyAuthenticationProviderCallbackDelegateFunction(
+            IntPtr _StateObject__,
+            NativePointer _Result
+        ) {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.LoginStateResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.LoginStateResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly LoginToThirdPartyAuthenticationProviderCallbackDelegate LoginToThirdPartyAuthenticationProviderDelegateInstance =
+            LoginToThirdPartyAuthenticationProviderCallbackDelegateFunction;
+
+        /// <summary>Second step of the 3rd party authentication flow</summary>
+                /// <remarks>Note: The Authentication Provider and the Redirect URL you've passed in the first step will be used now</remarks>
+                /// <param name="ThirdPartyToken">The authentication token returned by the Provider</param>
+                /// <param name="ThirdPartyStateId">The state Id returned by the Provider</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.LoginStateResult> LoginToThirdPartyAuthenticationProvider(
+            string ThirdPartyToken,
+            string ThirdPartyStateId
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.LoginStateResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_LoginToThirdPartyAuthenticationProvider_void_StringRC_StringRC_LoginStateResultCallback(
+                _ptr,
+                ThirdPartyToken,
+                ThirdPartyStateId,
+                LoginToThirdPartyAuthenticationProviderDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (LoginAsGuestWithIdCallbackDelegate))]
+#endif
+        static void LoginAsGuestWithIdCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.LoginStateResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.LoginStateResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly LoginAsGuestWithIdCallbackDelegate LoginAsGuestWithIdDelegateInstance =
+            LoginAsGuestWithIdCallbackDelegateFunction;
+
+        /// <summary>Log in to Magnopus Connected Services services as a guest.</summary>
+                /// <param name="DeviceId">The device Id to use when logging in</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.LoginStateResult> LoginAsGuestWithId(string DeviceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.LoginStateResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_LoginAsGuestWithId_void_StringRC_LoginStateResultCallback(
+                _ptr,
+                DeviceId,
+                LoginAsGuestWithIdDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (ExchangeKeyCallbackDelegate))]
+#endif
+        static void ExchangeKeyCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.LoginStateResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.LoginStateResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly ExchangeKeyCallbackDelegate ExchangeKeyDelegateInstance = ExchangeKeyCallbackDelegateFunction;
+
+        /// <summary>Log in to Magnopus Connected Services using the given one-time password/key.</summary>
+                /// <param name="UserId">The user id</param>
+                /// <param name="Key">The one-time key to exchange</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.LoginStateResult> ExchangeKey(string UserId, string Key)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.LoginStateResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_ExchangeKey_void_StringRC_StringRC_LoginStateResultCallback(
+                _ptr,
+                UserId,
+                Key,
+                ExchangeKeyDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (LogoutCallbackDelegate))]
+#endif
+        static void LogoutCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.LogoutResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.LogoutResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly LogoutCallbackDelegate LogoutDelegateInstance = LogoutCallbackDelegateFunction;
+
+        /// <summary>Logout from Magnopus Connected Services.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.LogoutResult> Logout()
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.LogoutResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_Logout_void_LogoutResultCallback(_ptr, LogoutDelegateInstance, (IntPtr)handle);
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (CreateUserCallbackDelegate))]
+#endif
+        static void CreateUserCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.ProfileResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.ProfileResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly CreateUserCallbackDelegate CreateUserDelegateInstance = CreateUserCallbackDelegateFunction;
+
+        /// <summary>Creates a new user profile.</summary>
+                /// <param name="UserName">User name associated with the new profile</param>
+                /// <param name="DisplayName">User display name associated with the new profile</param>
+                /// <param name="Email">Email address associated with the new profile</param>
+                /// <param name="Password">Password associated with the new profile</param>
+                /// <param name="ReceiveNewsletter">`true` if the user wants to receive the Magnopus Connected Services newsletter</param>
+                /// <param name="RedirectUrl">The url to redirect the user to after they have registered</param>
+                /// <param name="InviteToken">A token provided to the user that can be used to auto-confirm their account</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.ProfileResult> CreateUser(
+            string? UserName,
+            string? DisplayName,
+            string Email,
+            string Password,
+            bool ReceiveNewsletter,
+            string? RedirectUrl,
+            string? InviteToken
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.ProfileResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_CreateUser_void_StringRC_StringRC_StringRC_StringRC_bool_StringRC_StringRC_ProfileResultCallback(
+                _ptr,
+                UserName,
+                DisplayName,
+                Email,
+                Password,
+                ReceiveNewsletter,
+                RedirectUrl,
+                InviteToken,
+                CreateUserDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpgradeGuestAccountCallbackDelegate))]
+#endif
+        static void UpgradeGuestAccountCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.ProfileResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.ProfileResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly UpgradeGuestAccountCallbackDelegate UpgradeGuestAccountDelegateInstance =
+            UpgradeGuestAccountCallbackDelegateFunction;
+
+        /// <summary>Upgrade guest user to full user profile.</summary>
+                /// <param name="UserName">User name associated with the new profile</param>
+                /// <param name="DisplayName">User display name associated with the new profile</param>
+                /// <param name="Email">Email address associated with the new profile</param>
+                /// <param name="Password">Password associated with the new profile</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.ProfileResult> UpgradeGuestAccount(
+            string UserName,
+            string DisplayName,
+            string Email,
+            string Password
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.ProfileResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_UpgradeGuestAccount_void_StringRC_StringRC_StringRC_StringRC_ProfileResultCallback(
+                _ptr,
+                UserName,
+                DisplayName,
+                Email,
+                Password,
+                UpgradeGuestAccountDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (ConfirmUserEmailCallbackDelegate))]
+#endif
+        static void ConfirmUserEmailCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.NullResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly ConfirmUserEmailCallbackDelegate ConfirmUserEmailDelegateInstance =
+            ConfirmUserEmailCallbackDelegateFunction;
+
+        /// <summary>Send a confirmation email.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> ConfirmUserEmail()
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_ConfirmUserEmail_void_NullResultCallback(
+                _ptr,
+                ConfirmUserEmailDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (ResetUserPasswordCallbackDelegate))]
+#endif
+        static void ResetUserPasswordCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.NullResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly ResetUserPasswordCallbackDelegate ResetUserPasswordDelegateInstance =
+            ResetUserPasswordCallbackDelegateFunction;
+
+        /// <summary>Reset the users password.</summary>
+                /// <param name="Token">Token received through email by user</param>
+                /// <param name="NewPassword">The new password for the associated account</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> ResetUserPassword(string Token, string NewPassword)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_ResetUserPassword_void_StringRC_StringRC_NullResultCallback(
+                _ptr,
+                Token,
+                NewPassword,
+                ResetUserPasswordDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateUserDisplayNameCallbackDelegate))]
+#endif
+        static void UpdateUserDisplayNameCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.NullResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly UpdateUserDisplayNameCallbackDelegate UpdateUserDisplayNameDelegateInstance =
+            UpdateUserDisplayNameCallbackDelegateFunction;
+
+        /// <summary>Updates the user display name information.</summary>
+                /// <param name="UserId">Id of the user that will be updated</param>
+                /// <param name="NewUserDisplayName">New display name that will replace the previous value</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> UpdateUserDisplayName(string UserId, string NewUserDisplayName)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_UpdateUserDisplayName_void_StringRC_StringRC_NullResultCallback(
+                _ptr,
+                UserId,
+                NewUserDisplayName,
+                UpdateUserDisplayNameDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (DeleteUserCallbackDelegate))]
+#endif
+        static void DeleteUserCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.NullResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly DeleteUserCallbackDelegate DeleteUserDelegateInstance = DeleteUserCallbackDelegateFunction;
+
+        /// <summary>Delete the user.</summary>
+                /// <param name="UserId">Id of the user that will be deleted</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> DeleteUser(string UserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_DeleteUser_void_StringRC_NullResultCallback(
+                _ptr,
+                UserId,
+                DeleteUserDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (ForgotPasswordCallbackDelegate))]
+#endif
+        static void ForgotPasswordCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.NullResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly ForgotPasswordCallbackDelegate ForgotPasswordDelegateInstance =
+            ForgotPasswordCallbackDelegateFunction;
+
+        /// <summary>Allow a user to reset their password if forgotten by providing an email address.</summary>
+                /// <param name="Email">Account to recover password for</param>
+                /// <param name="RedirectUrl">The url to redirect the user to after they have registered</param>
+                /// @Param UseTokenChangePasswordUrl bool : if true the link in the email will direct the user to the Token Change URL
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> ForgotPassword(
+            string Email,
+            string? RedirectUrl,
+            bool UseTokenChangePasswordUrl
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_ForgotPassword_void_StringRC_StringRC_bool_NullResultCallback(
+                _ptr,
+                Email,
+                RedirectUrl,
+                UseTokenChangePasswordUrl,
+                ForgotPasswordDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetProfileByUserIdCallbackDelegate))]
+#endif
+        static void GetProfileByUserIdCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.ProfileResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.ProfileResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetProfileByUserIdCallbackDelegate GetProfileByUserIdDelegateInstance =
+            GetProfileByUserIdCallbackDelegateFunction;
+
+        /// <summary>Get a user profile by user ID.</summary>
+                /// <param name="InUserId">The id of the user to get</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.ProfileResult> GetProfileByUserId(string InUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.ProfileResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_GetProfileByUserId_void_StringRC_ProfileResultCallback(
+                _ptr,
+                InUserId,
+                GetProfileByUserIdDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetProfilesByUserIdCallbackDelegate))]
+#endif
+        static void GetProfilesByUserIdCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.BasicProfilesResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.BasicProfilesResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetProfilesByUserIdCallbackDelegate GetProfilesByUserIdDelegateInstance =
+            GetProfilesByUserIdCallbackDelegateFunction;
+
+        /// <summary>Get a list of minimal profiles (avatarId, personalityType, userName, and platform) by user IDs.</summary>
+                /// <param name="InUserIds">An array of user ids to search for users by</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.BasicProfilesResult> GetProfilesByUserId(Csp.Common.Array<string> InUserIds)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.BasicProfilesResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_GetProfilesByUserId_void_ArrayRC_BasicProfilesResultCallback(
+                _ptr,
+                InUserIds._ptr,
+                GetProfilesByUserIdDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (PingCallbackDelegate))]
+#endif
+        static void PingCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.PingResponseReceived>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.PingResponseReceived(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly PingCallbackDelegate PingDelegateInstance = PingCallbackDelegateFunction;
+
+        /// <summary>Ping Magnopus Connected Services</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.PingResponseReceived> Ping()
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.PingResponseReceived>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_Ping_void_PingResponseReceivedCallback(_ptr, PingDelegateInstance, (IntPtr)handle);
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetAgoraUserTokenCallbackDelegate))]
+#endif
+        static void GetAgoraUserTokenCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.AgoraUserTokenResult>)_handle.Target;
+            var _this = (UserSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.AgoraUserTokenResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetAgoraUserTokenCallbackDelegate GetAgoraUserTokenDelegateInstance =
+            GetAgoraUserTokenCallbackDelegateFunction;
+
+        /// <summary>Retrieve User token from Agora</summary>
+                /// <param name="Params">Params to configure the User token</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.AgoraUserTokenResult> GetAgoraUserToken(Csp.Systems.AgoraUserTokenParams Params)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.AgoraUserTokenResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_UserSystem_GetAgoraUserToken_void_AgoraUserTokenParamsRC_UserTokenResultCallback(
+                _ptr,
+                Params._ptr,
+                GetAgoraUserTokenDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        protected UserSystem() { }
+    }
+}
+