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

package/Source/Systems/Settings/SettingsSystem.cs

@@ -0,0 +1,999 @@
+// 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 Settings System
+    /// <summary>Public facing system that allows interfacing with Magnopus Connected Services' settings service.</summary>
+    /// <remarks>Offers methods for storing and retrieving client settings.</remarks>
+
+    public class SettingsSystem : Csp.Systems.SystemBase
+    {
+        internal override string _safeTypeName { get; } = "csp_systems_SettingsSystem";
+
+        #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_SettingsSystem_Dtor(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_SetNDAStatus_void_StringRC_bool_NullResultCallback(
+            IntPtr @class,
+            string InUserId,
+            bool InValue,
+            SetNDAStatusCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_GetNDAStatus_void_StringRC_BooleanResultCallback(
+            IntPtr @class,
+            string InUserId,
+            GetNDAStatusCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_SetNewsletterStatus_void_StringRC_bool_NullResultCallback(
+            IntPtr @class,
+            string InUserId,
+            bool InValue,
+            SetNewsletterStatusCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_GetNewsletterStatus_void_StringRC_BooleanResultCallback(
+            IntPtr @class,
+            string InUserId,
+            GetNewsletterStatusCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_AddRecentlyVisitedSpace_void_StringRC_StringC_NullResultCallback(
+            IntPtr @class,
+            string InUserId,
+            string InSpaceID,
+            AddRecentlyVisitedSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_GetRecentlyVisitedSpaces_void_StringRC_StringArrayResultCallback(
+            IntPtr @class,
+            string InUserId,
+            GetRecentlyVisitedSpacesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_ClearRecentlyVisitedSpaces_void_StringRC_NullResultCallback(
+            IntPtr @class,
+            string InUserId,
+            ClearRecentlyVisitedSpacesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_AddBlockedSpace_void_StringRC_StringC_NullResultCallback(
+            IntPtr @class,
+            string InUserId,
+            string InSpaceID,
+            AddBlockedSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_RemoveBlockedSpace_void_StringRC_StringC_NullResultCallback(
+            IntPtr @class,
+            string InUserId,
+            string InSpaceID,
+            RemoveBlockedSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_GetBlockedSpaces_void_StringRC_StringArrayResultCallback(
+            IntPtr @class,
+            string InUserId,
+            GetBlockedSpacesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_ClearBlockedSpaces_void_StringRC_NullResultCallback(
+            IntPtr @class,
+            string InUserId,
+            ClearBlockedSpacesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_UpdateAvatarPortrait_void_StringRC_FileAssetDataSourceRC_NullResultCallback(
+            IntPtr @class,
+            string UserId,
+            IntPtr NewAvatarPortrait,
+            UpdateAvatarPortraitCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_GetAvatarPortrait_void_StringRC_UriResultCallback(
+            IntPtr @class,
+            string UserId,
+            GetAvatarPortraitCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SettingsSystem_UpdateAvatarPortraitWithBuffer_void_StringRC_BufferAssetDataSourceRC_NullResultCallback(
+            IntPtr @class,
+            string UserId,
+            IntPtr NewAvatarPortrait,
+            UpdateAvatarPortraitWithBufferCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_SettingsSystem_Ctor();
+
+#pragma warning restore IDE1006
+        #endregion
+
+        internal SettingsSystem(NativePointer ptr) : base(ptr) { }
+
+        public SettingsSystem(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 SetNDAStatusCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetNDAStatusCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void SetNewsletterStatusCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetNewsletterStatusCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void AddRecentlyVisitedSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetRecentlyVisitedSpacesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void ClearRecentlyVisitedSpacesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void AddBlockedSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void RemoveBlockedSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetBlockedSpacesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void ClearBlockedSpacesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateAvatarPortraitCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetAvatarPortraitCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateAvatarPortraitWithBufferCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        ~SettingsSystem()
+        {
+            //RealDispose();
+        }
+
+        void RealDispose()
+        {
+            if (_ownsPtr && !_disposed)
+            {
+                csp_systems_SettingsSystem_Dtor(_ptr);
+                _disposed = true;
+            }
+
+            _disposed = true;
+        }
+
+        new public void Dispose()
+        {
+            RealDispose();
+            GC.SuppressFinalize(this);
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (SetNDAStatusCallbackDelegate))]
+#endif
+        static void SetNDAStatusCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 SetNDAStatusCallbackDelegate SetNDAStatusDelegateInstance =
+            SetNDAStatusCallbackDelegateFunction;
+
+        /// <summary>Set a boolean indicating whether the current user has completed a non-disclosure agreement.</summary>
+                /// <remarks>NullResultCallback. Returns status of the update task, no payload expected.</remarks>
+                /// <param name="InValue">Boolean reflecting desired state to store in magnopus connected services.</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> SetNDAStatus(string InUserId, bool InValue)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_SetNDAStatus_void_StringRC_bool_NullResultCallback(
+                _ptr,
+                InUserId,
+                InValue,
+                SetNDAStatusDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetNDAStatusCallbackDelegate))]
+#endif
+        static void GetNDAStatusCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.BooleanResult>)_handle.Target;
+            var _this = (SettingsSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.BooleanResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetNDAStatusCallbackDelegate GetNDAStatusDelegateInstance =
+            GetNDAStatusCallbackDelegateFunction;
+
+        /// <summary>Get a boolean indicating whether the current user has completed a non-disclosure agreement.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.BooleanResult> GetNDAStatus(string InUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.BooleanResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_GetNDAStatus_void_StringRC_BooleanResultCallback(
+                _ptr,
+                InUserId,
+                GetNDAStatusDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (SetNewsletterStatusCallbackDelegate))]
+#endif
+        static void SetNewsletterStatusCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 SetNewsletterStatusCallbackDelegate SetNewsletterStatusDelegateInstance =
+            SetNewsletterStatusCallbackDelegateFunction;
+
+        /// <summary>Opt in or out to receiving a newsletter for the current user.</summary>
+                /// <remarks>NullResultCallback. Returns status of the update task, no payload expected.</remarks>
+                /// <param name="InValue">Boolean reflecting desired state to store in magnopus connected services</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> SetNewsletterStatus(string InUserId, bool InValue)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_SetNewsletterStatus_void_StringRC_bool_NullResultCallback(
+                _ptr,
+                InUserId,
+                InValue,
+                SetNewsletterStatusDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetNewsletterStatusCallbackDelegate))]
+#endif
+        static void GetNewsletterStatusCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.BooleanResult>)_handle.Target;
+            var _this = (SettingsSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.BooleanResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetNewsletterStatusCallbackDelegate GetNewsletterStatusDelegateInstance =
+            GetNewsletterStatusCallbackDelegateFunction;
+
+        /// <summary>Get a boolean indicating whether the current user has opted into receiving a newsletter.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.BooleanResult> GetNewsletterStatus(string InUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.BooleanResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_GetNewsletterStatus_void_StringRC_BooleanResultCallback(
+                _ptr,
+                InUserId,
+                GetNewsletterStatusDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (AddRecentlyVisitedSpaceCallbackDelegate))]
+#endif
+        static void AddRecentlyVisitedSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 AddRecentlyVisitedSpaceCallbackDelegate AddRecentlyVisitedSpaceDelegateInstance =
+            AddRecentlyVisitedSpaceCallbackDelegateFunction;
+
+        /// <summary>Add a Space to the current user's list of recently visited Spaces</summary>
+                /// <remarks>Supplying a SpaceID will store as the most recent space, manages the list order and storing to Magnopus Connected Services.</remarks>
+                /// <remarks>NullResultCallback. Returns status of the update task, no payload expected.</remarks>
+                /// <param name="InSpaceID">SpaceID of most recent space entered</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> AddRecentlyVisitedSpace(string InUserId, string InSpaceID)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_AddRecentlyVisitedSpace_void_StringRC_StringC_NullResultCallback(
+                _ptr,
+                InUserId,
+                InSpaceID,
+                AddRecentlyVisitedSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetRecentlyVisitedSpacesCallbackDelegate))]
+#endif
+        static void GetRecentlyVisitedSpacesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.StringArrayResult>)_handle.Target;
+            var _this = (SettingsSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.StringArrayResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetRecentlyVisitedSpacesCallbackDelegate GetRecentlyVisitedSpacesDelegateInstance =
+            GetRecentlyVisitedSpacesCallbackDelegateFunction;
+
+        /// <summary>Get an array of the most recently visited Spaces for the current user.</summary>
+                /// <remarks>Returns an csp::common::Array of csp::common::Strings ordered from most to least recent spaces up to a maximum of 10 entries.</remarks>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.StringArrayResult> GetRecentlyVisitedSpaces(string InUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.StringArrayResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_GetRecentlyVisitedSpaces_void_StringRC_StringArrayResultCallback(
+                _ptr,
+                InUserId,
+                GetRecentlyVisitedSpacesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (ClearRecentlyVisitedSpacesCallbackDelegate))]
+#endif
+        static void ClearRecentlyVisitedSpacesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 ClearRecentlyVisitedSpacesCallbackDelegate ClearRecentlyVisitedSpacesDelegateInstance =
+            ClearRecentlyVisitedSpacesCallbackDelegateFunction;
+
+        /// <summary>Clear the list of recently-visited spaces for the current user.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> ClearRecentlyVisitedSpaces(string InUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_ClearRecentlyVisitedSpaces_void_StringRC_NullResultCallback(
+                _ptr,
+                InUserId,
+                ClearRecentlyVisitedSpacesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (AddBlockedSpaceCallbackDelegate))]
+#endif
+        static void AddBlockedSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 AddBlockedSpaceCallbackDelegate AddBlockedSpaceDelegateInstance =
+            AddBlockedSpaceCallbackDelegateFunction;
+
+        /// <summary>Block a space for the current user.</summary>
+                /// <remarks>The client is expected to implement the actual space filtering functionality as this function only adds the provided space to a list and will</remarks>
+                /// <remarks>not affect the spaces you get back from `SpaceSystem::GetSpaces()`.</remarks>
+                /// <param name="InSpaceID">SpaceID of most space to block</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> AddBlockedSpace(string InUserId, string InSpaceID)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_AddBlockedSpace_void_StringRC_StringC_NullResultCallback(
+                _ptr,
+                InUserId,
+                InSpaceID,
+                AddBlockedSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (RemoveBlockedSpaceCallbackDelegate))]
+#endif
+        static void RemoveBlockedSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 RemoveBlockedSpaceCallbackDelegate RemoveBlockedSpaceDelegateInstance =
+            RemoveBlockedSpaceCallbackDelegateFunction;
+
+        /// <summary>Unblock a space for the current user.</summary>
+                /// <param name="InSpaceID">SpaceID of most space to block</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> RemoveBlockedSpace(string InUserId, string InSpaceID)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_RemoveBlockedSpace_void_StringRC_StringC_NullResultCallback(
+                _ptr,
+                InUserId,
+                InSpaceID,
+                RemoveBlockedSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetBlockedSpacesCallbackDelegate))]
+#endif
+        static void GetBlockedSpacesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.StringArrayResult>)_handle.Target;
+            var _this = (SettingsSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.StringArrayResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetBlockedSpacesCallbackDelegate GetBlockedSpacesDelegateInstance =
+            GetBlockedSpacesCallbackDelegateFunction;
+
+        /// <summary>Get a list of Spaces that were blocked by the current user.</summary>
+                /// <remarks>Returns an csp::common::Array of csp::common::Strings ordered from most to least recent blocked spaces.</remarks>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.StringArrayResult> GetBlockedSpaces(string InUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.StringArrayResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_GetBlockedSpaces_void_StringRC_StringArrayResultCallback(
+                _ptr,
+                InUserId,
+                GetBlockedSpacesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (ClearBlockedSpacesCallbackDelegate))]
+#endif
+        static void ClearBlockedSpacesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 ClearBlockedSpacesCallbackDelegate ClearBlockedSpacesDelegateInstance =
+            ClearBlockedSpacesCallbackDelegateFunction;
+
+        /// <summary>Clear the list of blocked Spaces for the current user.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> ClearBlockedSpaces(string InUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_ClearBlockedSpaces_void_StringRC_NullResultCallback(
+                _ptr,
+                InUserId,
+                ClearBlockedSpacesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateAvatarPortraitCallbackDelegate))]
+#endif
+        static void UpdateAvatarPortraitCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 UpdateAvatarPortraitCallbackDelegate UpdateAvatarPortraitDelegateInstance =
+            UpdateAvatarPortraitCallbackDelegateFunction;
+
+        /// <summary>Updates the Portrait Avatar image or adds one if it didn't have it previously using FileAssetDataSource</summary>
+                /// <param name="UserId">UserId of Avatar Portrait</param>
+                /// <param name="NewAvatarPortrait">New Portrait Avatar information</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> UpdateAvatarPortrait(
+            string UserId,
+            Csp.Systems.FileAssetDataSource NewAvatarPortrait
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_UpdateAvatarPortrait_void_StringRC_FileAssetDataSourceRC_NullResultCallback(
+                _ptr,
+                UserId,
+                NewAvatarPortrait._ptr,
+                UpdateAvatarPortraitDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetAvatarPortraitCallbackDelegate))]
+#endif
+        static void GetAvatarPortraitCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.UriResult>)_handle.Target;
+            var _this = (SettingsSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.UriResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetAvatarPortraitCallbackDelegate GetAvatarPortraitDelegateInstance =
+            GetAvatarPortraitCallbackDelegateFunction;
+
+        /// <summary>Retrieves the Avatar Portrait information associated with the space</summary>
+                /// <remarks>If the user of the Avatar portrait associated with it the result callback will be successful, the HTTP res code will be ResponseNotFound</remarks>
+                /// <remarks>and the Uri field inside the UriResult will be empty</remarks>
+                /// <param name="UserId">UserId of Avatar Portrait</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.UriResult> GetAvatarPortrait(string UserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.UriResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_GetAvatarPortrait_void_StringRC_UriResultCallback(
+                _ptr,
+                UserId,
+                GetAvatarPortraitDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateAvatarPortraitWithBufferCallbackDelegate))]
+#endif
+        static void UpdateAvatarPortraitWithBufferCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SettingsSystem)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 UpdateAvatarPortraitWithBufferCallbackDelegate UpdateAvatarPortraitWithBufferDelegateInstance =
+            UpdateAvatarPortraitWithBufferCallbackDelegateFunction;
+
+        /// <summary>Updates the Avatar Portrait image or adds one if it didn't have it previously using BufferAssetDataSource</summary>
+                /// <param name="UserId">UserId of Avatar Portrait</param>
+                /// <param name="NewAvatarPortrait">New Avatar Portrait information</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> UpdateAvatarPortraitWithBuffer(
+            string UserId,
+            Csp.Systems.BufferAssetDataSource NewAvatarPortrait
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SettingsSystem_UpdateAvatarPortraitWithBuffer_void_StringRC_BufferAssetDataSourceRC_NullResultCallback(
+                _ptr,
+                UserId,
+                NewAvatarPortrait._ptr,
+                UpdateAvatarPortraitWithBufferDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        protected SettingsSystem() { }
+    }
+}
+