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

package/Source/Systems/Spaces/SpaceSystem.cs

@@ -0,0 +1,2322 @@
+// 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 Space System
+    /// <summary>Public facing system that allows interfacing with Magnopus Connected Services' concept of a Group.</summary>
+    /// <remarks>Offers methods for creating, deleting and joining spaces.</remarks>
+
+    public class SpaceSystem : Csp.Systems.SystemBase
+    {
+        internal override string _safeTypeName { get; } = "csp_systems_SpaceSystem";
+
+        #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_SpaceSystem_Dtor(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_EnterSpace_void_StringRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            EnterSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_ExitSpace_void(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern bool csp_systems_SpaceSystem_IsInSpace_bool(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_SpaceSystem_GetCurrentSpaceC_SpaceRC(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_CreateSpace_void_StringRC_StringRC_SpaceAttributes_ArrayRC_MapRC_FileAssetDataSourceRC_SpaceResultCallback(
+            IntPtr @class,
+            string Name,
+            string Description,
+            SpaceAttributes Attributes,
+            IntPtr InviteUsers,
+            IntPtr Metadata,
+            IntPtr FileThumbnail,
+            CreateSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_CreateSpaceWithBuffer_void_StringRC_StringRC_SpaceAttributes_ArrayRC_MapRC_BufferAssetDataSourceRC_SpaceResultCallback(
+            IntPtr @class,
+            string Name,
+            string Description,
+            SpaceAttributes Attributes,
+            IntPtr InviteUsers,
+            IntPtr Metadata,
+            IntPtr Thumbnail,
+            CreateSpaceWithBufferCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_UpdateSpace_void_StringRC_StringRC_StringRC_SpaceAttributesRC_BasicSpaceResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            string Name,
+            string Description,
+            IntPtr Type,
+            UpdateSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_DeleteSpace_void_StringRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            DeleteSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpaces_void_SpacesResultCallback(
+            IntPtr @class,
+            GetSpacesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpacesByAttributes_void_boolRC_boolRC_intRC_intRC_BasicSpacesResultCallback(
+            IntPtr @class,
+            IntPtr IsDiscoverable,
+            IntPtr RequiresInvite,
+            IntPtr ResultsSkip,
+            IntPtr ResultsMax,
+            GetSpacesByAttributesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpacesByIds_void_ArrayRC_SpacesResultCallback(
+            IntPtr @class,
+            IntPtr RequestedSpaceIDs,
+            GetSpacesByIdsCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpacesForUserId_void_StringRC_SpacesResultCallback(
+            IntPtr @class,
+            string UserId,
+            GetSpacesForUserIdCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpace_void_StringRC_SpaceResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_InviteToSpace_void_StringRC_StringRC_boolRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            string Email,
+            IntPtr IsModeratorRole,
+            InviteToSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_BulkInviteToSpace_void_StringRC_ArrayRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr InviteUsers,
+            BulkInviteToSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetPendingUserInvites_void_StringRC_PendingInvitesResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetPendingUserInvitesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_RemoveUserFromSpace_void_StringRC_StringRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            string UserId,
+            RemoveUserFromSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_AddUserToSpace_void_StringRC_StringRC_SpaceResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            string UserId,
+            AddUserToSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_AddSiteInfo_void_StringRC_SiteR_SiteResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr SiteInfo,
+            AddSiteInfoCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_RemoveSiteInfo_void_StringRC_SiteR_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr SiteInfo,
+            RemoveSiteInfoCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSitesInfo_void_StringRC_SitesCollectionResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetSitesInfoCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_UpdateUserRole_void_StringRC_UserRoleInfoRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr NewUserRoleInfo,
+            UpdateUserRoleCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetUsersRoles_void_StringRC_ArrayRC_UserRoleCollectionCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr RequestedUserIds,
+            GetUsersRolesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_UpdateSpaceMetadata_void_StringRC_MapRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr NewMetadata,
+            UpdateSpaceMetadataCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpacesMetadata_void_ArrayRC_SpacesMetadataResultCallback(
+            IntPtr @class,
+            IntPtr Spaces,
+            GetSpacesMetadataCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpaceMetadata_void_StringRC_SpaceMetadataResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetSpaceMetadataCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_UpdateSpaceThumbnail_void_StringRC_FileAssetDataSourceRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr NewThumbnail,
+            UpdateSpaceThumbnailCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_UpdateSpaceThumbnailWithBuffer_void_StringRC_BufferAssetDataSourceRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr NewThumbnail,
+            UpdateSpaceThumbnailWithBufferCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpaceThumbnail_void_StringRC_UriResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetSpaceThumbnailCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_AddUserToSpaceBanList_void_StringRC_StringRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            string RequestedUserId,
+            AddUserToSpaceBanListCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_DeleteUserFromSpaceBanList_void_StringRC_StringRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            string RequestedUserId,
+            DeleteUserFromSpaceBanListCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_UpdateSpaceGeoLocation_void_StringRC_GeoLocationRC_floatRC_ArrayRC_SpaceGeoLocationResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr Location,
+            IntPtr Orientation,
+            IntPtr GeoFence,
+            UpdateSpaceGeoLocationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_GetSpaceGeoLocation_void_StringRC_SpaceGeoLocationResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetSpaceGeoLocationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_SpaceSystem_DeleteSpaceGeoLocation_void_StringRC_NullResultCallback(
+            IntPtr @class,
+            string SpaceId,
+            DeleteSpaceGeoLocationCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_SpaceSystem_Ctor();
+
+#pragma warning restore IDE1006
+        #endregion
+
+        internal SpaceSystem(NativePointer ptr) : base(ptr) { }
+
+        public SpaceSystem(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 EnterSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void CreateSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void CreateSpaceWithBufferCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void DeleteSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpacesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpacesByAttributesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpacesByIdsCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpacesForUserIdCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void InviteToSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void BulkInviteToSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetPendingUserInvitesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void RemoveUserFromSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void AddUserToSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void AddSiteInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void RemoveSiteInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSitesInfoCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateUserRoleCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetUsersRolesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateSpaceMetadataCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpacesMetadataCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpaceMetadataCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateSpaceThumbnailCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateSpaceThumbnailWithBufferCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpaceThumbnailCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void AddUserToSpaceBanListCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void DeleteUserFromSpaceBanListCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void UpdateSpaceGeoLocationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetSpaceGeoLocationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void DeleteSpaceGeoLocationCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        ~SpaceSystem()
+        {
+            //RealDispose();
+        }
+
+        void RealDispose()
+        {
+            if (_ownsPtr && !_disposed)
+            {
+                csp_systems_SpaceSystem_Dtor(_ptr);
+                _disposed = true;
+            }
+
+            _disposed = true;
+        }
+
+        new public void Dispose()
+        {
+            RealDispose();
+            GC.SuppressFinalize(this);
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (EnterSpaceCallbackDelegate))]
+#endif
+        static void EnterSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 EnterSpaceCallbackDelegate EnterSpaceDelegateInstance = EnterSpaceCallbackDelegateFunction;
+
+        /// <summary>Enter a space.</summary>
+                /// <param name="Space">Space to enter into</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> EnterSpace(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_EnterSpace_void_StringRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                EnterSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        /// <summary>Send exit current space event to EventSystem.</summary>
+
+
+        public void ExitSpace()
+        {
+            csp_systems_SpaceSystem_ExitSpace_void(_ptr);
+        }
+
+        /// <summary>Get whether user is currently in a space.</summary>
+        /// <returns>Result of whether they are in a Space.</returns>
+
+
+        public bool IsInSpace()
+        {
+            var _result = csp_systems_SpaceSystem_IsInSpace_bool(_ptr);
+
+            return _result;
+        }
+
+        /// <summary>Get the user's current space.</summary>
+        /// <returns>The space data object the user is currently in</returns>
+
+
+        public Csp.Systems.Space GetCurrentSpace()
+        {
+            var _result = new Csp.Systems.Space(csp_systems_SpaceSystem_GetCurrentSpaceC_SpaceRC(_ptr));
+
+            return _result;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (CreateSpaceCallbackDelegate))]
+#endif
+        static void CreateSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly CreateSpaceCallbackDelegate CreateSpaceDelegateInstance = CreateSpaceCallbackDelegateFunction;
+
+        /// <summary>Creates a new space.</summary>
+                /// <param name="Name">Name for the new space</param>
+                /// <param name="Description">Description for the new space</param>
+                /// <param name="Type">Type of the new space</param>
+                /// <param name="InviteUsers">Optional array of users to be invited into the space</param>
+                /// <param name="Metadata">Metadata information for the new space</param>
+                /// <param name="FileThumbnail">Optional thumbnail image for the new space</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceResult> CreateSpace(
+            string Name,
+            string Description,
+            Csp.Systems.SpaceAttributes Attributes,
+            Csp.Common.Array<Csp.Systems.InviteUserRoleInfo>? InviteUsers,
+            Csp.Common.Map<string, string> Metadata,
+            Csp.Systems.FileAssetDataSource? FileThumbnail
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_CreateSpace_void_StringRC_StringRC_SpaceAttributes_ArrayRC_MapRC_FileAssetDataSourceRC_SpaceResultCallback(
+                _ptr,
+                Name,
+                Description,
+                Attributes,
+                InviteUsers?._ptr ?? IntPtr.Zero,
+                Metadata._ptr,
+                FileThumbnail?._ptr ?? IntPtr.Zero,
+                CreateSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (CreateSpaceWithBufferCallbackDelegate))]
+#endif
+        static void CreateSpaceWithBufferCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly CreateSpaceWithBufferCallbackDelegate CreateSpaceWithBufferDelegateInstance =
+            CreateSpaceWithBufferCallbackDelegateFunction;
+
+        /// <summary>Creates a new space Using BufferAssetDataSource.</summary>
+                /// <param name="Name">Name for the new space</param>
+                /// <param name="Description">Description for the new space</param>
+                /// <param name="Type">Type of the new space</param>
+                /// <param name="InviteUsers">Optional array of users to be invited into the space</param>
+                /// <param name="Metadata">Metadata information for the new space</param>
+                /// <param name="Thumbnail">Thumbnail image buffer for the new space</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceResult> CreateSpaceWithBuffer(
+            string Name,
+            string Description,
+            Csp.Systems.SpaceAttributes Attributes,
+            Csp.Common.Array<Csp.Systems.InviteUserRoleInfo>? InviteUsers,
+            Csp.Common.Map<string, string> Metadata,
+            Csp.Systems.BufferAssetDataSource Thumbnail
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_CreateSpaceWithBuffer_void_StringRC_StringRC_SpaceAttributes_ArrayRC_MapRC_BufferAssetDataSourceRC_SpaceResultCallback(
+                _ptr,
+                Name,
+                Description,
+                Attributes,
+                InviteUsers?._ptr ?? IntPtr.Zero,
+                Metadata._ptr,
+                Thumbnail._ptr,
+                CreateSpaceWithBufferDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateSpaceCallbackDelegate))]
+#endif
+        static void UpdateSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.BasicSpaceResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.BasicSpaceResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly UpdateSpaceCallbackDelegate UpdateSpaceDelegateInstance = UpdateSpaceCallbackDelegateFunction;
+
+        /// <summary>Updates the name and/or the description of a Space</summary>
+                /// <param name="Space">The space to update</param>
+                /// <param name="Name">If a new name is provided it will be used to update the space name</param>
+                /// <param name="Description">If a new description is provided it will be used to update the space</param>
+                /// <remarks>description</remarks>
+                /// <param name="Type">If a new type is provided it will be used to update the space type</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.BasicSpaceResult> UpdateSpace(
+            string SpaceId,
+            string? Name,
+            string? Description,
+            Csp.Systems.SpaceAttributes? Type
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.BasicSpaceResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            var TypePointer = IntPtr.Zero;
+            unsafe
+            {
+                if (Type.HasValue)
+                {
+                    var ptr = stackalloc Csp.Systems.SpaceAttributes[1];
+                    *ptr = Type.Value;
+                    TypePointer = (IntPtr)ptr;
+                }
+            }
+
+            csp_systems_SpaceSystem_UpdateSpace_void_StringRC_StringRC_StringRC_SpaceAttributesRC_BasicSpaceResultCallback(
+                _ptr,
+                SpaceId,
+                Name,
+                Description,
+                TypePointer,
+                UpdateSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (DeleteSpaceCallbackDelegate))]
+#endif
+        static void DeleteSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 DeleteSpaceCallbackDelegate DeleteSpaceDelegateInstance = DeleteSpaceCallbackDelegateFunction;
+
+        /// <summary>Deletes a given space and the corresponding UserService group.</summary>
+                /// <param name="Space">Space to delete</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> DeleteSpace(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_DeleteSpace_void_StringRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                DeleteSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpacesCallbackDelegate))]
+#endif
+        static void GetSpacesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpacesResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpacesResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpacesCallbackDelegate GetSpacesDelegateInstance = GetSpacesCallbackDelegateFunction;
+
+        /// <summary>Retrieves all spaces corresponding to the currently logged in user.</summary>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpacesResult> GetSpaces()
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpacesResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpaces_void_SpacesResultCallback(
+                _ptr,
+                GetSpacesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpacesByAttributesCallbackDelegate))]
+#endif
+        static void GetSpacesByAttributesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.BasicSpacesResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.BasicSpacesResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpacesByAttributesCallbackDelegate GetSpacesByAttributesDelegateInstance =
+            GetSpacesByAttributesCallbackDelegateFunction;
+
+        /// <summary>Retrieves basic space details for the spaces with the given attributes available to the logged in user.</summary>
+                /// <remarks>Results pagination is supported through the use of ResultsSkip and ResultsMax.</remarks>
+                /// <param name="IsDiscoverable">`true` or `false` to filter by IsDiscoverable attribute value.</param>
+                /// <param name="IsDiscoverable">`true` or `false` to filter by RequiresInvite attribute value.</param>
+                /// <param name="ResultsSkip">Number of result entries that will be skipped from the result. for no skip pass nullptr.</param>
+                /// <param name="ResultsMax">Maximum number of result entries to be retrieved. for all available result entries pass</param>
+                /// <remarks>nullptr.</remarks>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.BasicSpacesResult> GetSpacesByAttributes(
+            bool? IsDiscoverable,
+            bool? RequiresInvite,
+            int? ResultsSkip,
+            int? ResultsMax
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.BasicSpacesResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            var IsDiscoverablePointer = IntPtr.Zero;
+            unsafe
+            {
+                if (IsDiscoverable.HasValue)
+                {
+                    var ptr = stackalloc bool[1];
+                    *ptr = IsDiscoverable.Value;
+                    IsDiscoverablePointer = (IntPtr)ptr;
+                }
+            }
+            var RequiresInvitePointer = IntPtr.Zero;
+            unsafe
+            {
+                if (RequiresInvite.HasValue)
+                {
+                    var ptr = stackalloc bool[1];
+                    *ptr = RequiresInvite.Value;
+                    RequiresInvitePointer = (IntPtr)ptr;
+                }
+            }
+            var ResultsSkipPointer = IntPtr.Zero;
+            unsafe
+            {
+                if (ResultsSkip.HasValue)
+                {
+                    var ptr = stackalloc int[1];
+                    *ptr = ResultsSkip.Value;
+                    ResultsSkipPointer = (IntPtr)ptr;
+                }
+            }
+            var ResultsMaxPointer = IntPtr.Zero;
+            unsafe
+            {
+                if (ResultsMax.HasValue)
+                {
+                    var ptr = stackalloc int[1];
+                    *ptr = ResultsMax.Value;
+                    ResultsMaxPointer = (IntPtr)ptr;
+                }
+            }
+
+            csp_systems_SpaceSystem_GetSpacesByAttributes_void_boolRC_boolRC_intRC_intRC_BasicSpacesResultCallback(
+                _ptr,
+                IsDiscoverablePointer,
+                RequiresInvitePointer,
+                ResultsSkipPointer,
+                ResultsMaxPointer,
+                GetSpacesByAttributesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpacesByIdsCallbackDelegate))]
+#endif
+        static void GetSpacesByIdsCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpacesResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpacesResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpacesByIdsCallbackDelegate GetSpacesByIdsDelegateInstance =
+            GetSpacesByIdsCallbackDelegateFunction;
+
+        /// <summary>Retrieves space details corresponding to the provided Space IDs</summary>
+                /// <param name="RequestedSpaceIDs">Array of space ids for which the space details will be retrieved</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpacesResult> GetSpacesByIds(Csp.Common.Array<string> RequestedSpaceIDs)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpacesResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpacesByIds_void_ArrayRC_SpacesResultCallback(
+                _ptr,
+                RequestedSpaceIDs._ptr,
+                GetSpacesByIdsDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpacesForUserIdCallbackDelegate))]
+#endif
+        static void GetSpacesForUserIdCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpacesResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpacesResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpacesForUserIdCallbackDelegate GetSpacesForUserIdDelegateInstance =
+            GetSpacesForUserIdCallbackDelegateFunction;
+
+        /// <summary>Retrieves all spaces corresponding to the provided user ID.</summary>
+                /// <param name="UserId">Unique id of user</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpacesResult> GetSpacesForUserId(string UserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpacesResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpacesForUserId_void_StringRC_SpacesResultCallback(
+                _ptr,
+                UserId,
+                GetSpacesForUserIdDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpaceCallbackDelegate))]
+#endif
+        static void GetSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpaceCallbackDelegate GetSpaceDelegateInstance = GetSpaceCallbackDelegateFunction;
+
+        /// <summary>Retrieves a space by its unique ID.</summary>
+                /// <param name="SpaceId">Unique id of space</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceResult> GetSpace(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpace_void_StringRC_SpaceResultCallback(
+                _ptr,
+                SpaceId,
+                GetSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (InviteToSpaceCallbackDelegate))]
+#endif
+        static void InviteToSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 InviteToSpaceCallbackDelegate InviteToSpaceDelegateInstance =
+            InviteToSpaceCallbackDelegateFunction;
+
+        /// <summary>Invites a given email to a specific space.</summary>
+                /// <param name="Space">Space to invite to</param>
+                /// <param name="Email">Email to invite to space</param>
+                /// <param name="IsModeratorRole">If present and true sets the user's role in the space to "moderator", pass false or</param>
+                /// <remarks>nullptr to leave role as default</remarks>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> InviteToSpace(string SpaceId, string Email, bool? IsModeratorRole)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            var IsModeratorRolePointer = IntPtr.Zero;
+            unsafe
+            {
+                if (IsModeratorRole.HasValue)
+                {
+                    var ptr = stackalloc bool[1];
+                    *ptr = IsModeratorRole.Value;
+                    IsModeratorRolePointer = (IntPtr)ptr;
+                }
+            }
+
+            csp_systems_SpaceSystem_InviteToSpace_void_StringRC_StringRC_boolRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                Email,
+                IsModeratorRolePointer,
+                InviteToSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (BulkInviteToSpaceCallbackDelegate))]
+#endif
+        static void BulkInviteToSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 BulkInviteToSpaceCallbackDelegate BulkInviteToSpaceDelegateInstance =
+            BulkInviteToSpaceCallbackDelegateFunction;
+
+        /// <summary>Invites all the given emails to a specific space.</summary>
+                /// <param name="Space">Space to invite to</param>
+                /// <param name="InviteUsers">Array of users to invite with their email and role</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> BulkInviteToSpace(
+            string SpaceId,
+            Csp.Common.Array<Csp.Systems.InviteUserRoleInfo> InviteUsers
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_BulkInviteToSpace_void_StringRC_ArrayRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                InviteUsers._ptr,
+                BulkInviteToSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetPendingUserInvitesCallbackDelegate))]
+#endif
+        static void GetPendingUserInvitesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.PendingInvitesResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.PendingInvitesResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetPendingUserInvitesCallbackDelegate GetPendingUserInvitesDelegateInstance =
+            GetPendingUserInvitesCallbackDelegateFunction;
+
+        /// <summary>Returns an array of obfuscated email addresses, addresses of users that have not yet accepted the space invite</summary>
+                /// <param name="Space">Space for which the invites where sent</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.PendingInvitesResult> GetPendingUserInvites(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.PendingInvitesResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetPendingUserInvites_void_StringRC_PendingInvitesResultCallback(
+                _ptr,
+                SpaceId,
+                GetPendingUserInvitesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (RemoveUserFromSpaceCallbackDelegate))]
+#endif
+        static void RemoveUserFromSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 RemoveUserFromSpaceCallbackDelegate RemoveUserFromSpaceDelegateInstance =
+            RemoveUserFromSpaceCallbackDelegateFunction;
+
+        /// <summary>Removes a user from a space by the user's unique ID.</summary>
+                /// <param name="Space">Space to remove user from</param>
+                /// <param name="UserId">Unique id of user</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> RemoveUserFromSpace(string SpaceId, string UserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_RemoveUserFromSpace_void_StringRC_StringRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                UserId,
+                RemoveUserFromSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (AddUserToSpaceCallbackDelegate))]
+#endif
+        static void AddUserToSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly AddUserToSpaceCallbackDelegate AddUserToSpaceDelegateInstance =
+            AddUserToSpaceCallbackDelegateFunction;
+
+        /// <summary>Adds a user to a space by the user's unique ID.</summary>
+                /// <param name="Space">Space to add user to</param>
+                /// <param name="UserId">Unique id of user</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceResult> AddUserToSpace(string SpaceId, string UserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_AddUserToSpace_void_StringRC_StringRC_SpaceResultCallback(
+                _ptr,
+                SpaceId,
+                UserId,
+                AddUserToSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (AddSiteInfoCallbackDelegate))]
+#endif
+        static void AddSiteInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SiteResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SiteResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly AddSiteInfoCallbackDelegate AddSiteInfoDelegateInstance = AddSiteInfoCallbackDelegateFunction;
+
+        /// <summary>Creates new Site information and associates it with the Space.</summary>
+                /// <param name="Space">Space to associate the Site information with</param>
+                /// <param name="SiteInfo">Site information to be added</param>
+                /// <returns>Data class containing information on task result/progress</returns>
+
+        public Task<Csp.Systems.SiteResult> AddSiteInfo(string SpaceId, Csp.Systems.Site SiteInfo)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SiteResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_AddSiteInfo_void_StringRC_SiteR_SiteResultCallback(
+                _ptr,
+                SpaceId,
+                SiteInfo._ptr,
+                AddSiteInfoDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (RemoveSiteInfoCallbackDelegate))]
+#endif
+        static void RemoveSiteInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 RemoveSiteInfoCallbackDelegate RemoveSiteInfoDelegateInstance =
+            RemoveSiteInfoCallbackDelegateFunction;
+
+        /// <summary>Removes the Site information from the Space.</summary>
+                /// <param name="Space">Space for which to remove the associated Site information</param>
+                /// <param name="SiteInfo">Site information to be removed</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> RemoveSiteInfo(string SpaceId, Csp.Systems.Site SiteInfo)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_RemoveSiteInfo_void_StringRC_SiteR_NullResultCallback(
+                _ptr,
+                SpaceId,
+                SiteInfo._ptr,
+                RemoveSiteInfoDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSitesInfoCallbackDelegate))]
+#endif
+        static void GetSitesInfoCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SitesCollectionResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SitesCollectionResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSitesInfoCallbackDelegate GetSitesInfoDelegateInstance =
+            GetSitesInfoCallbackDelegateFunction;
+
+        /// <summary>Retrieves the Sites information associated with a Space.</summary>
+                /// <param name="Space">Space to be queried for Site information</param>
+                /// <returns>Data class containing information on task result/progress</returns>
+
+        public Task<Csp.Systems.SitesCollectionResult> GetSitesInfo(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SitesCollectionResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSitesInfo_void_StringRC_SitesCollectionResultCallback(
+                _ptr,
+                SpaceId,
+                GetSitesInfoDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateUserRoleCallbackDelegate))]
+#endif
+        static void UpdateUserRoleCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 UpdateUserRoleCallbackDelegate UpdateUserRoleDelegateInstance =
+            UpdateUserRoleCallbackDelegateFunction;
+
+        /// <summary>Updates the space role for a particular user</summary>
+                /// <param name="Space">The space that the requested user is part of</param>
+                /// <param name="NewUserRoleInfo">New user role information containing the new role for the specified user</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> UpdateUserRole(string SpaceId, Csp.Systems.UserRoleInfo NewUserRoleInfo)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_UpdateUserRole_void_StringRC_UserRoleInfoRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                NewUserRoleInfo._ptr,
+                UpdateUserRoleDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetUsersRolesCallbackDelegate))]
+#endif
+        static void GetUsersRolesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.UserRoleCollectionResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.UserRoleCollectionResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetUsersRolesCallbackDelegate GetUsersRolesDelegateInstance =
+            GetUsersRolesCallbackDelegateFunction;
+
+        /// <summary>Retrieves the User role information for the User Ids that have been passed in</summary>
+                /// <param name="Space">Space for which the User Roles will be retrieved</param>
+                /// <param name="RequestedUserIds">Array of User Ids for which the User Roles will be retrieved</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.UserRoleCollectionResult> GetUsersRoles(
+            string SpaceId,
+            Csp.Common.Array<string> RequestedUserIds
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.UserRoleCollectionResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetUsersRoles_void_StringRC_ArrayRC_UserRoleCollectionCallback(
+                _ptr,
+                SpaceId,
+                RequestedUserIds._ptr,
+                GetUsersRolesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateSpaceMetadataCallbackDelegate))]
+#endif
+        static void UpdateSpaceMetadataCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 UpdateSpaceMetadataCallbackDelegate UpdateSpaceMetadataDelegateInstance =
+            UpdateSpaceMetadataCallbackDelegateFunction;
+
+        /// <summary>Updates the Space metadata information with the new one provided</summary>
+                /// <param name="SpaceId">ID of Space for which the metadata will be updated</param>
+                /// <param name="NewMetadata">New metadata information that will replace the previous one</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> UpdateSpaceMetadata(
+            string SpaceId,
+            Csp.Common.Map<string, string> NewMetadata
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_UpdateSpaceMetadata_void_StringRC_MapRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                NewMetadata._ptr,
+                UpdateSpaceMetadataDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpacesMetadataCallbackDelegate))]
+#endif
+        static void GetSpacesMetadataCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpacesMetadataResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpacesMetadataResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpacesMetadataCallbackDelegate GetSpacesMetadataDelegateInstance =
+            GetSpacesMetadataCallbackDelegateFunction;
+
+        /// <summary>Retrieves Spaces metadata information</summary>
+                /// <param name="Spaces">Spaces for which metadata will be retrieved</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpacesMetadataResult> GetSpacesMetadata(Csp.Common.Array<string> Spaces)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpacesMetadataResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpacesMetadata_void_ArrayRC_SpacesMetadataResultCallback(
+                _ptr,
+                Spaces._ptr,
+                GetSpacesMetadataDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpaceMetadataCallbackDelegate))]
+#endif
+        static void GetSpaceMetadataCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceMetadataResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceMetadataResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpaceMetadataCallbackDelegate GetSpaceMetadataDelegateInstance =
+            GetSpaceMetadataCallbackDelegateFunction;
+
+        /// <summary>Retrieves the Space metadata information</summary>
+                /// <param name="Space">Space for which the metadata will be retrieved</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceMetadataResult> GetSpaceMetadata(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceMetadataResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpaceMetadata_void_StringRC_SpaceMetadataResultCallback(
+                _ptr,
+                SpaceId,
+                GetSpaceMetadataDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateSpaceThumbnailCallbackDelegate))]
+#endif
+        static void UpdateSpaceThumbnailCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 UpdateSpaceThumbnailCallbackDelegate UpdateSpaceThumbnailDelegateInstance =
+            UpdateSpaceThumbnailCallbackDelegateFunction;
+
+        /// <summary>Updates the Space thumbnail image or adds one if it didn't have it previously using FileAssetDataSource</summary>
+                /// <param name="Space">Space for which the thumbnail will be updated</param>
+                /// <param name="NewThumbnail">New thumbnail information</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> UpdateSpaceThumbnail(
+            string SpaceId,
+            Csp.Systems.FileAssetDataSource NewThumbnail
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_UpdateSpaceThumbnail_void_StringRC_FileAssetDataSourceRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                NewThumbnail._ptr,
+                UpdateSpaceThumbnailDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateSpaceThumbnailWithBufferCallbackDelegate))]
+#endif
+        static void UpdateSpaceThumbnailWithBufferCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 UpdateSpaceThumbnailWithBufferCallbackDelegate UpdateSpaceThumbnailWithBufferDelegateInstance =
+            UpdateSpaceThumbnailWithBufferCallbackDelegateFunction;
+
+        /// <summary>Updates the Space thumbnail image or adds one if it didn't have it previously using BufferAssetDataSource</summary>
+                /// <param name="Space">Space for which the thumbnail will be updated</param>
+                /// <param name="NewThumbnail">New thumbnail information</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> UpdateSpaceThumbnailWithBuffer(
+            string SpaceId,
+            Csp.Systems.BufferAssetDataSource NewThumbnail
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_UpdateSpaceThumbnailWithBuffer_void_StringRC_BufferAssetDataSourceRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                NewThumbnail._ptr,
+                UpdateSpaceThumbnailWithBufferDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpaceThumbnailCallbackDelegate))]
+#endif
+        static void GetSpaceThumbnailCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.UriResult>)_handle.Target;
+            var _this = (SpaceSystem)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 GetSpaceThumbnailCallbackDelegate GetSpaceThumbnailDelegateInstance =
+            GetSpaceThumbnailCallbackDelegateFunction;
+
+        /// <summary>Retrieves the space thumbnail information associated with the space</summary>
+                /// <remarks>If the space does not have a thumbnail 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="Space">Space for which the thumbnail information will be retrieved</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.UriResult> GetSpaceThumbnail(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.UriResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpaceThumbnail_void_StringRC_UriResultCallback(
+                _ptr,
+                SpaceId,
+                GetSpaceThumbnailDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (AddUserToSpaceBanListCallbackDelegate))]
+#endif
+        static void AddUserToSpaceBanListCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 AddUserToSpaceBanListCallbackDelegate AddUserToSpaceBanListDelegateInstance =
+            AddUserToSpaceBanListCallbackDelegateFunction;
+
+        /// <summary>Adds user to group banned list. Banned list can be retrieved from the space</summary>
+                /// <param name="Space">Space for which the ban will be issued on</param>
+                /// <param name="RequestedUserId">User id to be banned from the space</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> AddUserToSpaceBanList(string SpaceId, string RequestedUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_AddUserToSpaceBanList_void_StringRC_StringRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                RequestedUserId,
+                AddUserToSpaceBanListDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (DeleteUserFromSpaceBanListCallbackDelegate))]
+#endif
+        static void DeleteUserFromSpaceBanListCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 DeleteUserFromSpaceBanListCallbackDelegate DeleteUserFromSpaceBanListDelegateInstance =
+            DeleteUserFromSpaceBanListCallbackDelegateFunction;
+
+        /// <summary>Deletes user from group banned list. Banned list can be retrieved from the space</summary>
+                /// <param name="Space">Space for which the Space for which the ban will be removed on</param>
+                /// <param name="RequestedUserId">User id to have ban removed from the space</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> DeleteUserFromSpaceBanList(string SpaceId, string RequestedUserId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_DeleteUserFromSpaceBanList_void_StringRC_StringRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                RequestedUserId,
+                DeleteUserFromSpaceBanListDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (UpdateSpaceGeoLocationCallbackDelegate))]
+#endif
+        static void UpdateSpaceGeoLocationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceGeoLocationResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceGeoLocationResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly UpdateSpaceGeoLocationCallbackDelegate UpdateSpaceGeoLocationDelegateInstance =
+            UpdateSpaceGeoLocationCallbackDelegateFunction;
+
+        /// <summary>Add or update a GeoLocation for the space</summary>
+                /// <param name="SpaceId">Id of the space to udpate</param>
+                /// <param name="Location">The latitude and longitude of the geo location</param>
+                /// <param name="Orientation">The compass direction the space points. Must be between 0 (north) and 360 (inclusive)</param>
+                /// <param name="GeoFence">Array of points that creates a geo fence for the space.</param>
+                /// <remarks>Must be in clockwise order and start and end with the same value.</remarks>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceGeoLocationResult> UpdateSpaceGeoLocation(
+            string SpaceId,
+            Csp.Systems.GeoLocation? Location,
+            float? Orientation,
+            Csp.Common.Array<Csp.Systems.GeoLocation>? GeoFence
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceGeoLocationResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            var OrientationPointer = IntPtr.Zero;
+            unsafe
+            {
+                if (Orientation.HasValue)
+                {
+                    var ptr = stackalloc float[1];
+                    *ptr = Orientation.Value;
+                    OrientationPointer = (IntPtr)ptr;
+                }
+            }
+
+            csp_systems_SpaceSystem_UpdateSpaceGeoLocation_void_StringRC_GeoLocationRC_floatRC_ArrayRC_SpaceGeoLocationResultCallback(
+                _ptr,
+                SpaceId,
+                Location?._ptr ?? IntPtr.Zero,
+                OrientationPointer,
+                GeoFence?._ptr ?? IntPtr.Zero,
+                UpdateSpaceGeoLocationDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetSpaceGeoLocationCallbackDelegate))]
+#endif
+        static void GetSpaceGeoLocationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.SpaceGeoLocationResult>)_handle.Target;
+            var _this = (SpaceSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.SpaceGeoLocationResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetSpaceGeoLocationCallbackDelegate GetSpaceGeoLocationDelegateInstance =
+            GetSpaceGeoLocationCallbackDelegateFunction;
+
+        /// <summary>Get the geo location details for the given space id</summary>
+                /// <param name="SpaceId">Id of the space</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.SpaceGeoLocationResult> GetSpaceGeoLocation(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.SpaceGeoLocationResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_GetSpaceGeoLocation_void_StringRC_SpaceGeoLocationResultCallback(
+                _ptr,
+                SpaceId,
+                GetSpaceGeoLocationDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (DeleteSpaceGeoLocationCallbackDelegate))]
+#endif
+        static void DeleteSpaceGeoLocationCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.NullResult>)_handle.Target;
+            var _this = (SpaceSystem)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 DeleteSpaceGeoLocationCallbackDelegate DeleteSpaceGeoLocationDelegateInstance =
+            DeleteSpaceGeoLocationCallbackDelegateFunction;
+
+        /// <summary>Delete the geo location information of the space</summary>
+                /// <param name="SpaceId">Id of the space to be udpated</param>
+                /// <returns>The result for the request</returns>
+
+        public Task<Csp.Systems.NullResult> DeleteSpaceGeoLocation(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.NullResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_SpaceSystem_DeleteSpaceGeoLocation_void_StringRC_NullResultCallback(
+                _ptr,
+                SpaceId,
+                DeleteSpaceGeoLocationDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        protected SpaceSystem() { }
+    }
+}
+