connected-spaces-platform.web 4.14.0 → 4.15.1

package/connectedspacesplatform.ts

@@ -787,6 +787,28 @@ function csp_systems_LogLevelFactory(
 }
 ProxyClassFactories["csp_systems_LogLevel"] = csp_systems_LogLevelFactory;
 
+function csp_systems_PeriodEnumFactory(
+  nativePointer: NativePointer,
+): Systems.PeriodEnum {
+  return nativePointer.pointer as Systems.PeriodEnum;
+}
+ProxyClassFactories["csp_systems_PeriodEnum"] = csp_systems_PeriodEnumFactory;
+
+function csp_systems_TierFeaturesFactory(
+  nativePointer: NativePointer,
+): Systems.TierFeatures {
+  return nativePointer.pointer as Systems.TierFeatures;
+}
+ProxyClassFactories["csp_systems_TierFeatures"] =
+  csp_systems_TierFeaturesFactory;
+
+function csp_systems_TierNamesFactory(
+  nativePointer: NativePointer,
+): Systems.TierNames {
+  return nativePointer.pointer as Systems.TierNames;
+}
+ProxyClassFactories["csp_systems_TierNames"] = csp_systems_TierNamesFactory;
+
 function csp_systems_SpaceAttributesFactory(
   nativePointer: NativePointer,
 ): Systems.SpaceAttributes {
@@ -1232,6 +1254,30 @@ function csp_systems_MaintenanceInfoFactory(
 ProxyClassFactories["csp_systems_MaintenanceInfo"] =
   csp_systems_MaintenanceInfoFactory;
 
+function csp_systems_FeatureLimitInfoFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.FeatureLimitInfo(nativePointer);
+}
+ProxyClassFactories["csp_systems_FeatureLimitInfo"] =
+  csp_systems_FeatureLimitInfoFactory;
+
+function csp_systems_UserTierInfoFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.UserTierInfo(nativePointer);
+}
+ProxyClassFactories["csp_systems_UserTierInfo"] =
+  csp_systems_UserTierInfoFactory;
+
+function csp_systems_FeatureQuotaInfoFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.FeatureQuotaInfo(nativePointer);
+}
+ProxyClassFactories["csp_systems_FeatureQuotaInfo"] =
+  csp_systems_FeatureQuotaInfoFactory;
+
 function csp_systems_ScriptSystemFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1813,6 +1859,53 @@ function csp_systems_MaintenanceSystemFactory(
 ProxyClassFactories["csp_systems_MaintenanceSystem"] =
   csp_systems_MaintenanceSystemFactory;
 
+function csp_systems_FeaturesLimitResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.FeaturesLimitResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_FeaturesLimitResult"] =
+  csp_systems_FeaturesLimitResultFactory;
+
+function csp_systems_FeatureLimitResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.FeatureLimitResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_FeatureLimitResult"] =
+  csp_systems_FeatureLimitResultFactory;
+
+function csp_systems_UserTierResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.UserTierResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_UserTierResult"] =
+  csp_systems_UserTierResultFactory;
+
+function csp_systems_FeatureQuotaResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.FeatureQuotaResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_FeatureQuotaResult"] =
+  csp_systems_FeatureQuotaResultFactory;
+
+function csp_systems_FeaturesQuotaResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.FeaturesQuotaResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_FeaturesQuotaResult"] =
+  csp_systems_FeaturesQuotaResultFactory;
+
+function csp_systems_QuotaSystemFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.QuotaSystem(nativePointer);
+}
+ProxyClassFactories["csp_systems_QuotaSystem"] = csp_systems_QuotaSystemFactory;
+
 function csp_systems_SettingsCollectionResultFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2257,6 +2350,42 @@ function csp_common_Array_csp_systems_MaintenanceInfoFactory(
 ProxyClassFactories["csp_common_Array_csp_systems_MaintenanceInfo"] =
   csp_common_Array_csp_systems_MaintenanceInfoFactory;
 
+function csp_common_Array_csp_systems_FeatureLimitInfoFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<Systems.FeatureLimitInfo>(
+    nativePointer,
+    csp_systems_FeatureLimitInfoFactory,
+    "csp_systems_FeatureLimitInfo",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_systems_FeatureLimitInfo"] =
+  csp_common_Array_csp_systems_FeatureLimitInfoFactory;
+
+function csp_common_Array_csp_systems_FeatureQuotaInfoFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<Systems.FeatureQuotaInfo>(
+    nativePointer,
+    csp_systems_FeatureQuotaInfoFactory,
+    "csp_systems_FeatureQuotaInfo",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_systems_FeatureQuotaInfo"] =
+  csp_common_Array_csp_systems_FeatureQuotaInfoFactory;
+
+function csp_common_Array_csp_systems_TierFeaturesFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<Systems.TierFeatures>(
+    nativePointer,
+    csp_systems_TierFeaturesFactory,
+    "csp_systems_TierFeatures",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_systems_TierFeatures"] =
+  csp_common_Array_csp_systems_TierFeaturesFactory;
+
 function csp_common_Array_csp_systems_SiteFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -3337,6 +3466,41 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data representation period of time.  
+ */
+  export enum PeriodEnum {
+    Total,
+    CalendarMonth,
+    Hours24,
+  }
+}
+
+export namespace Systems {
+  export enum TierFeatures {
+    SpaceOwner = 0,
+    ScopeConcurrentUsers,
+    ObjectCaptureUpload,
+    AudioVideoUpload,
+    TotalUploadSizeInKilobytes,
+    Agora,
+    OpenAI,
+    Shopify,
+    TicketedSpace,
+  }
+}
+
+export namespace Systems {
+  export enum TierNames {
+    Basic = 0,
+    Premium,
+    Pro,
+    Enterprise,
+  }
+}
+
 export namespace Systems {
   export enum SpaceAttributes {
     None = 0,
@@ -4129,6 +4293,26 @@ export class EndpointURIs
       [this.pointer, value],
     );
   }
+
+  get trackingServiceURI(): string {
+    let _result = Module.ccall(
+      "csp_EndpointURIs__Get_TrackingServiceURI",
+      "string",
+      ["number"],
+      [this.pointer],
+    );
+
+    return _result;
+  }
+
+  set trackingServiceURI(value: string) {
+    Module.ccall(
+      "csp_EndpointURIs__Set_TrackingServiceURI",
+      "void",
+      ["number", "string"],
+      [this.pointer, value],
+    );
+  }
 }
 
 /**
@@ -25387,6 +25571,26 @@ export namespace Systems {
 
       return _nPtr;
     }
+
+    /**
+     * @description Retrieves the Quota system.
+     * @return Pointer to the quota system class
+     */
+
+    getQuotaSystem(): Systems.QuotaSystem {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SystemsManager_GetQuotaSystem_QuotaSystemP",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.QuotaSystem(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
   }
 }
 
@@ -28634,6 +28838,349 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data representation of a progress of a specific feature.  
+ * Limit Value of -1 means unlimited usage  
+ */
+  export class FeatureLimitInfo
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): FeatureLimitInfo {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_systems_FeatureLimitInfo_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new FeatureLimitInfo(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_FeatureLimitInfo_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get featureName(): Systems.TierFeatures {
+      let _result = Module.ccall(
+        "csp_systems_FeatureLimitInfo__Get_FeatureName",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set featureName(value: Systems.TierFeatures) {
+      Module.ccall(
+        "csp_systems_FeatureLimitInfo__Set_FeatureName",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get activityCount(): number {
+      let _result = Module.ccall(
+        "csp_systems_FeatureLimitInfo__Get_ActivityCount",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set activityCount(value: number) {
+      Module.ccall(
+        "csp_systems_FeatureLimitInfo__Set_ActivityCount",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get limit(): number {
+      let _result = Module.ccall(
+        "csp_systems_FeatureLimitInfo__Get_Limit",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set limit(value: number) {
+      Module.ccall(
+        "csp_systems_FeatureLimitInfo__Set_Limit",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data representation of a progress of a specific feature.  
+ */
+  export class UserTierInfo
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): UserTierInfo {
+      var _ptr = Module._malloc(8);
+      Module.ccall("csp_systems_UserTierInfo_Ctor", "void", ["number"], [_ptr]);
+      var _nPtr = getNativePointer(_ptr);
+
+      return new UserTierInfo(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_UserTierInfo_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get assignToType(): string {
+      let _result = Module.ccall(
+        "csp_systems_UserTierInfo__Get_AssignToType",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set assignToType(value: string) {
+      Module.ccall(
+        "csp_systems_UserTierInfo__Set_AssignToType",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get assignToId(): string {
+      let _result = Module.ccall(
+        "csp_systems_UserTierInfo__Get_AssignToId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set assignToId(value: string) {
+      Module.ccall(
+        "csp_systems_UserTierInfo__Set_AssignToId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get tierName(): Systems.TierNames {
+      let _result = Module.ccall(
+        "csp_systems_UserTierInfo__Get_TierName",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set tierName(value: Systems.TierNames) {
+      Module.ccall(
+        "csp_systems_UserTierInfo__Set_TierName",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data representation of a progress of a specific feature.  
+ * Limit Value of -1 means unlimited usage  
+ */
+  export class FeatureQuotaInfo
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): FeatureQuotaInfo {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_systems_FeatureQuotaInfo_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new FeatureQuotaInfo(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_FeatureQuotaInfo_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get featureName(): Systems.TierFeatures {
+      let _result = Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Get_FeatureName",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set featureName(value: Systems.TierFeatures) {
+      Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Set_FeatureName",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get tierName(): Systems.TierNames {
+      let _result = Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Get_TierName",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set tierName(value: Systems.TierNames) {
+      Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Set_TierName",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get limit(): number {
+      let _result = Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Get_Limit",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set limit(value: number) {
+      Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Set_Limit",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get period(): Systems.PeriodEnum {
+      let _result = Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Get_Period",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set period(value: Systems.PeriodEnum) {
+      Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Set_Period",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get allowReductions(): boolean {
+      let _result = Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Get_AllowReductions",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set allowReductions(value: boolean) {
+      Module.ccall(
+        "csp_systems_FeatureQuotaInfo__Set_AllowReductions",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Systems {
   /**
    * @description A JavaScript based scripting system that can be used to create advanced behaviours and interactions between entities in spaces.
@@ -43410,6 +43957,687 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data class used to contain information when receiving an array of feature progress.  
+ */
+  export class FeaturesLimitResult
+    extends Services.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Services.ResultBase,
+    ): Systems.FeaturesLimitResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.FeaturesLimitResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Retrieves the feature progress result.
+     * @return Const array of feature progress class
+     */
+
+    getFeaturesLimitInfo(): Common.Array<Systems.FeatureLimitInfo> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_FeaturesLimitResult_GetFeaturesLimitInfoC_ArrayRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Array<Systems.FeatureLimitInfo>(
+        getNativePointer(_ret),
+        csp_systems_FeatureLimitInfoFactory,
+        "csp_systems_FeatureLimitInfo",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_FeaturesLimitResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data class used to contain information when receiving an array of feature progresses.  
+ */
+  export class FeatureLimitResult
+    extends Services.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Services.ResultBase,
+    ): Systems.FeatureLimitResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.FeatureLimitResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Retrieves the feature progress result.  
+    @returnFeatureProgress : const ref to feature progress class
+     */
+
+    getFeatureLimitInfo(): Systems.FeatureLimitInfo {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_FeatureLimitResult_GetFeatureLimitInfoC_FeatureLimitInfoRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.FeatureLimitInfo(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_FeatureLimitResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data class used to contain information when receiving user tier information.  
+ */
+  export class UserTierResult
+    extends Services.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Services.ResultBase,
+    ): Systems.UserTierResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.UserTierResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Retrieves the user tier result.  
+    @returnFeatureProgress : const ref to user tier information class
+     */
+
+    getUserTierInfo(): Systems.UserTierInfo {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_UserTierResult_GetUserTierInfoC_UserTierInfoRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.UserTierInfo(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_UserTierResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data class used to contain information when receiving feature quota information.  
+ */
+  export class FeatureQuotaResult
+    extends Services.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Services.ResultBase,
+    ): Systems.FeatureQuotaResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.FeatureQuotaResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Retrieves the feature quota result.  
+    @returnFeatureProgress : const ref to feature quota class
+     */
+
+    getFeatureQuotaInfo(): Systems.FeatureQuotaInfo {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_FeatureQuotaResult_GetFeatureQuotaInfoC_FeatureQuotaInfoRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.FeatureQuotaInfo(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_FeatureQuotaResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Data class used to contain information when receiving an array of feature quota information.  
+ */
+  export class FeaturesQuotaResult
+    extends Services.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Services.ResultBase,
+    ): Systems.FeaturesQuotaResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.FeaturesQuotaResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Retrieves an array of feature quota results.  
+    @returnFeatureProgress : const ref to feature quota class
+     */
+
+    getFeaturesQuotaInfo(): Common.Array<Systems.FeatureQuotaInfo> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_FeaturesQuotaResult_GetFeaturesQuotaInfoC_ArrayRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Array<Systems.FeatureQuotaInfo>(
+        getNativePointer(_ret),
+        csp_systems_FeatureQuotaInfoFactory,
+        "csp_systems_FeatureQuotaInfo",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_FeaturesQuotaResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Quota System
+ * @description Public facing system that allows interfacing with Magnopus Connect Services' Quota Server.  
+ * Offers methods for receiving Quota Queries.  
+ */
+  export class QuotaSystem extends Systems.SystemBase {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromSystemBase(
+      baseInstance: Systems.SystemBase,
+    ): Systems.QuotaSystem {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.QuotaSystem(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Get the total number of Spaces owned by the current user and their tier space limit
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getTotalSpacesOwnedByUser(): Promise<Systems.FeatureLimitResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.FeatureLimitResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.FeatureLimitResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetTotalSpacesOwnedByUser_void_FeatureLimitCallback",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Gets total number of user inside of a space and its tier user limit
+     * @param spaceId - Id of the Space
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getConcurrentUsersInSpace(
+      spaceId: string,
+    ): Promise<Systems.FeatureLimitResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.FeatureLimitResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.FeatureLimitResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetConcurrentUsersInSpace_void_StringRC_FeatureLimitCallback",
+        "void",
+        ["number", "string", "number", "number"],
+        [this.pointer, spaceId, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Get total size of all assets within a space and their tier space size limit
+     * @param spaceId - Id of the Space
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getTotalSpaceSizeInKilobytes(
+      spaceId: string,
+    ): Promise<Systems.FeatureLimitResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.FeatureLimitResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.FeatureLimitResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetTotalSpaceSizeInKilobytes_void_StringRC_FeatureLimitCallback",
+        "void",
+        ["number", "string", "number", "number"],
+        [this.pointer, spaceId, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Get Array of feature progresses for a user and their tier feature limits
+     * @param featureNames - Array of feature names that will be retrieved
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getTierFeatureProgressForUser(
+      featureNames: Common.Array<Systems.TierFeatures>,
+    ): Promise<Systems.FeaturesLimitResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.FeaturesLimitResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.FeaturesLimitResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetTierFeatureProgressForUser_void_ArrayRC_FeaturesLimitCallback",
+        "void",
+        ["number", "number", "number", "number"],
+        [this.pointer, featureNames.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Get Array of feature progress for a user Space and its tier feature limits
+     * @param spaceId - Id of the Space
+     * @param featureNames - Array of feature names that will be retrieved
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getTierFeatureProgressForSpace(
+      spaceId: string,
+      featureNames: Common.Array<Systems.TierFeatures>,
+    ): Promise<Systems.FeaturesLimitResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.FeaturesLimitResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.FeaturesLimitResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetTierFeatureProgressForSpace_void_StringRC_ArrayRC_FeaturesLimitCallback",
+        "void",
+        ["number", "string", "number", "number", "number"],
+        [this.pointer, spaceId, featureNames.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Get current users tier information
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getCurrentUserTier(): Promise<Systems.UserTierResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.UserTierResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.UserTierResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetCurrentUserTier_void_UserTierCallback",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Get current feature quota information
+     * @param tierName - Name of the tier
+     * @param featureName - Name of the feature
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getTierFeatureQuota(
+      tierName: Systems.TierNames,
+      featureName: Systems.TierFeatures,
+    ): Promise<Systems.FeatureQuotaResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.FeatureQuotaResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.FeatureQuotaResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetTierFeatureQuota_void_TierNames_TierFeatures_FeatureQuotaCallback",
+        "void",
+        ["number", "number", "number", "number", "number"],
+        [this.pointer, tierName, featureName, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Get current array of current feature quota information inside a tier
+     * @param tierName - Name of the tier
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async getTierFeaturesQuota(
+      tierName: Systems.TierNames,
+    ): Promise<Systems.FeaturesQuotaResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.FeaturesQuotaResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.FeaturesQuotaResult(_resultPtr);
+
+        if (
+          _resultInstance.getResultCode() == Services.EResultCode.InProgress
+        ) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_QuotaSystem_GetTierFeaturesQuota_void_TierNames_FeaturesQuotaCallback",
+        "void",
+        ["number", "number", "number", "number"],
+        [this.pointer, tierName, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Settings System
@@ -49773,6 +51001,60 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_FeatureLimitInfo(): Array<Systems.FeatureLimitInfo> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_systems_FeatureLimitInfo",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<Systems.FeatureLimitInfo>(
+        getNativePointer(_ret),
+        csp_systems_FeatureLimitInfoFactory,
+        "csp_systems_FeatureLimitInfo",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
+    static ofcsp_systems_FeatureQuotaInfo(): Array<Systems.FeatureQuotaInfo> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_systems_FeatureQuotaInfo",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<Systems.FeatureQuotaInfo>(
+        getNativePointer(_ret),
+        csp_systems_FeatureQuotaInfoFactory,
+        "csp_systems_FeatureQuotaInfo",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
+    static ofcsp_systems_TierFeatures(): Array<Systems.TierFeatures> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_systems_TierFeatures",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<Systems.TierFeatures>(
+        getNativePointer(_ret),
+        csp_systems_TierFeaturesFactory,
+        "csp_systems_TierFeatures",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_Site(): Array<Systems.Site> {
       var _ret = Module._malloc(8);
       Module.ccall(
@@ -50349,6 +51631,66 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_FeatureLimitInfo_number(
+      size: number,
+    ): Array<Systems.FeatureLimitInfo> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_systems_FeatureLimitInfo",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<Systems.FeatureLimitInfo>(
+        getNativePointer(_ret),
+        csp_systems_FeatureLimitInfoFactory,
+        "csp_systems_FeatureLimitInfo",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
+    static ofcsp_systems_FeatureQuotaInfo_number(
+      size: number,
+    ): Array<Systems.FeatureQuotaInfo> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_systems_FeatureQuotaInfo",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<Systems.FeatureQuotaInfo>(
+        getNativePointer(_ret),
+        csp_systems_FeatureQuotaInfoFactory,
+        "csp_systems_FeatureQuotaInfo",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
+    static ofcsp_systems_TierFeatures_number(
+      size: number,
+    ): Array<Systems.TierFeatures> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_systems_TierFeatures",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<Systems.TierFeatures>(
+        getNativePointer(_ret),
+        csp_systems_TierFeaturesFactory,
+        "csp_systems_TierFeatures",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_Site_number(size: number): Array<Systems.Site> {
       var _ret = Module._malloc(8);
       Module.ccall(