connected-spaces-platform.unity.core 4.14.0 → 4.15.0

package/Source/Systems/Quota/QuotaSystem.cs

@@ -0,0 +1,602 @@
+// 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 GraphQL System
+    /// <summary>Public facing system that allows interfacing with Magnopus Connect Services' Quota Server.</summary>
+    /// <remarks>Offers methods for receiving Quota Queries.</remarks>
+
+    public class QuotaSystem : Csp.Systems.SystemBase
+    {
+        internal override string _safeTypeName { get; } = "csp_systems_QuotaSystem";
+
+        #region P/Invoke
+#pragma warning disable IDE1006
+
+
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_Dtor(IntPtr @class);
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetTotalSpacesOwnedByUser_void_FeatureLimitCallback(
+            IntPtr @class,
+            GetTotalSpacesOwnedByUserCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetConcurrentUsersInSpace_void_StringRC_FeatureLimitCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetConcurrentUsersInSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetTotalSpaceSizeInKilobytes_void_StringRC_FeatureLimitCallback(
+            IntPtr @class,
+            string SpaceId,
+            GetTotalSpaceSizeInKilobytesCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetTierFeatureProgressForUser_void_ArrayRC_FeaturesLimitCallback(
+            IntPtr @class,
+            IntPtr FeatureNames,
+            GetTierFeatureProgressForUserCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetTierFeatureProgressForSpace_void_StringRC_ArrayRC_FeaturesLimitCallback(
+            IntPtr @class,
+            string SpaceId,
+            IntPtr FeatureNames,
+            GetTierFeatureProgressForSpaceCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetCurrentUserTier_void_UserTierCallback(
+            IntPtr @class,
+            GetCurrentUserTierCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetTierFeatureQuota_void_TierNamesRC_TierFeaturesRC_FeatureQuotaCallback(
+            IntPtr @class,
+            IntPtr TierName,
+            IntPtr FeatureName,
+            GetTierFeatureQuotaCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern void csp_systems_QuotaSystem_GetTierFeaturesQuota_void_TierNamesRC_FeaturesQuotaCallback(
+            IntPtr @class,
+            IntPtr TierName,
+            GetTierFeaturesQuotaCallbackDelegate callback,
+            IntPtr callbackStateObject
+        );
+
+        [
+            DllImport(
+#if !UNITY_EDITOR && UNITY_IOS
+            "__Internal"
+#elif DEBUG && !UNITY_EDITOR_OSX && !UNITY_STANDALONE_OSX
+                "ConnectedSpacesPlatform_D"
+#else
+                "ConnectedSpacesPlatform"
+#endif
+            ),
+            SuppressUnmanagedCodeSecurity
+        ]
+        static extern NativePointer csp_systems_QuotaSystem_Ctor();
+
+#pragma warning restore IDE1006
+        #endregion
+
+        internal QuotaSystem(NativePointer ptr) : base(ptr) { }
+
+        public QuotaSystem(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 GetTotalSpacesOwnedByUserCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetConcurrentUsersInSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetTotalSpaceSizeInKilobytesCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetTierFeatureProgressForUserCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetTierFeatureProgressForSpaceCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetCurrentUserTierCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetTierFeatureQuotaCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        delegate void GetTierFeaturesQuotaCallbackDelegate(IntPtr _StateObject__, NativePointer Result);
+
+        ~QuotaSystem()
+        {
+            //RealDispose();
+        }
+
+        void RealDispose()
+        {
+            if (_ownsPtr && !_disposed)
+            {
+                csp_systems_QuotaSystem_Dtor(_ptr);
+                _disposed = true;
+            }
+
+            _disposed = true;
+        }
+
+        new public void Dispose()
+        {
+            RealDispose();
+            GC.SuppressFinalize(this);
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetTotalSpacesOwnedByUserCallbackDelegate))]
+#endif
+        static void GetTotalSpacesOwnedByUserCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.FeatureLimitResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.FeatureLimitResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetTotalSpacesOwnedByUserCallbackDelegate GetTotalSpacesOwnedByUserDelegateInstance =
+            GetTotalSpacesOwnedByUserCallbackDelegateFunction;
+
+        /// <summary>Get the total number of Spaces owned by the current user and their tier space limit</summary>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.FeatureLimitResult> GetTotalSpacesOwnedByUser()
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.FeatureLimitResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetTotalSpacesOwnedByUser_void_FeatureLimitCallback(
+                _ptr,
+                GetTotalSpacesOwnedByUserDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetConcurrentUsersInSpaceCallbackDelegate))]
+#endif
+        static void GetConcurrentUsersInSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.FeatureLimitResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.FeatureLimitResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetConcurrentUsersInSpaceCallbackDelegate GetConcurrentUsersInSpaceDelegateInstance =
+            GetConcurrentUsersInSpaceCallbackDelegateFunction;
+
+        /// <summary>Gets total number of user inside of a space and its tier user limit</summary>
+                /// <param name="SpaceId">Id of the Space</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.FeatureLimitResult> GetConcurrentUsersInSpace(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.FeatureLimitResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetConcurrentUsersInSpace_void_StringRC_FeatureLimitCallback(
+                _ptr,
+                SpaceId,
+                GetConcurrentUsersInSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetTotalSpaceSizeInKilobytesCallbackDelegate))]
+#endif
+        static void GetTotalSpaceSizeInKilobytesCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.FeatureLimitResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.FeatureLimitResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetTotalSpaceSizeInKilobytesCallbackDelegate GetTotalSpaceSizeInKilobytesDelegateInstance =
+            GetTotalSpaceSizeInKilobytesCallbackDelegateFunction;
+
+        /// <summary>Get total size of all assets within a space and their tier space size limit</summary>
+                /// <param name="SpaceId">Id of the Space</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.FeatureLimitResult> GetTotalSpaceSizeInKilobytes(string SpaceId)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.FeatureLimitResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetTotalSpaceSizeInKilobytes_void_StringRC_FeatureLimitCallback(
+                _ptr,
+                SpaceId,
+                GetTotalSpaceSizeInKilobytesDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetTierFeatureProgressForUserCallbackDelegate))]
+#endif
+        static void GetTierFeatureProgressForUserCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.FeaturesLimitResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.FeaturesLimitResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetTierFeatureProgressForUserCallbackDelegate GetTierFeatureProgressForUserDelegateInstance =
+            GetTierFeatureProgressForUserCallbackDelegateFunction;
+
+        /// <summary>Get Array of feature progresses for a user and their tier feature limits</summary>
+                /// <param name="FeatureNames">Array of feature names that will be retrieved</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.FeaturesLimitResult> GetTierFeatureProgressForUser(
+            Csp.Common.Array<Csp.Systems.TierFeatures> FeatureNames
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.FeaturesLimitResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetTierFeatureProgressForUser_void_ArrayRC_FeaturesLimitCallback(
+                _ptr,
+                FeatureNames._ptr,
+                GetTierFeatureProgressForUserDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetTierFeatureProgressForSpaceCallbackDelegate))]
+#endif
+        static void GetTierFeatureProgressForSpaceCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.FeaturesLimitResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.FeaturesLimitResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetTierFeatureProgressForSpaceCallbackDelegate GetTierFeatureProgressForSpaceDelegateInstance =
+            GetTierFeatureProgressForSpaceCallbackDelegateFunction;
+
+        /// <summary>Get Array of feature progress for a user Space and its tier feature limits</summary>
+                /// <param name="SpaceId">Id of the Space</param>
+                /// <param name="FeatureNames">Array of feature names that will be retrieved</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.FeaturesLimitResult> GetTierFeatureProgressForSpace(
+            string SpaceId,
+            Csp.Common.Array<Csp.Systems.TierFeatures> FeatureNames
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.FeaturesLimitResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetTierFeatureProgressForSpace_void_StringRC_ArrayRC_FeaturesLimitCallback(
+                _ptr,
+                SpaceId,
+                FeatureNames._ptr,
+                GetTierFeatureProgressForSpaceDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetCurrentUserTierCallbackDelegate))]
+#endif
+        static void GetCurrentUserTierCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.UserTierResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.UserTierResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetCurrentUserTierCallbackDelegate GetCurrentUserTierDelegateInstance =
+            GetCurrentUserTierCallbackDelegateFunction;
+
+        /// <summary>Get current users tier information</summary>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.UserTierResult> GetCurrentUserTier()
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.UserTierResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetCurrentUserTier_void_UserTierCallback(
+                _ptr,
+                GetCurrentUserTierDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetTierFeatureQuotaCallbackDelegate))]
+#endif
+        static void GetTierFeatureQuotaCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.FeatureQuotaResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.FeatureQuotaResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetTierFeatureQuotaCallbackDelegate GetTierFeatureQuotaDelegateInstance =
+            GetTierFeatureQuotaCallbackDelegateFunction;
+
+        /// <summary>Get current feature quota information</summary>
+                /// <param name="TierName">Name of the tier</param>
+                /// <param name="FeatureName">Name of the feature</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.FeatureQuotaResult> GetTierFeatureQuota(
+            Csp.Systems.TierNames TierName,
+            Csp.Systems.TierFeatures FeatureName
+        ) {
+            var tcs = new TaskCompletionSource<Csp.Systems.FeatureQuotaResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetTierFeatureQuota_void_TierNamesRC_TierFeaturesRC_FeatureQuotaCallback(
+                _ptr,
+                (IntPtr)TierName,
+                (IntPtr)FeatureName,
+                GetTierFeatureQuotaDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+#if !UNITY_EDITOR && ENABLE_IL2CPP
+        [AOT.MonoPInvokeCallback (typeof (GetTierFeaturesQuotaCallbackDelegate))]
+#endif
+        static void GetTierFeaturesQuotaCallbackDelegateFunction(IntPtr _StateObject__, NativePointer _Result)
+        {
+            var _handle = (GCHandle)_StateObject__;
+            var tcs = (TaskCompletionSource<Csp.Systems.FeaturesQuotaResult>)_handle.Target;
+            var _this = (QuotaSystem)tcs.Task.AsyncState;
+
+            var task_result = new Csp.Systems.FeaturesQuotaResult(_Result);
+
+            if (task_result.GetResultCode() == Csp.Services.EResultCode.InProgress)
+            {
+                return;
+            }
+
+            tcs.SetResult(task_result);
+            _handle.Free();
+        }
+
+        static readonly GetTierFeaturesQuotaCallbackDelegate GetTierFeaturesQuotaDelegateInstance =
+            GetTierFeaturesQuotaCallbackDelegateFunction;
+
+        /// <summary>Get current array of current feature quota information inside a tier</summary>
+                /// <param name="TierName">Name of the tier</param>
+                /// <returns>Result class</returns>
+
+        public Task<Csp.Systems.FeaturesQuotaResult> GetTierFeaturesQuota(Csp.Systems.TierNames TierName)
+        {
+            var tcs = new TaskCompletionSource<Csp.Systems.FeaturesQuotaResult>(this);
+            var handle = GCHandle.Alloc(tcs);
+
+            csp_systems_QuotaSystem_GetTierFeaturesQuota_void_TierNamesRC_FeaturesQuotaCallback(
+                _ptr,
+                (IntPtr)TierName,
+                GetTierFeaturesQuotaDelegateInstance,
+                (IntPtr)handle
+            );
+
+            return tcs.Task;
+        }
+
+        protected QuotaSystem() { }
+    }
+}
+

package/Source/Systems/Quota/QuotaSystem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5f9d811d389e4b3bad3471da9da3e6da
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Source/Systems/Quota/TierFeatures.cs

@@ -0,0 +1,28 @@
+// 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
+{
+    public enum TierFeatures
+    {
+        SpaceOwner = 0,
+        ScopeConcurrentUsers,
+        ObjectCaptureUpload,
+        AudioVideoUpload,
+        TotalUploadSizeInKilobytes,
+        Agora,
+        OpenAI,
+        Shopify,
+        TicketedSpace,
+    }
+}
+

package/Source/Systems/Quota/TierFeatures.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 64aa545c498d4f938d13a891fe20970b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Source/Systems/Quota/TierNames.cs

@@ -0,0 +1,23 @@
+// 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
+{
+    public enum TierNames
+    {
+        Basic = 0,
+        Premium,
+        Pro,
+        Enterprise,
+    }
+}
+

package/Source/Systems/Quota/TierNames.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 554201378c624b42a41223c25908879c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: