connected-spaces-platform.web 5.0.1 → 5.1.0

package/connectedspacesplatform.ts

@@ -1023,6 +1023,14 @@ function csp_multiplayer_SequenceChangedParamsFactory(
 ProxyClassFactories["csp_multiplayer_SequenceChangedParams"] =
   csp_multiplayer_SequenceChangedParamsFactory;
 
+function csp_multiplayer_SequenceHierarchyChangedParamsFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.SequenceHierarchyChangedParams(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_SequenceHierarchyChangedParams"] =
+  csp_multiplayer_SequenceHierarchyChangedParamsFactory;
+
 function csp_multiplayer_MultiplayerConnectionFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1039,6 +1047,14 @@ function csp_multiplayer_ReplicatedValueFactory(
 ProxyClassFactories["csp_multiplayer_ReplicatedValue"] =
   csp_multiplayer_ReplicatedValueFactory;
 
+function csp_multiplayer_SequenceHierarchyFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.SequenceHierarchy(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_SequenceHierarchy"] =
+  csp_multiplayer_SequenceHierarchyFactory;
+
 function csp_multiplayer_ComponentUpdateInfoFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1517,6 +1533,22 @@ function csp_systems_VoipSystemFactory(
 }
 ProxyClassFactories["csp_systems_VoipSystem"] = csp_systems_VoipSystemFactory;
 
+function csp_multiplayer_SequenceHierarchyResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.SequenceHierarchyResult(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_SequenceHierarchyResult"] =
+  csp_multiplayer_SequenceHierarchyResultFactory;
+
+function csp_multiplayer_SequenceHierarchyCollectionResultFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.SequenceHierarchyCollectionResult(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_SequenceHierarchyCollectionResult"] =
+  csp_multiplayer_SequenceHierarchyCollectionResultFactory;
+
 function csp_multiplayer_AnimatedModelSpaceComponentFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2381,6 +2413,26 @@ function csp_common_Array_csp_systems_SpaceUserRoleFactory(
 ProxyClassFactories["csp_common_Array_csp_systems_SpaceUserRole"] =
   csp_common_Array_csp_systems_SpaceUserRoleFactory;
 
+function csp_common_Array_uint64_tFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<bigint>(nativePointer, NumberFactory, "uint64_t");
+}
+ProxyClassFactories["csp_common_Array_uint64_t"] =
+  csp_common_Array_uint64_tFactory;
+
+function csp_common_Array_csp_multiplayer_SequenceHierarchyFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<Multiplayer.SequenceHierarchy>(
+    nativePointer,
+    csp_multiplayer_SequenceHierarchyFactory,
+    "csp_multiplayer_SequenceHierarchy",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_multiplayer_SequenceHierarchy"] =
+  csp_common_Array_csp_multiplayer_SequenceHierarchyFactory;
+
 function csp_common_Array_csp_multiplayer_MessageInfoFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2835,6 +2887,18 @@ function csp_common_Array_csp_common_Map_String_StringFactory(
 ProxyClassFactories["csp_common_Array_csp_common_Map_String_String"] =
   csp_common_Array_csp_common_Map_String_StringFactory;
 
+function csp_common_List_csp_multiplayer_SpaceEntityFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.List<Multiplayer.SpaceEntity>(
+    nativePointer,
+    csp_multiplayer_SpaceEntityFactory,
+    "csp_multiplayer_SpaceEntity",
+  );
+}
+ProxyClassFactories["csp_common_List_csp_multiplayer_SpaceEntity"] =
+  csp_common_List_csp_multiplayer_SpaceEntityFactory;
+
 function csp_common_List_StringFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -3004,6 +3068,7 @@ export namespace Multiplayer {
   export enum ESequenceUpdateType {
     Create,
     Update,
+    Rename,
     Delete,
   }
 }
@@ -3092,6 +3157,7 @@ export namespace Multiplayer {
     UPDATE_FLAGS_SELECTION_ID = 32,
     UPDATE_FLAGS_THIRD_PARTY_REF = 64,
     UPDATE_FLAGS_THIRD_PARTY_PLATFORM = 128,
+    UPDATE_FLAGS_PARENT = 256,
   }
 }
 
@@ -3792,6 +3858,7 @@ export namespace Systems {
     ShopifyInvalidStoreName,
     UserShopifyLimitReached,
     UserTokenRefreshFailed,
+    InvalidSequenceKey,
   }
 }
 
@@ -4252,6 +4319,12 @@ export namespace Multiplayer {
      */
     nextValueIsNull: () => boolean;
 
+    /**
+     * @description Checks if the next value is an array.
+     * @return True if the next value is null, false otherwise.
+     */
+    nextValueIsArray: () => boolean;
+
     /**
      * @description Puts the deserialiser into array processing mode to begin reading from an array.
      * @param outLength - A reference to variable to store the length of the array.
@@ -20956,6 +21029,36 @@ export namespace Common {
       return new Vector3(_nPtr);
     }
 
+    /**
+     * @description Member by member addition with another Vector3
+     * @param vector3 - Other
+     */
+    // operator+
+
+    /**
+     * @description Subtracts another Vector3 from this one
+     * @param vector3 - Other
+     */
+    // operator-
+
+    /**
+     * @description Divides the Vector3 by divisor
+     * @param float - Divisor
+     */
+    // operator/
+
+    /**
+     * @description Member by member multiplication with another Vector3
+     * @param vector3 - Other
+     */
+    // operator*
+
+    /**
+     * @description Multiplies the Vector3 by a scalar
+     * @param float - Scalar
+     */
+    // operator*
+
     delete(): void {
       if (this.ownsPointer && !this.disposed) {
         Module.ccall(
@@ -21132,6 +21235,36 @@ export namespace Common {
       return new Vector4(_nPtr);
     }
 
+    /**
+     * @description Member by member addition with another Vector4
+     * @param vector4 - Other
+     */
+    // operator+
+
+    /**
+     * @description Subtracts another Vector4 from this one
+     * @param vector4 - Other
+     */
+    // operator-
+
+    /**
+     * @description Divides the Vector4 by divisor
+     * @param float - Divisor
+     */
+    // operator/
+
+    /**
+     * @description Member by member multiplication with another Vector4
+     * @param vector4 - Other
+     */
+    // operator*
+
+    /**
+     * @description Multiplies the Vector4 by a scalar
+     * @param float - Scalar
+     */
+    // operator*
+
     delete(): void {
       if (this.ownsPointer && !this.disposed) {
         Module.ccall(
@@ -21887,6 +22020,110 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  export class SequenceHierarchyChangedParams
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): SequenceHierarchyChangedParams {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchyChangedParams_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new SequenceHierarchyChangedParams(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_SequenceHierarchyChangedParams_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get updateType(): Multiplayer.ESequenceUpdateType {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHierarchyChangedParams__Get_UpdateType",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set updateType(value: Multiplayer.ESequenceUpdateType) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchyChangedParams__Set_UpdateType",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get parentId(): bigint {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHierarchyChangedParams__Get_ParentId",
+        "bigint",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _unfixedValue = _result;
+      let _fixedValue =
+        _unfixedValue < 0 ? _unfixedValue + 2n ** 64n : _unfixedValue;
+
+      _result = _fixedValue;
+
+      return _result;
+    }
+
+    set parentId(value: bigint) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchyChangedParams__Set_ParentId",
+        "void",
+        ["number", "bigint"],
+        [this.pointer, value],
+      );
+    }
+
+    get isRoot(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHierarchyChangedParams__Get_IsRoot",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set isRoot(value: boolean) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchyChangedParams__Set_IsRoot",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
 @ingroup Multiplayer
@@ -22716,6 +22953,108 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  /**
+@ingroup Space Entity System
+ * @description Class which exposes data that is relevent to entity hierarchies, which comes from the underlying Sequence System.  
+ * This allows users to manage the ordering of child entites within their parent.  
+ */
+  export class SequenceHierarchy
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    hasParent(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHierarchy_HasParentC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    static create(): SequenceHierarchy {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchy_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new SequenceHierarchy(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_SequenceHierarchy_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get ids(): Common.Array<bigint> {
+      const _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchy__Get_Ids",
+        "void",
+        ["number", "number"],
+        [_ptr, this.pointer],
+      );
+
+      const _nPtr = getNativePointer(_ptr);
+      return new Common.Array<bigint>(_nPtr, NumberFactory, "uint64_t");
+    }
+
+    set ids(value: Common.Array<bigint>) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchy__Set_Ids",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+
+    get parentId(): bigint {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHierarchy__Get_ParentId",
+        "bigint",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _unfixedValue = _result;
+      let _fixedValue =
+        _unfixedValue < 0 ? _unfixedValue + 2n ** 64n : _unfixedValue;
+
+      _result = _fixedValue;
+
+      return _result;
+    }
+
+    set parentId(value: bigint) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchy__Set_ParentId",
+        "void",
+        ["number", "bigint"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Info class that specifies a type of update and the ID of a component the update is applied to.
@@ -22964,6 +23303,25 @@ export namespace Multiplayer {
       return _nPtr;
     }
 
+    /**
+     * @description Get the Global SpaceTransform of the SpaceEntity, derived from it's parent.
+     * @return SpaceTransform.
+     */
+
+    getGlobalTransform(): Multiplayer.SpaceTransform {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_GetGlobalTransformC_SpaceTransform",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Multiplayer.SpaceTransform(getNativePointer(_ret));
+      Module._free(_ret);
+      return _nPtr;
+    }
+
     /**
      * @description Get the position of the SpaceEntity, in world space.
      * @return Position.
@@ -22984,6 +23342,25 @@ export namespace Multiplayer {
       return _nPtr;
     }
 
+    /**
+     * @description Get the Global position of the SpaceEntity, in world space, derived from it's parent.
+     * @return Position.
+     */
+
+    getGlobalPosition(): Common.Vector3 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_GetGlobalPositionC_Vector3",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Vector3(getNativePointer(_ret));
+      Module._free(_ret);
+      return _nPtr;
+    }
+
     /**
      * @description Set the position of the SpaceEntity, in world space.
      * @param value - The position to set.
@@ -23018,6 +23395,25 @@ export namespace Multiplayer {
       return _nPtr;
     }
 
+    /**
+     * @description Get the Global rotation of the SpaceEntity, derived from it's parent.
+     * @return Rotation.
+     */
+
+    getGlobalRotation(): Common.Vector4 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_GetGlobalRotationC_Vector4",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Vector4(getNativePointer(_ret));
+      Module._free(_ret);
+      return _nPtr;
+    }
+
     /**
      * @description Set the rotation of the SpaceEntity.
      * @param value - The rotation to set.
@@ -23052,6 +23448,25 @@ export namespace Multiplayer {
       return _nPtr;
     }
 
+    /**
+     * @description Get the Global scale of the SpaceEntity, derived from it's parent.
+     * @return Scale.
+     */
+
+    getGlobalScale(): Common.Vector3 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_GetGlobalScaleC_Vector3",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Vector3(getNativePointer(_ret));
+      Module._free(_ret);
+      return _nPtr;
+    }
+
     /**
      * @description Set the scale of the SpaceEntity.
      * @param value - The scale to set.
@@ -23185,6 +23600,122 @@ export namespace Multiplayer {
       return _nPtr;
     }
 
+    /**
+     * @description Sets the parent for this entity
+     * QueueUpdate() should be called afterwards to enable changes to the parent.
+     * @param parentId - Uint64_t the new parent id of this entity.
+     */
+
+    setParentId(parentId: bigint): void {
+      assert(parentId >= Limits.UINT64_MIN);
+      assert(parentId <= Limits.UINT64_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_SetParentId_void_uint64_t",
+        "void",
+        ["number", "bigint"],
+        [this.pointer, parentId],
+      );
+    }
+
+    /**
+     * @description Removes the parent entity
+     * QueueUpdate() should be called afterwards to enable changes to the parent.
+     */
+
+    removeParentEntity(): void {
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_RemoveParentEntity_void",
+        "void",
+        ["number"],
+        [this.pointer],
+      );
+    }
+
+    /**
+     * @description Gets the parent of this entity
+     * @return SpaceEntity
+     */
+
+    getParentEntity(): Multiplayer.SpaceEntity {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_GetParentEntityC_SpaceEntityP",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Create a new entity with this entity as it's parent
+     * @param inName - The name to give the new SpaceEntity.
+     * @param inSpaceTransform - The initial transform to set the SpaceEntity to.
+     * @param callback - A callback that executes when the creation is complete,
+     * which contains a pointer to the new SpaceEntity so that it can be used on the local client.
+     */
+
+    async createChildEntity(
+      name: string,
+      spaceTransform: Multiplayer.SpaceTransform,
+    ): Promise<Multiplayer.SpaceEntity> {
+      var _resolve;
+
+      var _promise = new Promise<Multiplayer.SpaceEntity>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1Ptr = getNativePointer(arg1);
+        var _arg1Instance = new Multiplayer.SpaceEntity(_arg1Ptr);
+
+        _resolve(_arg1Instance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_CreateChildEntity_void_StringRC_SpaceTransformRC_EntityCreatedCallback",
+        "void",
+        ["number", "string", "number", "number", "number"],
+        [this.pointer, name, spaceTransform.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Gets the children of this entity
+     * @return Csp::common::list&lt;spaceentity&gt;
+     */
+
+    getChildEntities(): Common.List<Multiplayer.SpaceEntity> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntity_GetChildEntitiesC_ListPC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.List<Multiplayer.SpaceEntity>(
+        getNativePointer(_ret),
+        csp_multiplayer_SpaceEntityFactory,
+        "csp_multiplayer_SpaceEntity",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
     /**
      * @description Queues an update which will be executed on next Tick() or ProcessPendingEntityOperations(). Not a blocking or async function.
      */
@@ -24341,6 +24872,324 @@ export namespace Multiplayer {
         [this.pointer, enabled],
       );
     }
+
+    /**
+     * @description Retrieves all entites that exist at the root level (do not have a parent entity).
+     * @return A list of root entities.
+     */
+
+    getRootHierarchyEntities(): Common.List<Multiplayer.SpaceEntity> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntitySystem_GetRootHierarchyEntitiesC_ListPC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.List<Multiplayer.SpaceEntity>(
+        getNativePointer(_ret),
+        csp_multiplayer_SpaceEntityFactory,
+        "csp_multiplayer_SpaceEntity",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Creates an entity hierarchy for a given parent entity id. Pass null to create a hiererchy for the root.
+     * @param parentId - An optional parent. Pass null to create a hiererchy for the root.
+     * @param hierarchyItemIds - An array of entity ids.
+     * @param callback - A callback when the asynchronous task finishes.
+     */
+
+    async createSequenceHierarchy(
+      parentId: bigint | null,
+      hierarchyItemIds: Common.Array<bigint>,
+    ): Promise<Multiplayer.SequenceHierarchyResult> {
+      var _resolve;
+
+      var _promise = new Promise<Multiplayer.SequenceHierarchyResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Multiplayer.SequenceHierarchyResult(
+          _resultPtr,
+        );
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      var parentIdPointer = 0;
+      if (parentId != null) {
+        parentIdPointer = Module._malloc(4);
+        Module.setValue(parentIdPointer, parentId, "i32");
+      }
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntitySystem_CreateSequenceHierarchy_void_uint64_tRC_ArrayRC_SequenceHierarchyResultCallback",
+        "void",
+        ["number", "bigint", "number", "number", "number"],
+        [
+          this.pointer,
+          parentIdPointer,
+          hierarchyItemIds.pointer,
+          _callbackPtr,
+          0,
+        ],
+      );
+
+      if (parentIdPointer) {
+        Module._free(parentIdPointer);
+      }
+
+      return _promise;
+    }
+
+    /**
+     * @description Updates an entity hierarchy for a given parent entity id. Pass null to update the root.
+     * This will create a hierarchy if it doesnt exist.
+     * @param parentId - An optional parent. Pass null to create a hiererchy for the root.
+     * @param hierarchyItemIds - An array of entity ids.
+     * @param callback - A callback when the asynchronous task finishes.
+     */
+
+    async updateSequenceHierarchy(
+      parentId: bigint | null,
+      hierarchyItemIds: Common.Array<bigint>,
+    ): Promise<Multiplayer.SequenceHierarchyResult> {
+      var _resolve;
+
+      var _promise = new Promise<Multiplayer.SequenceHierarchyResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Multiplayer.SequenceHierarchyResult(
+          _resultPtr,
+        );
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      var parentIdPointer = 0;
+      if (parentId != null) {
+        parentIdPointer = Module._malloc(4);
+        Module.setValue(parentIdPointer, parentId, "i32");
+      }
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntitySystem_UpdateSequenceHierarchy_void_uint64_tRC_ArrayRC_SequenceHierarchyResultCallback",
+        "void",
+        ["number", "bigint", "number", "number", "number"],
+        [
+          this.pointer,
+          parentIdPointer,
+          hierarchyItemIds.pointer,
+          _callbackPtr,
+          0,
+        ],
+      );
+
+      if (parentIdPointer) {
+        Module._free(parentIdPointer);
+      }
+
+      return _promise;
+    }
+
+    /**
+     * @description Gets an entity hierarchy for a given parent entity id. Pass null to get the root hierarchy.
+     * @param parentId - An optional parent. Pass null to get the root hierarchy.
+     * @param callback - A callback when the asynchronous task finishes.
+     */
+
+    async getSequenceHierarchy(
+      parentId: bigint | null,
+    ): Promise<Multiplayer.SequenceHierarchyResult> {
+      var _resolve;
+
+      var _promise = new Promise<Multiplayer.SequenceHierarchyResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Multiplayer.SequenceHierarchyResult(
+          _resultPtr,
+        );
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      var parentIdPointer = 0;
+      if (parentId != null) {
+        parentIdPointer = Module._malloc(4);
+        Module.setValue(parentIdPointer, parentId, "i32");
+      }
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntitySystem_GetSequenceHierarchy_void_uint64_tRC_SequenceHierarchyResultCallback",
+        "void",
+        ["number", "bigint", "number", "number"],
+        [this.pointer, parentIdPointer, _callbackPtr, 0],
+      );
+
+      if (parentIdPointer) {
+        Module._free(parentIdPointer);
+      }
+
+      return _promise;
+    }
+
+    /**
+     * @description Gets all hierarchies for a space
+     * @param callback - A callback when the asynchronous task finishes.
+     */
+
+    async getAllSequenceHierarchies(): Promise<Multiplayer.SequenceHierarchyCollectionResult> {
+      var _resolve;
+
+      var _promise = new Promise<Multiplayer.SequenceHierarchyCollectionResult>(
+        (_r) => {
+          _resolve = _r;
+        },
+      );
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Multiplayer.SequenceHierarchyCollectionResult(
+          _resultPtr,
+        );
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntitySystem_GetAllSequenceHierarchies_void_SequenceHierarchyCollectionResultCallback",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Deletes an entity hierarchy for a given parent entity id. Pass null to delete the root hierarchy.
+     * @param parentId - An optional parent. Pass null to get the root hierarchy.
+     * @param callback - A callback when the asynchronous task finishes.
+     */
+
+    async deleteSequenceHierarchy(
+      parentId: bigint | null,
+    ): Promise<Systems.NullResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.NullResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.NullResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      var parentIdPointer = 0;
+      if (parentId != null) {
+        parentIdPointer = Module._malloc(4);
+        Module.setValue(parentIdPointer, parentId, "i32");
+      }
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntitySystem_DeleteSequenceHierarchy_void_uint64_tRC_NullResultCallback",
+        "void",
+        ["number", "bigint", "number", "number"],
+        [this.pointer, parentIdPointer, _callbackPtr, 0],
+      );
+
+      if (parentIdPointer) {
+        Module._free(parentIdPointer);
+      }
+
+      return _promise;
+    }
+
+    /**
+     * @description Sets a callback for a sequence  hierarchy changed event.
+     * @param callback - Callback to receive data for the sequence hierarchy that has been changed.
+     */
+    setSequenceHierarchyChangedCallback(
+      callback: (arg1: Multiplayer.SequenceHierarchyChangedParams) => void,
+    ) {
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1 = new Multiplayer.SequenceHierarchyChangedParams(
+          getNativePointer(arg1),
+        );
+
+        callback(_arg1);
+      };
+
+      var _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_multiplayer_SpaceEntitySystem_SetSequenceHierarchyChangedCallback_void_SequenceHierarchyChangedCallbackHandler",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+    }
   }
 }
 
@@ -24396,6 +25245,19 @@ export namespace Multiplayer {
       return new SpaceTransform(_nPtr);
     }
 
+    /**
+     * @description Equality operator
+     * @param spaceTransform - Transform
+     */
+    // operator==
+
+    /**
+     * @description Multiplication operator
+     * @param spaceTransform - Transform
+     * NOTE: This mimics the operations of a matrix transform multiplication, but converts the back into a recognisable form.
+     */
+    // operator*
+
     delete(): void {
       if (this.ownsPointer && !this.disposed) {
         Module.ccall(
@@ -33188,6 +34050,130 @@ export namespace Systems {
   }
 }
 
+export namespace Multiplayer {
+  /**
+@ingroup Space Entity System
+ * @description Data class used to contain information when attempting to get a sequence hierarchy  
+ */
+  export class SequenceHierarchyResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Multiplayer.SequenceHierarchyResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Multiplayer.SequenceHierarchyResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Retreives the SequenceHierarchy from the result.
+     */
+
+    getSequenceHierarchy(): Multiplayer.SequenceHierarchy {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchyResult_GetSequenceHierarchyC_SequenceHierarchyRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Multiplayer.SequenceHierarchy(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_SequenceHierarchyResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
+export namespace Multiplayer {
+  /**
+@ingroup Space Entity System
+ * @description Data class used to contain information when attempting to get an array of sequence hierachies  
+ */
+  export class SequenceHierarchyCollectionResult
+    extends Systems.ResultBase
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromResultBase(
+      baseInstance: Systems.ResultBase,
+    ): Multiplayer.SequenceHierarchyCollectionResult {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Multiplayer.SequenceHierarchyCollectionResult(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Retreives the SequenceHierarchies from the result.
+     */
+
+    getSequenceHierarchyCollection(): Common.Array<Multiplayer.SequenceHierarchy> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_SequenceHierarchyCollectionResult_GetSequenceHierarchyCollectionC_ArrayRC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Array<Multiplayer.SequenceHierarchy>(
+        getNativePointer(_ret),
+        csp_multiplayer_SequenceHierarchyFactory,
+        "csp_multiplayer_SequenceHierarchy",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_SequenceHierarchyCollectionResult_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
 @ingroup AnimatedModelSpaceComponent
@@ -46500,7 +47486,7 @@ export namespace Systems {
      */
 
     async createHotspotGroup(
-      arg1: string,
+      groupName: string,
       hotspotIds: Common.Array<string>,
     ): Promise<Systems.HotspotGroupResult> {
       var _resolve;
@@ -46529,7 +47515,7 @@ export namespace Systems {
         "csp_systems_HotspotSequenceSystem_CreateHotspotGroup_void_StringRC_ArrayRC_HotspotGroupResultCallback",
         "void",
         ["number", "string", "number", "number", "number"],
-        [this.pointer, arg1, hotspotIds.pointer, _callbackPtr, 0],
+        [this.pointer, groupName, hotspotIds.pointer, _callbackPtr, 0],
       );
 
       return _promise;
@@ -48338,6 +49324,7 @@ export namespace Systems {
 
     /**
      * @description Creates a new sequence. If a sequence already exists with this key, it will overwrite the current one.
+     * NOTE: This call will fail (Reason InvalidSequenceKey) if the SequenceKey parameter contains invalid keys, such as spaces, '/' or '%'
      * This call will fail if the user isn't a creator of the space.
      * @param sequenceKey - The unique grouping name. Our naming convention is: Type:[SpaceId]:[GroupName]
      * @param referenceType - The type of reference (GroupId etc.)
@@ -48406,6 +49393,7 @@ export namespace Systems {
 
     /**
      * @description Updates an existing sequence. This call will fail if the user isn't a creator of the space.
+     * NOTE: This call will fail if the SequenceKey parameter contains invalid keys, such as spaces, '/' or '%'
      * @param sequenceKey - The unique grouping name. Our naming convention is: Type:[SpaceId]:[GroupName]
      * @param referenceType - The type of reference (GroupId etc.)
      * @param referenceId - The id of the reference
@@ -48473,6 +49461,8 @@ export namespace Systems {
 
     /**
      * @description Renames a given sequence. This call will fail if the user isn't a creator of the space.
+     * NOTE: This call will fail (Reason InvalidSequenceKey) if the OldSequenceKey, or NewSequenceKey parameters contains invalid keys, such as
+     * spaces, '/' or '%'
      * @param oldSequenceKey - The current sequence key name
      * @param newSequenceKey - The new sequence key name
      * @param callback - Callback to call when a response is received
@@ -48516,6 +49506,7 @@ export namespace Systems {
 
     /**
      * @description Finds sequences based on the given criteria
+     * NOTE: This call will fail (Reason InvalidSequenceKey) if the SequenceKey parameter contains invalid keys, such as spaces, '/' or '%'
      * @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 etc.). Must be used with ReferenceIds
@@ -48583,6 +49574,7 @@ export namespace Systems {
 
     /**
      * @description Gets a sequence by it's key
+     * NOTE: This call will fail (Reason InvalidSequenceKey) if the SequenceKey parameter contains invalid keys, such as spaces, '/' or '%'
      * @param sequenceKey - The unique grouping name
      * @param callback - Callback to call when a response is received
      */
@@ -48622,6 +49614,7 @@ export namespace Systems {
 
     /**
      * @description Deletes the given sequences. This call will fail if the user isn't a creator of the space
+     * NOTE: This call will fail (Reason InvalidSequenceKey) if the SequenceKey parameter contains invalid keys, such as spaces, '/' or '%'
      * @param sequenceKeys - An array of sequence keys to delete
      * @param callback - Callback to call when a response is received
      */
@@ -51946,6 +52939,74 @@ export namespace Systems {
 
       return _promise;
     }
+
+    /**
+     * @description Duplicate an existing space and assign it to the current user
+     * @param spaceId - Id of the space to duplicate.
+     * @param newName - A unique name for the duplicated space.
+     * @param newAttributes - Attributes to apply to the duplicated space.
+     * @param memberGroupIds - An optional array of group (space) IDs to copy users from.
+     * @param shallowCopy - If true, the duplicated space will reference the assets of the original space. Otherwise, all assets will be
+     * duplicated.
+     * @param callback - Callback when asynchronous task finishes
+     */
+
+    async duplicateSpace(
+      spaceId: string,
+      newName: string,
+      newAttributes: Systems.SpaceAttributes,
+      memberGroupIds: Common.Array<string> | null,
+      shallowCopy: boolean,
+    ): Promise<Systems.SpaceResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.SpaceResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.SpaceResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SpaceSystem_DuplicateSpace_void_StringRC_StringRC_SpaceAttributes_ArrayRC_bool_SpaceResultCallback",
+        "void",
+        [
+          "number",
+          "string",
+          "string",
+          "number",
+          "number",
+          "boolean",
+          "number",
+          "number",
+        ],
+        [
+          this.pointer,
+          spaceId,
+          newName,
+          newAttributes,
+          memberGroupIds != null ? memberGroupIds.pointer : 0,
+          shallowCopy,
+          _callbackPtr,
+          0,
+        ],
+      );
+
+      return _promise;
+    }
   }
 }
 
@@ -54795,6 +55856,42 @@ export namespace Common {
       return _inst;
     }
 
+    static ofuint64_t(): Array<bigint> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_uint64_t",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<bigint>(
+        getNativePointer(_ret),
+        NumberFactory,
+        "uint64_t",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
+    static ofcsp_multiplayer_SequenceHierarchy(): Array<Multiplayer.SequenceHierarchy> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_multiplayer_SequenceHierarchy",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<Multiplayer.SequenceHierarchy>(
+        getNativePointer(_ret),
+        csp_multiplayer_SequenceHierarchyFactory,
+        "csp_multiplayer_SequenceHierarchy",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_multiplayer_MessageInfo(): Array<Multiplayer.MessageInfo> {
       var _ret = Module._malloc(8);
       Module.ccall(
@@ -55542,6 +56639,44 @@ export namespace Common {
       return _inst;
     }
 
+    static ofuint64_t_number(size: number): Array<bigint> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_uint64_t",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<bigint>(
+        getNativePointer(_ret),
+        NumberFactory,
+        "uint64_t",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
+    static ofcsp_multiplayer_SequenceHierarchy_number(
+      size: number,
+    ): Array<Multiplayer.SequenceHierarchy> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_multiplayer_SequenceHierarchy",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<Multiplayer.SequenceHierarchy>(
+        getNativePointer(_ret),
+        csp_multiplayer_SequenceHierarchyFactory,
+        "csp_multiplayer_SequenceHierarchy",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_multiplayer_MessageInfo_number(
       size: number,
     ): Array<Multiplayer.MessageInfo> {
@@ -56389,6 +57524,24 @@ export namespace Common {
     private TTypeFactory: ProxyClassFactory;
     private TTypeName: string;
 
+    static ofcsp_multiplayer_SpaceEntity(): List<Multiplayer.SpaceEntity> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_List_Ctor_csp_multiplayer_SpaceEntity",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new List<Multiplayer.SpaceEntity>(
+        getNativePointer(_ret),
+        csp_multiplayer_SpaceEntityFactory,
+        "csp_multiplayer_SpaceEntity",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofString(): List<string> {
       var _ret = Module._malloc(8);
       Module.ccall("csp_common_List_Ctor_String", "void", ["number"], [_ret]);
@@ -56420,6 +57573,26 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_multiplayer_SpaceEntity_number(
+      minimumSize: number,
+    ): List<Multiplayer.SpaceEntity> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_List_Ctor_size_t_csp_multiplayer_SpaceEntity",
+        "void",
+        ["number", "number"],
+        [_ret, minimumSize],
+      );
+      var _inst = new List<Multiplayer.SpaceEntity>(
+        getNativePointer(_ret),
+        csp_multiplayer_SpaceEntityFactory,
+        "csp_multiplayer_SpaceEntity",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofString_number(minimumSize: number): List<string> {
       var _ret = Module._malloc(8);
       Module.ccall(
@@ -56458,6 +57631,26 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_multiplayer_SpaceEntity_List(
+      other: Common.List<Multiplayer.SpaceEntity>,
+    ): List<Multiplayer.SpaceEntity> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_List_Ctor_ListRC_csp_multiplayer_SpaceEntity",
+        "void",
+        ["number", "number"],
+        [_ret, other.pointer],
+      );
+      var _inst = new List<Multiplayer.SpaceEntity>(
+        getNativePointer(_ret),
+        csp_multiplayer_SpaceEntityFactory,
+        "csp_multiplayer_SpaceEntity",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofString_List(other: Common.List<string>): List<string> {
       var _ret = Module._malloc(8);
       Module.ccall(