connected-spaces-platform.web 5.1.0 → 5.3.1

package/connectedspacesplatform.ts

@@ -510,6 +510,14 @@ function csp_multiplayer_ButtonPropertyKeysFactory(
 ProxyClassFactories["csp_multiplayer_ButtonPropertyKeys"] =
   csp_multiplayer_ButtonPropertyKeysFactory;
 
+function csp_multiplayer_CinematicCameraPropertyKeysFactory(
+  nativePointer: NativePointer,
+): Multiplayer.CinematicCameraPropertyKeys {
+  return nativePointer.pointer as Multiplayer.CinematicCameraPropertyKeys;
+}
+ProxyClassFactories["csp_multiplayer_CinematicCameraPropertyKeys"] =
+  csp_multiplayer_CinematicCameraPropertyKeysFactory;
+
 function csp_multiplayer_CollisionPropertyKeysFactory(
   nativePointer: NativePointer,
 ): Multiplayer.CollisionPropertyKeys {
@@ -969,6 +977,13 @@ function csp_common_VariantFactory(
 }
 ProxyClassFactories["csp_common_Variant"] = csp_common_VariantFactory;
 
+function csp_common_Vector2Factory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Vector2(nativePointer);
+}
+ProxyClassFactories["csp_common_Vector2"] = csp_common_Vector2Factory;
+
 function csp_common_Vector3Factory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1031,6 +1046,14 @@ function csp_multiplayer_SequenceHierarchyChangedParamsFactory(
 ProxyClassFactories["csp_multiplayer_SequenceHierarchyChangedParams"] =
   csp_multiplayer_SequenceHierarchyChangedParamsFactory;
 
+function csp_multiplayer_SequenceHotspotChangedParamsFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.SequenceHotspotChangedParams(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_SequenceHotspotChangedParams"] =
+  csp_multiplayer_SequenceHotspotChangedParamsFactory;
+
 function csp_multiplayer_MultiplayerConnectionFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1581,6 +1604,14 @@ function csp_multiplayer_ButtonSpaceComponentFactory(
 ProxyClassFactories["csp_multiplayer_ButtonSpaceComponent"] =
   csp_multiplayer_ButtonSpaceComponentFactory;
 
+function csp_multiplayer_CinematicCameraSpaceComponentFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Multiplayer.CinematicCameraSpaceComponent(nativePointer);
+}
+ProxyClassFactories["csp_multiplayer_CinematicCameraSpaceComponent"] =
+  csp_multiplayer_CinematicCameraSpaceComponentFactory;
+
 function csp_multiplayer_CollisionSpaceComponentFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -3035,6 +3066,7 @@ export namespace Multiplayer {
     GaussianSplat,
     Text,
     Hotspot,
+    CinematicCamera,
   }
 }
 
@@ -3070,6 +3102,7 @@ export namespace Multiplayer {
     Update,
     Rename,
     Delete,
+    Invalid,
   }
 }
 
@@ -3108,6 +3141,7 @@ export namespace Multiplayer {
     Integer,
     Float,
     String,
+    Vector2,
     Vector3,
     Vector4,
   }
@@ -3330,6 +3364,28 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  /**
+   * @description Enumerates the list of properties that can be replicated for a CinematicCamera component.
+   */
+  export enum CinematicCameraPropertyKeys {
+    Position = 0,
+    Rotation,
+    IsEnabled,
+    FocalLength,
+    AspectRatio,
+    SensorSize,
+    NearClip,
+    FarClip,
+    Iso,
+    ShutterSpeed,
+    Aperture,
+    IsViewerCamera,
+    ThirdPartyComponentRef,
+    Num,
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Enumerates the list of properties that can be replicated for a collision component.
@@ -4181,6 +4237,12 @@ export namespace Multiplayer {
      */
     writeString: (value: string) => void;
 
+    /**
+     * @description Write a vector2 field of the entity.
+     * @param value - The value to write.
+     */
+    writeVector2: (value: Common.Vector2) => void;
+
     /**
      * @description Write a vector3 field of the entity.
      * @param value - The value to write.
@@ -4301,6 +4363,12 @@ export namespace Multiplayer {
      */
     readString: () => string;
 
+    /**
+     * @description Reads a vector2 from the deserialiser.
+     * @return The deserialised vector2.
+     */
+    readVector2: () => Common.Vector2;
+
     /**
      * @description Reads a vector3 from the deserialiser.
      * @return The deserialised vector3.
@@ -20949,6 +21017,170 @@ export namespace Common {
   }
 }
 
+export namespace Common {
+  /**
+   * @description Represents a 2 dimensional vector.
+   */
+  export class Vector2 extends NativeClassWrapper implements INativeResource {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    /**
+     * @description Returns a Vector2 with all fields set to 0.
+     * @return Const vector2&
+     */
+
+    static zero(): Common.Vector2 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_Vector2_Zero_Vector2RC",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _nPtr = new Common.Vector2(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Returns a Vector2 with all fields set to 1.
+     * @return Const vector2&
+     */
+
+    static one(): Common.Vector2 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_Vector2_One_Vector2RC",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _nPtr = new Common.Vector2(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Constructs a Vector2 with all fields set to 0.
+     */
+    static create(): Vector2 {
+      var _ptr = Module._malloc(8);
+      Module.ccall("csp_common_Vector2_Ctor", "void", ["number"], [_ptr]);
+      var _nPtr = getNativePointer(_ptr);
+
+      return new Vector2(_nPtr);
+    }
+
+    /**
+     * @description Constructs a Vector2 with the given x, y values.
+     * @param x - Float
+     * @param y - Float
+     */
+    static create_x_y(x: number, y: number): Vector2 {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Vector2_Ctor_float_float",
+        "void",
+        ["number", "number", "number"],
+        [_ptr, x, y],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new Vector2(_nPtr);
+    }
+
+    /**
+     * @description Member by member addition with another Vector2
+     * @param vector2 - Other
+     */
+    // operator+
+
+    /**
+     * @description Subtracts another Vector2 from this one
+     * @param vector2 - Other
+     */
+    // operator-
+
+    /**
+     * @description Divides the Vector2 by divisor
+     * @param float - Divisor
+     */
+    // operator/
+
+    /**
+     * @description Member by member multiplication with another Vector2
+     * @param vector2 - Other
+     */
+    // operator*
+
+    /**
+     * @description Multiplies the Vector2 by a scalar
+     * @param float - Scalar
+     */
+    // operator*
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_common_Vector2_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get x(): number {
+      let _result = Module.ccall(
+        "csp_common_Vector2__Get_X",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set x(value: number) {
+      Module.ccall(
+        "csp_common_Vector2__Set_X",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get y(): number {
+      let _result = Module.ccall(
+        "csp_common_Vector2__Get_Y",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set y(value: number) {
+      Module.ccall(
+        "csp_common_Vector2__Set_Y",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Common {
   /**
    * @description Represents a 3 dimensional vector.
@@ -22124,6 +22356,124 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  export class SequenceHotspotChangedParams
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static create(): SequenceHotspotChangedParams {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new SequenceHotspotChangedParams(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_SequenceHotspotChangedParams_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get updateType(): Multiplayer.ESequenceUpdateType {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Get_UpdateType",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set updateType(value: Multiplayer.ESequenceUpdateType) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Set_UpdateType",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    get spaceId(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Get_SpaceId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set spaceId(value: string) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Set_SpaceId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get name(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Get_Name",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set name(value: string) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Set_Name",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get newName(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Get_NewName",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set newName(value: string) {
+      Module.ccall(
+        "csp_multiplayer_SequenceHotspotChangedParams__Set_NewName",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
 @ingroup Multiplayer
@@ -22396,6 +22746,31 @@ export namespace Multiplayer {
       );
     }
 
+    /**
+     * @description Sets a callback to be fired when a hotspot sequence is changed.
+     * @param callback - Callback to receive data for the hotspot sequence that has been changed.
+     */
+    setHotspotSequenceChangedCallback(
+      callback: (arg1: Multiplayer.SequenceHotspotChangedParams) => void,
+    ) {
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1 = new Multiplayer.SequenceHotspotChangedParams(
+          getNativePointer(arg1),
+        );
+
+        callback(_arg1);
+      };
+
+      var _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_multiplayer_MultiplayerConnection_SetHotspotSequenceChangedCallback_void_HotspotSequenceChangedCallbackHandler",
+        "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.
@@ -22652,6 +23027,23 @@ export namespace Multiplayer {
       return new ReplicatedValue(_nPtr);
     }
 
+    /**
+     * @description Construct a ReplicatedValue based on a csp::common::Vector2 type.
+     * @param inVector2Value - Initial value.
+     */
+    static create_vector2Value(vector2Value: Common.Vector2): ReplicatedValue {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_ReplicatedValue_Ctor_Vector2RC",
+        "void",
+        ["number", "number"],
+        [_ptr, vector2Value.pointer],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new ReplicatedValue(_nPtr);
+    }
+
     /**
      * @description Construct a ReplicatedValue based on a csp::common::Vector3 type.
      * @param inVector3Value - Initial value.
@@ -22883,6 +23275,40 @@ export namespace Multiplayer {
       return _result;
     }
 
+    /**
+     * @description Set a Vector2 value for this replicated value from a csp::common::Vector2, will overwrite and previous value.
+     */
+
+    setVector2(value: Common.Vector2): void {
+      Module.ccall(
+        "csp_multiplayer_ReplicatedValue_SetVector2_void_Vector2RC",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+
+    /**
+     * @description Get a csp::common::Vector2 value from this replicated value, will assert if not a csp::common::Vector2 type.
+     * /// Use ReplicatedValue::GetReplicatedValueType to ensure type before accessing.
+     * /// @return csp::common::Vector2
+     */
+
+    getVector2(): Common.Vector2 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_ReplicatedValue_GetVector2C_Vector2RC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Vector2(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
     /**
      * @description Set a Vector3 value for this replicated value from a csp::common::Vector3, will overwrite and previous value.
      */
@@ -33568,7 +33994,7 @@ export namespace Systems {
 
 export namespace Systems {
   /**
-   * @description Data structure for an Agora user token, giving userID, channel name and settings regarding sharing of audio/video/screenshare.
+   * @description Data structure for an Agora user token, giving userID, referenceID, channel name and settings regarding sharing of audio/video/screenshare.
    */
   export class AgoraUserTokenParams
     extends NativeClassWrapper
@@ -33645,6 +34071,26 @@ export namespace Systems {
       );
     }
 
+    get referenceId(): string {
+      let _result = Module.ccall(
+        "csp_systems_AgoraUserTokenParams__Get_ReferenceId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceId(value: string) {
+      Module.ccall(
+        "csp_systems_AgoraUserTokenParams__Set_ReferenceId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
     get lifespan(): number {
       let _result = Module.ccall(
         "csp_systems_AgoraUserTokenParams__Get_Lifespan",
@@ -36095,6 +36541,530 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  /**
+@ingroup CinematicCameraSpaceComponent
+ * @description Data representation of an CinematicCameraSpaceComponent.  
+ */
+  export class CinematicCameraSpaceComponent
+    extends Multiplayer.ComponentBase
+    implements
+      Multiplayer.IThirdPartyComponentRef,
+      Multiplayer.IPositionComponent,
+      Multiplayer.IRotationComponent,
+      Multiplayer.IEnableableComponent,
+      INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromComponentBase(
+      baseInstance: Multiplayer.ComponentBase,
+    ): Multiplayer.CinematicCameraSpaceComponent {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Multiplayer.CinematicCameraSpaceComponent(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    /**
+     * @description Constructs the CinematicCamera 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,
+    ): CinematicCameraSpaceComponent {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_Ctor_SpaceEntityP",
+        "void",
+        ["number", "number"],
+        [_ptr, parent.pointer],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new CinematicCameraSpaceComponent(_nPtr);
+    }
+
+    /**
+     * @description Gived the sensor size and focal length, return the horizonal fov
+     * @return FOV in degrees
+     */
+
+    getFov(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetFovC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * \addtogroup IPositionComponent  
+    @{
+    @copydoc IPositionComponent::GetPosition()
+     */
+
+    getPosition(): Common.Vector3 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_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_CinematicCameraSpaceComponent_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_CinematicCameraSpaceComponent_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_CinematicCameraSpaceComponent_SetRotation_void_Vector4RC",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+
+    /**
+    @}
+     * @description Get focal length  
+     * @return Current focal length
+     */
+
+    getFocalLength(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetFocalLengthC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set focalLength
+     * Note: Effects the result of GetFov()
+     * @param value - Focallength
+     */
+
+    setFocalLength(value: number): void {
+      assert(value >= Limits.FLOAT_MIN);
+      assert(value <= Limits.FLOAT_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetFocalLength_void_float",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Get Current aspect ratio
+     * @return Current aspect ratio
+     */
+
+    getAspectRatio(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetAspectRatioC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set Current aspect ratio
+     * @param value - Current aspect ratio
+     */
+
+    setAspectRatio(value: number): void {
+      assert(value >= Limits.FLOAT_MIN);
+      assert(value <= Limits.FLOAT_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetAspectRatio_void_float",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Get sensor size
+     * @return Current sensor size
+     */
+
+    getSensorSize(): Common.Vector2 {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetSensorSizeC_Vector2RC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.Vector2(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Set Current SensorSize
+     * @param value - Current SensorSize
+     */
+
+    setSensorSize(value: Common.Vector2): void {
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetSensorSize_void_Vector2RC",
+        "void",
+        ["number", "number"],
+        [this.pointer, value.pointer],
+      );
+    }
+
+    /**
+     * @description Get near clip
+     * Note: On platforms that don't support reversedZ, near clip should be used to control the clipping distance
+     * @return Current near clip
+     */
+
+    getNearClip(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetNearClipC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set near clip
+     * @param value - Near clip
+     */
+
+    setNearClip(value: number): void {
+      assert(value >= Limits.FLOAT_MIN);
+      assert(value <= Limits.FLOAT_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetNearClip_void_float",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Get far clip
+     * Note: On platforms that don't support reversedZ, far clip should be used to control the clipping distance
+     * @return Current far clip
+     */
+
+    getFarClip(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetFarClipC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set far clip
+     * Note: far clip, controls how the density increases and height decreases. Smaller values make the visible transition larger.
+     * @param value - Far clip
+     */
+
+    setFarClip(value: number): void {
+      assert(value >= Limits.FLOAT_MIN);
+      assert(value <= Limits.FLOAT_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetFarClip_void_float",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Get ISO sensitivity for controlling exposure.
+     * Note: reserved for future use, do not implement on clients
+     * @return Current iso
+     */
+
+    getIso(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetIsoC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set ISO sensitivity for controlling exposure.
+     * Note: reserved for future use, do not implement on clients
+     * @param value - ISO sensitivity for controlling exposure.
+     */
+
+    setIso(value: number): void {
+      assert(value >= Limits.FLOAT_MIN);
+      assert(value <= Limits.FLOAT_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetIso_void_float",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Get shutter speed.
+     * Note: reserved for future use, do not implement on clients
+     * @param value - Shutter speed
+     */
+
+    getShutterSpeed(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetShutterSpeedC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set shutter speed
+     * Note: reserved for future use, do not implement on clients
+     * @param value - Shutter speed
+     */
+
+    setShutterSpeed(value: number): void {
+      assert(value >= Limits.FLOAT_MIN);
+      assert(value <= Limits.FLOAT_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetShutterSpeed_void_float",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Get aperture.
+     * Note: reserved for future use, do not implement on clients
+     * @param value - Aperture
+     */
+
+    getAperture(): number {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetApertureC_float",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set aperture
+     * Note: reserved for future use, do not implement on clients
+     * @param value - Aperture flag
+     */
+
+    setAperture(value: number): void {
+      assert(value >= Limits.FLOAT_MIN);
+      assert(value <= Limits.FLOAT_MAX);
+
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetAperture_void_float",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * @description Get IsViewerCamera.
+     * Note: reserved for future use, do not implement on clients
+     * @param value - IsViewerCamera
+     */
+
+    getIsViewerCamera(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetIsViewerCameraC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Set IsViewerCamera
+     * Note: reserved for future use, do not implement on clients
+     * @param value - IsViewerCamera Flag
+     */
+
+    setIsViewerCamera(value: boolean): void {
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetIsViewerCamera_void_bool",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+     * \addtogroup IEnableableComponent  
+    @{
+    @copydoc IEnableableComponent::GetIsEnabled()
+     */
+
+    getIsEnabled(): boolean {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetIsEnabledC_bool",
+        "boolean",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+    @copydoc IEnableableComponent::SetIsEnabled()
+     */
+
+    setIsEnabled(value: boolean): void {
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetIsEnabled_void_bool",
+        "void",
+        ["number", "boolean"],
+        [this.pointer, value],
+      );
+    }
+
+    /**
+    @}
+     * \addtogroup IThirdPartyComponentRef  
+    @{
+    @copydoc IThirdPartyComponentRef::GetThirdPartyComponentRef()
+     */
+
+    getThirdPartyComponentRef(): string {
+      let _result = Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_GetThirdPartyComponentRefC_StringRC",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _resultString = Module.UTF8ToString(_result);
+      free(_result);
+
+      _result = _resultString;
+
+      return _result;
+    }
+
+    /**
+    @copydoc IThirdPartyComponentRef::SetThirdPartyComponentRef()
+     */
+
+    setThirdPartyComponentRef(value: string): void {
+      Module.ccall(
+        "csp_multiplayer_CinematicCameraSpaceComponent_SetThirdPartyComponentRef_void_StringRC",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_multiplayer_CinematicCameraSpaceComponent_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
 @ingroup CollisionSpaceComponent
@@ -39500,7 +40470,7 @@ export namespace Multiplayer {
 
     getUniqueComponentId(): string {
       let _result = Module.ccall(
-        "csp_multiplayer_HotspotSpaceComponent_GetUniqueComponentIdC_StringRC",
+        "csp_multiplayer_HotspotSpaceComponent_GetUniqueComponentIdC_String",
         "number",
         ["number"],
         [this.pointer],
@@ -47737,6 +48707,46 @@ export namespace Systems {
         this.disposed = true;
       }
     }
+
+    /**
+     * @description This will delete any groups which only contain this item
+     * For any groups which contanin the given item and additional items, it will just update the group by removing the given item.
+     * @param itemName - An item to update all sequences containing.
+     * @param callback - Callback to call when a response is received
+     */
+
+    async removeItemFromGroups(itemName: string): 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");
+
+      Module.ccall(
+        "csp_systems_HotspotSequenceSystem_RemoveItemFromGroups_void_StringRC_NullResultCallback",
+        "void",
+        ["number", "string", "number", "number"],
+        [this.pointer, itemName, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
   }
 }
 
@@ -49572,6 +50582,58 @@ export namespace Systems {
       return _promise;
     }
 
+    /**
+     * @description Finds all sequences that contain the given items
+     * @param items - An array of items which should be searched for
+     * @param referenceType - The type of reference (GroupId 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
+     */
+
+    async getAllSequencesContainingItems(
+      items: Common.Array<string>,
+      referenceType: string | null,
+      referenceIds: Common.Array<string>,
+    ): Promise<Systems.SequencesResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.SequencesResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.SequencesResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SequenceSystem_GetAllSequencesContainingItems_void_ArrayRC_StringRC_ArrayRC_SequencesResultCallback",
+        "void",
+        ["number", "number", "string", "number", "number", "number"],
+        [
+          this.pointer,
+          items.pointer,
+          referenceType,
+          referenceIds.pointer,
+          _callbackPtr,
+          0,
+        ],
+      );
+
+      return _promise;
+    }
+
     /**
      * @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 '%'