connected-spaces-platform.web 4.28.1 → 4.30.0

package/connectedspacesplatform.ts

@@ -366,6 +366,14 @@ function csp_multiplayer_EPermissionChangeTypeFactory(
 ProxyClassFactories["csp_multiplayer_EPermissionChangeType"] =
   csp_multiplayer_EPermissionChangeTypeFactory;
 
+function csp_multiplayer_ESequenceUpdateTypeFactory(
+  nativePointer: NativePointer,
+): Multiplayer.ESequenceUpdateType {
+  return nativePointer.pointer as Multiplayer.ESequenceUpdateType;
+}
+ProxyClassFactories["csp_multiplayer_ESequenceUpdateType"] =
+  csp_multiplayer_ESequenceUpdateTypeFactory;
+
 function csp_multiplayer_ConnectionStateFactory(
   nativePointer: NativePointer,
 ): Multiplayer.ConnectionState {
@@ -597,6 +605,14 @@ function csp_multiplayer_GaussianSplatPropertyKeysFactory(
 ProxyClassFactories["csp_multiplayer_GaussianSplatPropertyKeys"] =
   csp_multiplayer_GaussianSplatPropertyKeysFactory;
 
+function csp_multiplayer_HotspotPropertyKeysFactory(
+  nativePointer: NativePointer,
+): Multiplayer.HotspotPropertyKeys {
+  return nativePointer.pointer as Multiplayer.HotspotPropertyKeys;
+}
+ProxyClassFactories["csp_multiplayer_HotspotPropertyKeys"] =
+  csp_multiplayer_HotspotPropertyKeysFactory;
+
 function csp_multiplayer_ImagePropertyKeysFactory(
   nativePointer: NativePointer,
 ): Multiplayer.ImagePropertyKeys {
@@ -999,6 +1015,14 @@ function csp_multiplayer_UserPermissionsParamsFactory(
 ProxyClassFactories["csp_multiplayer_UserPermissionsParams"] =
   csp_multiplayer_UserPermissionsParamsFactory;
 
+function csp_multiplayer_SequenceChangedParamsFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.SequenceChangedParams(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_SequenceChangedParams"] =
+  csp_multiplayer_SequenceChangedParamsFactory;
+
 function csp_multiplayer_MultiplayerConnectionFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1333,6 +1357,13 @@ function csp_systems_ScriptSystemFactory(
 ProxyClassFactories["csp_systems_ScriptSystem"] =
   csp_systems_ScriptSystemFactory;
 
+function csp_systems_SequenceFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.Sequence(nativePointer);
+}
+ProxyClassFactories["csp_systems_Sequence"] = csp_systems_SequenceFactory;
+
 function csp_systems_SettingsCollectionFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1574,6 +1605,14 @@ function csp_multiplayer_GaussianSplatSpaceComponentFactory(
 ProxyClassFactories["csp_multiplayer_GaussianSplatSpaceComponent"] =
   csp_multiplayer_GaussianSplatSpaceComponentFactory;
 
+function csp_multiplayer_HotspotSpaceComponentFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.HotspotSpaceComponent(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_HotspotSpaceComponent"] =
+  csp_multiplayer_HotspotSpaceComponentFactory;
+
 function csp_multiplayer_ImageSpaceComponentFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2009,6 +2048,30 @@ function csp_systems_QuotaSystemFactory(
 }
 ProxyClassFactories["csp_systems_QuotaSystem"] = csp_systems_QuotaSystemFactory;
 
+function csp_systems_SequenceResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.SequenceResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_SequenceResult"] =
+  csp_systems_SequenceResultFactory;
+
+function csp_systems_SequencesResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.SequencesResult(nativePointer);
+}
+ProxyClassFactories["csp_systems_SequencesResult"] =
+  csp_systems_SequencesResultFactory;
+
+function csp_systems_SequenceSystemFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Systems.SequenceSystem(nativePointer);
+}
+ProxyClassFactories["csp_systems_SequenceSystem"] =
+  csp_systems_SequenceSystemFactory;
+
 function csp_systems_SettingsCollectionResultFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2545,6 +2608,18 @@ function csp_common_Array_csp_systems_TierFeaturesFactory(
 ProxyClassFactories["csp_common_Array_csp_systems_TierFeatures"] =
   csp_common_Array_csp_systems_TierFeaturesFactory;
 
+function csp_common_Array_csp_systems_SequenceFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<Systems.Sequence>(
+    nativePointer,
+    csp_systems_SequenceFactory,
+    "csp_systems_Sequence",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_systems_Sequence"] =
+  csp_common_Array_csp_systems_SequenceFactory;
+
 function csp_common_Array_csp_systems_SiteFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2851,6 +2926,7 @@ export namespace Multiplayer {
     FiducialMarker,
     GaussianSplat,
     Text,
+    Hotspot,
   }
 }
 
@@ -2880,6 +2956,14 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  export enum ESequenceUpdateType {
+    Create,
+    Update,
+    Delete,
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Enum used to specify the current state of the multiplayer connection.
@@ -3312,6 +3396,22 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  /**
+   * @description Enumerates the list of properties that can be replicated for an Hotspot space component.
+   */
+  export enum HotspotPropertyKeys {
+    Position,
+    Rotation,
+    Name,
+    IsTeleportPoint,
+    IsSpawnPoint,
+    IsVisible,
+    IsARVisible,
+    Num,
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Enumerates the list of properties that can be replicated for an image space component.
@@ -4588,6 +4688,26 @@ export class EndpointURIs
       [this.pointer, value],
     );
   }
+
+  get maintenanceWindowURI(): string {
+    let _result = Module.ccall(
+      "csp_EndpointURIs__Get_MaintenanceWindowURI",
+      "string",
+      ["number"],
+      [this.pointer],
+    );
+
+    return _result;
+  }
+
+  set maintenanceWindowURI(value: string) {
+    Module.ccall(
+      "csp_EndpointURIs__Set_MaintenanceWindowURI",
+      "void",
+      ["number", "string"],
+      [this.pointer, value],
+    );
+  }
 }
 
 /**
@@ -21590,6 +21710,104 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  export class SequenceChangedParams
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): SequenceChangedParams {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new SequenceChangedParams(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_SequenceChangedParams_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get updateType(): Multiplayer.ESequenceUpdateType {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Get_UpdateType",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set updateType(value: Multiplayer.ESequenceUpdateType) {
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Set_UpdateType",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get key(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Get_Key",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set key(value: string) {
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Set_Key",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get newKey(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Get_NewKey",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set newKey(value: string) {
+      Module.ccall(
+        "csp_multiplayer_SequenceChangedParams__Set_NewKey",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
 @ingroup Multiplayer
@@ -21837,6 +22055,31 @@ export namespace Multiplayer {
       );
     }
 
+    /**
+     * @description Sets a callback for a sequence changed event.
+     * @param callback - Callback to receive data for the sequence that has been changed.
+     */
+    setSequenceChangedCallback(
+      callback: (arg1: Multiplayer.SequenceChangedParams) => void,
+    ) {
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1 = new Multiplayer.SequenceChangedParams(
+          getNativePointer(arg1),
+        );
+
+        callback(_arg1);
+      };
+
+      var _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_multiplayer_MultiplayerConnection_SetSequenceChangedCallback_void_SequenceChangedCallbackHandler",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+    }
+
     /**
      * @description Registers a callback to listen for the named event.
      * @param eventName - The identifying name for the event to listen for.
@@ -25454,6 +25697,26 @@ export namespace Systems {
       return _nPtr;
     }
 
+    /**
+     * @description Retrieves the Sequence system.
+     * @return Pointer to the sequence system class
+     */
+
+    getSequenceSystem(): Systems.SequenceSystem {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SystemsManager_GetSequenceSystem_SequenceSystemP",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.SequenceSystem(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
     getSpaceEntitySystem(): Multiplayer.SpaceEntitySystem {
       var _ret = Module._malloc(8);
 
@@ -29863,6 +30126,122 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description A basic class abstraction for a sequence, including key, and reference variables, and items.  
+ */
+  export class Sequence extends NativeClassWrapper implements INativeResource {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): Sequence {
+      var _ptr = Module._malloc(8);
+      Module.ccall("csp_systems_Sequence_Ctor", "void", ["number"], [_ptr]);
+      var _nPtr = getNativePointer(_ptr);
+
+      return new Sequence(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_Sequence_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get key(): string {
+      let _result = Module.ccall(
+        "csp_systems_Sequence__Get_Key",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set key(value: string) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_Key",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceType(): string {
+      let _result = Module.ccall(
+        "csp_systems_Sequence__Get_ReferenceType",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceType(value: string) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_ReferenceType",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceId(): string {
+      let _result = Module.ccall(
+        "csp_systems_Sequence__Get_ReferenceId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceId(value: string) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_ReferenceId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get items(): Common.Array<string> {
+      const _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_systems_Sequence__Get_Items",
+        "void",
+        ["number", "number"],
+        [_ptr, this.pointer],
+      );
+
+      const _nPtr = getNativePointer(_ptr);
+      return new Common.Array<string>(_nPtr, StringFactory, "String");
+    }
+
+    set items(value: Common.Array<string>) {
+      Module.ccall(
+        "csp_systems_Sequence__Set_Items",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Settings System
@@ -37741,6 +38120,313 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  /**
+@ingroup HotspotSpaceComponent
+ * @description Data representation of an HotspotSpaceComponent.  
+ */
+  export class HotspotSpaceComponent
+    extends Multiplayer.ComponentBase
+    implements
+      Multiplayer.IPositionComponent,
+      Multiplayer.IRotationComponent,
+      Multiplayer.IVisibleComponent,
+      INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromComponentBase(
+      baseInstance: Multiplayer.ComponentBase,
+    ): Multiplayer.HotspotSpaceComponent {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Multiplayer.HotspotSpaceComponent(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Constructs the Hotspot space component, and associates it with the specified Parent space entity.
+     * @param parent - The Space entity that owns this component.
+     */
+    static create_parent(
+      parent: Multiplayer.SpaceEntity,
+    ): HotspotSpaceComponent {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_Ctor_SpaceEntityP",
+        "void",
+        ["number", "number"],
+        [_ptr, parent.pointer],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new HotspotSpaceComponent(_nPtr);
+    }
+
+    /**
+     * @description Gets the Name of the Hotspot.
+     * @return The Name of the Hotspot.
+     */
+
+    getName(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetNameC_StringRC",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _resultString = Module.UTF8ToString(_result);
+      free(_result);
+
+      _result = _resultString;
+
+      return _result;
+    }
+
+    /**
+     * @description Sets the Name of this Hotspot.
+     * @param value - The Name of this Hotspot.
+     */
+
+    setName(value: string): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetName_void_StringRC",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Gets the IsTeleportPoint of this Hotspot.
+     */
+
+    getIsTeleportPoint(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetIsTeleportPointC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Sets this Hotspot to be a teleport point.
+     * @param inValue - The teleport point state flag value.
+     */
+
+    setIsTeleportPoint(value: boolean): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetIsTeleportPoint_void_bool",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Gets the IsSpawnPoint of this Hotspot.
+     */
+
+    getIsSpawnPoint(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetIsSpawnPointC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Sets this Hotspot to be a spawn point.
+     * @param inValue - The spawn point state flag value.
+     */
+
+    setIsSpawnPoint(value: boolean): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetIsSpawnPoint_void_bool",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Gets a unique identifier for this component in the hierarchy.
+     * NOTE: This does not give a complete hierarchy path, only the entityId of the parent for the component.
+     * @return Componentid'.
+     */
+
+    getUniqueComponentId(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetUniqueComponentIdC_StringRC",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _resultString = Module.UTF8ToString(_result);
+      free(_result);
+
+      _result = _resultString;
+
+      return _result;
+    }
+
+    /**
+     * \addtogroup IPositionComponent  
+    @{
+    @copydoc IPositionComponent::GetPosition()
+     */
+
+    getPosition(): Common.Vector3 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetPositionC_Vector3RC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Vector3(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+    @copydoc IPositionComponent::SetPosition()
+     */
+
+    setPosition(value: Common.Vector3): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetPosition_void_Vector3RC",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+
+    /**
+    @}
+     * \addtogroup IRotationComponent  
+    @{
+    @copydoc IRotationComponent::GetRotation()
+     */
+
+    getRotation(): Common.Vector4 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetRotationC_Vector4RC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Vector4(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+    @copydoc IRotationComponent::SetRotation()
+     */
+
+    setRotation(value: Common.Vector4): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetRotation_void_Vector4RC",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+
+    /**
+    @}
+     * \addtogroup IVisibleComponent  
+    @{
+    @copydoc IVisibleComponent::GetIsVisible()
+     */
+
+    getIsVisible(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetIsVisibleC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+    @copydoc IVisibleComponent::SetIsVisible()
+     */
+
+    setIsVisible(value: boolean): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetIsVisible_void_bool",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+    @copydoc IVisibleComponent::GetIsARVisible()
+     */
+
+    getIsARVisible(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_GetIsARVisibleC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+    @copydoc IVisibleComponent::SetIsARVisible()
+     */
+
+    setIsARVisible(value: boolean): void {
+      Module.ccall(
+        "csp_multiplayer_HotspotSpaceComponent_SetIsARVisible_void_bool",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_HotspotSpaceComponent_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
 @ingroup ImageSpaceComponent
@@ -45537,7 +46223,9 @@ export namespace Systems {
      * @param callback - Callback when asynchronous task finishes
      */
 
-    async getMaintenanceInfo(): Promise<Systems.MaintenanceInfoResult> {
+    async getMaintenanceInfo(
+      maintenanceURL: string,
+    ): Promise<Systems.MaintenanceInfoResult> {
       var _resolve;
 
       var _promise = new Promise<Systems.MaintenanceInfoResult>((_r) => {
@@ -45561,10 +46249,10 @@ export namespace Systems {
       _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
-        "csp_systems_MaintenanceSystem_GetMaintenanceInfo_void_MaintenanceInfoCallback",
+        "csp_systems_MaintenanceSystem_GetMaintenanceInfo_void_StringRC_MaintenanceInfoCallback",
         "void",
-        ["number", "number", "number"],
-        [this.pointer, _callbackPtr, 0],
+        ["number", "string", "number", "number"],
+        [this.pointer, maintenanceURL, _callbackPtr, 0],
       );
 
       return _promise;
@@ -46827,6 +47515,339 @@ export namespace Systems {
   }
 }
 
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description Result structure for a sequence result  
+ */
+  export class SequenceResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Systems.SequenceResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.SequenceResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    getSequence(): Systems.Sequence {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SequenceResult_GetSequenceC_SequenceRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Systems.Sequence(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_SequenceResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description Data class used to contain information when attempting to get an array of sequences.  
+ */
+  export class SequencesResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Systems.SequencesResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.SequencesResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    getSequences(): Common.Array<Systems.Sequence> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_systems_SequencesResult_GetSequencesC_ArrayRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Array<Systems.Sequence>(
+        getNativePointer(_ret),
+        csp_systems_SequenceFactory,
+        "csp_systems_Sequence",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_systems_SequencesResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Systems {
+  /**
+@ingroup Sequence System
+ * @description Public facing system that allows the management of groupings of items in a space.  
+ */
+  export class SequenceSystem extends Systems.SystemBase {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromSystemBase(
+      baseInstance: Systems.SystemBase,
+    ): Systems.SequenceSystem {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Systems.SequenceSystem(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Creates a new sequence. If a sequence already exists with this key, it will overwrite the current one. This call will fail if the user
+     * isn't a creator of the space.
+     * @param sequenceKey - The unique grouping name. The suggested convention is: Type:[Id]
+     * @param referenceType - The type of reference (GroupId, SpaceId etc.)
+     * @param referenceId - The id of the reference
+     * @param items - An ordered array of members
+     * @param callback - Callback to call when a response is received
+     */
+
+    createSequence(
+      sequenceKey: string,
+      referenceType: string,
+      referenceId: string,
+      items: Common.Array<string>,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_CreateSequence_void_StringRC_StringRC_StringRC_ArrayRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "string", "string", "number", "number"],
+        [
+          this.pointer,
+          sequenceKey,
+          referenceType,
+          referenceId,
+          items.pointer,
+          callbackPtr,
+        ],
+      );
+    }
+
+    /**
+     * @description Updates an existing sequence. This call will fail if the user isn't a creator of the space.
+     * @param sequenceKey - The unique grouping name. The suggested convention is: Type:[Id]
+     * @param referenceType - The type of reference (GroupId, SpaceId etc.)
+     * @param referenceId - The id of the reference
+     * @param items - An ordered array of members
+     * @param callback - Callback to call when a response is received
+     */
+
+    updateSequence(
+      sequenceKey: string,
+      referenceType: string,
+      referenceId: string,
+      items: Common.Array<string>,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_UpdateSequence_void_StringRC_StringRC_StringRC_ArrayRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "string", "string", "number", "number"],
+        [
+          this.pointer,
+          sequenceKey,
+          referenceType,
+          referenceId,
+          items.pointer,
+          callbackPtr,
+        ],
+      );
+    }
+
+    /**
+     * @description Renames a given sequence. This call will fail if the user isn't a creator of the space.
+     * @param oldSequenceKey - The current sequence key name
+     * @param newSequenceKey - The new sequence key name
+     * @param callback - Callback to call when a response is received
+     */
+
+    renameSequence(
+      oldSequenceKey: string,
+      newSequenceKey: string,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_RenameSequence_void_StringRC_StringRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "string", "number"],
+        [this.pointer, oldSequenceKey, newSequenceKey, callbackPtr],
+      );
+    }
+
+    /**
+     * @description Finds sequences based on the given criteria
+     * @param sequenceKeys - An array of sequence keys to search for
+     * @param sequenceKeys - An optional regex string for searching keys
+     * @param referenceType - The type of reference (GroupId, SpaceId etc.). Must be used with ReferenceIds
+     * @param referenceIds - The ids of the reference. Must be used with ReferenceType
+     * @param callback - Callback to call when a response is received
+     */
+
+    getSequencesByCriteria(
+      sequenceKeys: Common.Array<string>,
+      keyRegex: string,
+      referenceType: string,
+      referenceIds: Common.Array<string>,
+      callback: (result: Systems.SequencesResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequencesResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_GetSequencesByCriteria_void_ArrayRC_StringRC_StringRC_ArrayRC_SequencesResultCallback",
+        "void",
+        ["number", "number", "string", "string", "number", "number"],
+        [
+          this.pointer,
+          sequenceKeys.pointer,
+          keyRegex,
+          referenceType,
+          referenceIds.pointer,
+          callbackPtr,
+        ],
+      );
+    }
+
+    /**
+     * @description Gets a sequence by it's key
+     * @param sequenceKey - The unique grouping name
+     * @param callback - Callback to call when a response is received
+     */
+
+    getSequence(
+      sequenceKey: string,
+      callback: (result: Systems.SequenceResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.SequenceResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_GetSequence_void_StringRC_SequenceResultCallback",
+        "void",
+        ["number", "string", "number"],
+        [this.pointer, sequenceKey, callbackPtr],
+      );
+    }
+
+    /**
+     * @description Deletes the given sequences. This call will fail if the user isn't a creator of the space
+     * @param sequenceKeys - An array of sequence keys to delete
+     * @param callback - Callback to call when a response is received
+     */
+
+    deleteSequences(
+      sequenceKeys: Common.Array<string>,
+      callback: (result: Systems.NullResult) => void,
+    ): void {
+      var _callback = (_stateObject__: number, result) => {
+        var _result = new Systems.NullResult(getNativePointer(result));
+        callback(_result);
+      };
+
+      var callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_DeleteSequences_void_ArrayRC_NullResultCallback",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, sequenceKeys.pointer, callbackPtr],
+      );
+    }
+  }
+}
+
 export namespace Systems {
   /**
 @ingroup Settings System
@@ -53292,6 +54313,24 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_Sequence(): Array<Systems.Sequence> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_systems_Sequence",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<Systems.Sequence>(
+        getNativePointer(_ret),
+        csp_systems_SequenceFactory,
+        "csp_systems_Sequence",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_Site(): Array<Systems.Site> {
       var _ret = Module._malloc(8);
       Module.ccall(
@@ -54048,6 +55087,26 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_systems_Sequence_number(
+      size: number,
+    ): Array<Systems.Sequence> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_systems_Sequence",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<Systems.Sequence>(
+        getNativePointer(_ret),
+        csp_systems_SequenceFactory,
+        "csp_systems_Sequence",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_systems_Site_number(size: number): Array<Systems.Site> {
       var _ret = Module._malloc(8);
       Module.ccall(