connected-spaces-platform.web 6.9.0 → 6.10.0

package/connectedspacesplatform.ts

@@ -327,6 +327,11 @@ function NumberFactory(nativePointer: NativePointer): number {
 }
 ProxyClassFactories["Number"] = NumberFactory;
 
+function csp_EFeatureFlagFactory(nativePointer: NativePointer): EFeatureFlag {
+  return nativePointer.pointer as EFeatureFlag;
+}
+ProxyClassFactories["csp_EFeatureFlag"] = csp_EFeatureFlagFactory;
+
 function csp_common_EAssetChangeTypeFactory(
   nativePointer: NativePointer,
 ): Common.EAssetChangeType {
@@ -841,6 +846,14 @@ function csp_multiplayer_VideoPlayerSourceTypeFactory(
 ProxyClassFactories["csp_multiplayer_VideoPlayerSourceType"] =
   csp_multiplayer_VideoPlayerSourceTypeFactory;
 
+function csp_multiplayer_StereoVideoTypeFactory(
+  nativePointer: NativePointer,
+): Multiplayer.StereoVideoType {
+  return nativePointer.pointer as Multiplayer.StereoVideoType;
+}
+ProxyClassFactories["csp_multiplayer_StereoVideoType"] =
+  csp_multiplayer_StereoVideoTypeFactory;
+
 function csp_multiplayer_VideoPlayerPropertyKeysFactory(
   nativePointer: NativePointer,
 ): Multiplayer.VideoPlayerPropertyKeys {
@@ -1002,6 +1015,13 @@ function csp_systems_EThirdPartyAuthenticationProvidersFactory(
 ProxyClassFactories["csp_systems_EThirdPartyAuthenticationProviders"] =
   csp_systems_EThirdPartyAuthenticationProvidersFactory;
 
+function csp_FeatureFlagFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new FeatureFlag(nativePointer);
+}
+ProxyClassFactories["csp_FeatureFlag"] = csp_FeatureFlagFactory;
+
 function csp_ServiceDefinitionFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -1702,6 +1722,14 @@ function csp_common_SequenceChangedNetworkEventDataFactory(
 ProxyClassFactories["csp_common_SequenceChangedNetworkEventData"] =
   csp_common_SequenceChangedNetworkEventDataFactory;
 
+function csp_common_AsyncCallCompletedEventDataFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.AsyncCallCompletedEventData(nativePointer);
+}
+ProxyClassFactories["csp_common_AsyncCallCompletedEventData"] =
+  csp_common_AsyncCallCompletedEventDataFactory;
+
 function csp_multiplayer_OfflineRealtimeEngineFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -2686,6 +2714,18 @@ function csp_common_Array_csp_multiplayer_ComponentUpdateInfoFactory(
 ProxyClassFactories["csp_common_Array_csp_multiplayer_ComponentUpdateInfo"] =
   csp_common_Array_csp_multiplayer_ComponentUpdateInfoFactory;
 
+function csp_common_Array_csp_FeatureFlagFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.Array<FeatureFlag>(
+    nativePointer,
+    csp_FeatureFlagFactory,
+    "csp_FeatureFlag",
+  );
+}
+ProxyClassFactories["csp_common_Array_csp_FeatureFlag"] =
+  csp_common_Array_csp_FeatureFlagFactory;
+
 function csp_common_Array_csp_common_ReplicatedValueFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -3342,6 +3382,10 @@ function csp_common_Map_String_csp_common_Array_StringFactory(
 ProxyClassFactories["csp_common_Map_String_csp_common_Array_String"] =
   csp_common_Map_String_csp_common_Array_StringFactory;
 
+export enum EFeatureFlag {
+  Invalid = 0,
+}
+
 export namespace Common {
   /**
    * @description Enum specifying the type of change that occured to an asset.
@@ -4436,6 +4480,18 @@ export namespace Multiplayer {
   }
 }
 
+export namespace Multiplayer {
+  /**
+   * @description Enumerates the type of stereo the video player supports.
+   */
+  export enum StereoVideoType {
+    None = 0,
+    SideBySide,
+    TopBottom,
+    Num,
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Enumerates the list of properties that can be replicated for a video player component.
@@ -4462,6 +4518,7 @@ export namespace Multiplayer {
     MeshComponentId,
     IsEnabled,
     IsVirtualVisible,
+    StereoVideoType,
     Num,
   }
 }
@@ -4632,6 +4689,7 @@ export namespace Systems {
     OpenAI,
     Shopify,
     TicketedSpace,
+    GoogleGenAI,
     Invalid,
   }
 }
@@ -5013,6 +5071,101 @@ export namespace Systems {
   }
 }
 
+export class FeatureFlag extends NativeClassWrapper implements INativeResource {
+  /** @internal */
+  constructor(pointer: NativePointer) {
+    super(pointer);
+  }
+
+  static create(): FeatureFlag {
+    var _ptr = Module._malloc(8);
+    Module.ccall("csp_FeatureFlag_Ctor", "void", ["number"], [_ptr]);
+    var _nPtr = getNativePointer(_ptr);
+
+    return new FeatureFlag(_nPtr);
+  }
+
+  static create_type_isEnabled(
+    type: EFeatureFlag,
+    isEnabled: boolean,
+  ): FeatureFlag {
+    var _ptr = Module._malloc(8);
+    Module.ccall(
+      "csp_FeatureFlag_Ctor_EFeatureFlag_bool",
+      "void",
+      ["number", "number", "boolean"],
+      [_ptr, type, isEnabled],
+    );
+    var _nPtr = getNativePointer(_ptr);
+
+    return new FeatureFlag(_nPtr);
+  }
+
+  getDescription(): string {
+    let _result = Module.ccall(
+      "csp_FeatureFlag_GetDescription_StringRC",
+      "number",
+      ["number"],
+      [this.pointer],
+    );
+
+    const _resultString = Module.UTF8ToString(_result);
+    free(_result);
+
+    _result = _resultString;
+
+    return _result;
+  }
+
+  delete(): void {
+    if (this.ownsPointer && !this.disposed) {
+      Module.ccall("csp_FeatureFlag_Dtor", "void", ["number"], [this.pointer]);
+
+      this.disposed = true;
+    }
+  }
+
+  get type(): EFeatureFlag {
+    let _result = Module.ccall(
+      "csp_FeatureFlag__Get_Type",
+      "number",
+      ["number"],
+      [this.pointer],
+    );
+
+    return _result;
+  }
+
+  set type(value: EFeatureFlag) {
+    Module.ccall(
+      "csp_FeatureFlag__Set_Type",
+      "void",
+      ["number", "number"],
+      [this.pointer, value],
+    );
+  }
+
+  get enabled(): boolean {
+    let _result = Module.ccall(
+      "csp_FeatureFlag__Get_Enabled",
+      "boolean",
+      ["number"],
+      [this.pointer],
+    );
+
+    return _result;
+  }
+
+  set enabled(value: boolean) {
+    Module.ccall(
+      "csp_FeatureFlag__Set_Enabled",
+      "void",
+      ["number", "boolean"],
+      [this.pointer, value],
+    );
+  }
+}
+
 /**
  * @description Represents definition for identifying and versioning an external service endpoint.
  */
@@ -5460,6 +5613,9 @@ export class CSPFoundation {
    * @param tenant - Tenant for Magnopus Services. Data is not shared between tenants so clients using separate tenants
    * cannot interact with each other.
    * @param clientUserAgentHeader - The Client Info data
+   * @param featureFlagOverrides - Optional list of feature flags whose default
+   * enabled state is to be overriden. The FeatureFlag.Description property can be ignored when passing in feature flags here as this is defined by
+   * the developer who creates the flag.
    * @return True for successful initialisation.
    */
 
@@ -5467,12 +5623,18 @@ export class CSPFoundation {
     endpointRootURI: string,
     tenant: string,
     clientUserAgentHeader: ClientUserAgent,
+    featureFlagOverrides: Common.Array<FeatureFlag>,
   ): boolean {
     let _result = Module.ccall(
-      "csp_CSPFoundation_Initialise_bool_StringRC_StringRC_ClientUserAgentRC",
+      "csp_CSPFoundation_Initialise_bool_StringRC_StringRC_ClientUserAgentRC_ArrayRC",
       "boolean",
-      ["string", "string", "number"],
-      [endpointRootURI, tenant, clientUserAgentHeader.pointer],
+      ["string", "string", "number", "number"],
+      [
+        endpointRootURI,
+        tenant,
+        clientUserAgentHeader.pointer,
+        featureFlagOverrides.pointer,
+      ],
     );
 
     return _result;
@@ -5710,6 +5872,69 @@ export class CSPFoundation {
 
     return _result;
   }
+
+  /**
+   * @description Checks if a given feature flag is enabled.
+   * @param flag - The feature flag to check
+   * @return True if the feature flag is enabled, false otherwise
+   */
+
+  static isFeatureEnabled(flag: EFeatureFlag): boolean {
+    let _result = Module.ccall(
+      "csp_CSPFoundation_IsFeatureEnabled_bool_EFeatureFlag",
+      "boolean",
+      ["number"],
+      [flag],
+    );
+
+    return _result;
+  }
+
+  /**
+   * @description Returns an array of feature flags.
+   * @return An array of the defined feature flags
+   */
+
+  static getFeatureFlags(): Common.Array<FeatureFlag> {
+    var _ret = Module._malloc(8);
+
+    Module.ccall(
+      "csp_CSPFoundation_GetFeatureFlags_ArrayRC",
+      "void",
+      ["number"],
+      [_ret],
+    );
+    var _nPtr = new Common.Array<FeatureFlag>(
+      getNativePointer(_ret),
+      csp_FeatureFlagFactory,
+      "csp_FeatureFlag",
+    );
+    Module._free(_ret);
+
+    return _nPtr;
+  }
+
+  /**
+   * @description Get the description of a feature flag.
+   * @param flag - The feature flag whose description is to be retrieved
+   * @return The description of the feature flag
+   */
+
+  static getFeatureFlagDescription(flag: EFeatureFlag): string {
+    let _result = Module.ccall(
+      "csp_CSPFoundation_GetFeatureFlagDescription_String_EFeatureFlag",
+      "number",
+      ["number"],
+      [flag],
+    );
+
+    const _resultString = Module.UTF8ToString(_result);
+    free(_result);
+
+    _result = _resultString;
+
+    return _result;
+  }
 }
 
 export namespace Common {
@@ -27518,9 +27743,13 @@ export namespace Systems {
 
 export namespace Systems {
   /**
-   * @description Base class for all Connected Spaces Platform Systems, which enforces passing of a WebClient or NetworkEventBus instance in the constructor
-   * of each System.
-   */
+ * @description Base class for all Connected Spaces Platform Systems, which enforces passing of a WebClient or NetworkEventBus instance in the constructor  
+ * of each System.  
+@invariant EventBusPtr can never be null. The NetworkEventBus is owned by the MultiplayerConnection and persists for it's lifetime. It is passed
+ * to each system (which derive from SystemBase) by reference to their ctor. This ref is dereferenced before being passed to the SystemBase ctor.  
+@invariant LogSystem can never be null. The LogSystem is owned by the SystemsManager and persists for it's lifetime. It is passed to
+ * each system (which derive from SystemBase) by reference to their ctor. This ref is dereferenced before being passed to the SystemBase ctor.  
+ */
   export class SystemBase extends NativeClassWrapper {
     /** @internal */
     constructor(pointer: NativePointer) {
@@ -27543,19 +27772,6 @@ export namespace Systems {
         [this.pointer],
       );
     }
-
-    /**
-     * @description Deregisters the system from listening for the default event.
-     */
-
-    deregisterSystemCallback(): void {
-      Module.ccall(
-        "csp_systems_SystemBase_DeregisterSystemCallback_void",
-        "void",
-        ["number"],
-        [this.pointer],
-      );
-    }
   }
 }
 
@@ -35261,6 +35477,116 @@ export namespace Common {
   }
 }
 
+export namespace Common {
+  export class AsyncCallCompletedEventData
+    extends Common.NetworkEventData
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    static fromNetworkEventData(
+      baseInstance: Common.NetworkEventData,
+    ): Common.AsyncCallCompletedEventData {
+      const nativeClassWrapper = baseInstance as unknown as NativeClassWrapper;
+      return new Common.AsyncCallCompletedEventData(
+        new NativePointer(
+          nativeClassWrapper.pointer,
+          nativeClassWrapper.ownsPointer,
+        ),
+      );
+    }
+
+    static create(): AsyncCallCompletedEventData {
+      var _ptr = Module._malloc(8);
+      Module.ccall(
+        "csp_common_AsyncCallCompletedEventData_Ctor",
+        "void",
+        ["number"],
+        [_ptr],
+      );
+      var _nPtr = getNativePointer(_ptr);
+
+      return new AsyncCallCompletedEventData(_nPtr);
+    }
+
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_common_AsyncCallCompletedEventData_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    get operationName(): string {
+      let _result = Module.ccall(
+        "csp_common_AsyncCallCompletedEventData__Get_OperationName",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set operationName(value: string) {
+      Module.ccall(
+        "csp_common_AsyncCallCompletedEventData__Set_OperationName",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceId(): string {
+      let _result = Module.ccall(
+        "csp_common_AsyncCallCompletedEventData__Get_ReferenceId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceId(value: string) {
+      Module.ccall(
+        "csp_common_AsyncCallCompletedEventData__Set_ReferenceId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+
+    get referenceType(): string {
+      let _result = Module.ccall(
+        "csp_common_AsyncCallCompletedEventData__Get_ReferenceType",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set referenceType(value: string) {
+      Module.ccall(
+        "csp_common_AsyncCallCompletedEventData__Set_ReferenceType",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Class for creating and managing objects in an offline context.
@@ -47565,6 +47891,36 @@ export namespace Multiplayer {
       );
     }
 
+    /**
+     * @description Gets the type of stereo the video of this component uses.
+     * @return The type of stereo used by this video.
+     */
+
+    getStereoVideoType(): Multiplayer.StereoVideoType {
+      let _result = Module.ccall(
+        "csp_multiplayer_VideoPlayerSpaceComponent_GetStereoVideoTypeC_StereoVideoType",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Sets the type of stereo the video of this component uses.
+     * @param value - The type of stereo used by this video.
+     */
+
+    setStereoVideoType(value: Multiplayer.StereoVideoType): void {
+      Module.ccall(
+        "csp_multiplayer_VideoPlayerSpaceComponent_SetStereoVideoType_void_StereoVideoType",
+        "void",
+        ["number", "number"],
+        [this.pointer, value],
+      );
+    }
+
     /**
      * \addtogroup IVisibleComponent  
     @{
@@ -51235,19 +51591,6 @@ export namespace Systems {
         [this.pointer],
       );
     }
-
-    /**
-     * @description Deregisters the system from listening for the named event.
-     */
-
-    deregisterSystemCallback(): void {
-      Module.ccall(
-        "csp_systems_AssetSystem_DeregisterSystemCallback_void",
-        "void",
-        ["number"],
-        [this.pointer],
-      );
-    }
   }
 }
 
@@ -54122,7 +54465,7 @@ export namespace Systems {
     ): HotspotSequenceSystem {
       var _ptr = Module._malloc(8);
       Module.ccall(
-        "csp_systems_HotspotSequenceSystem_Ctor_SequenceSystemP_SpaceSystemP_NetworkEventBusP_LogSystemR",
+        "csp_systems_HotspotSequenceSystem_Ctor_SequenceSystemP_SpaceSystemP_NetworkEventBusR_LogSystemR",
         "void",
         ["number", "number", "number", "number", "number"],
         [
@@ -54476,19 +54819,6 @@ export namespace Systems {
         [this.pointer],
       );
     }
-
-    /**
-     * @description Deregisters the system from listening for the named event.
-     */
-
-    deregisterSystemCallback(): void {
-      Module.ccall(
-        "csp_systems_HotspotSequenceSystem_DeregisterSystemCallback_void",
-        "void",
-        ["number"],
-        [this.pointer],
-      );
-    }
   }
 }
 
@@ -55997,19 +56327,6 @@ export namespace Systems {
         [this.pointer],
       );
     }
-
-    /**
-     * @description Deregisters the system from listening for the named event.
-     */
-
-    deregisterSystemCallback(): void {
-      Module.ccall(
-        "csp_systems_SequenceSystem_DeregisterSystemCallback_void",
-        "void",
-        ["number"],
-        [this.pointer],
-      );
-    }
   }
 }
 
@@ -59684,14 +60001,19 @@ export namespace Systems {
     }
 
     /**
-     * @description Duplicate an existing space and assign it to the current user
+     * @description Duplicate an existing space and assign it to the current user.
+     * This is a synchronous operation and can have a high execution time for complex spaces. If the user disconnects while waiting for the operation
+     * to complete, the duplicate space request will be cancelled.
+     * \deprecated Use DuplicateSpaceAsync() instead. This method performs a synchronous duplication of a Space which can timeout and fail for
+     * complex Spaces or if the backend services are under excessive load.
      * @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 memberGroupIds - An optional array of group (space) IDs. Members of these groups will be added
+     * to the duplicated space with the same roles.
      * @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
+     * @param callback - Callback when asynchronous task finishes.
      */
 
     async duplicateSpace(
@@ -59750,6 +60072,106 @@ export namespace Systems {
 
       return _promise;
     }
+
+    /**
+     * @description Duplicate an existing space and assign it to the current user.
+     * This is an asynchronous operation. If the user disconnects while waiting for the operation to complete it will continue unaffected. Please
+     * subcribe to the AsyncCallCompletedCallback via @ref SpaceSystem::SetAsyncCallCompletedCallback() to be notified when the duplication operation
+     * is complete. The AsyncCallCompletedEventData returned by the AsyncCallCompletedCallback will contain the following information:
+     * - OperationName: "DuplicateSpaceAsync".
+     * - ReferenceId: Id of the newly duplicated Space.
+     * - ReferenceType: "GroupId".
+     * @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. Members of these groups will be added
+     * to the duplicated space with the same roles.
+     * @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 is successfully received by the backend services.
+     */
+
+    async duplicateSpaceAsync(
+      spaceId: string,
+      newName: string,
+      newAttributes: Systems.SpaceAttributes,
+      memberGroupIds: Common.Array<string> | null,
+      shallowCopy: boolean,
+    ): 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_SpaceSystem_DuplicateSpaceAsync_void_StringRC_StringRC_SpaceAttributes_ArrayRC_bool_NullResultCallback",
+        "void",
+        [
+          "number",
+          "string",
+          "string",
+          "number",
+          "number",
+          "boolean",
+          "number",
+          "number",
+        ],
+        [
+          this.pointer,
+          spaceId,
+          newName,
+          newAttributes,
+          memberGroupIds != null ? memberGroupIds.pointer : 0,
+          shallowCopy,
+          _callbackPtr,
+          0,
+        ],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Sets a callback for the async call completed event. Triggered when an async call to DuplicateSpace is completed.
+     * @param callback - Callback to receive data concerning the Space duplication.
+     */
+    setAsyncCallCompletedCallback(
+      callback: (arg1: Common.AsyncCallCompletedEventData) => void,
+    ) {
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1 = new Common.AsyncCallCompletedEventData(
+          getNativePointer(arg1),
+        );
+
+        callback(_arg1);
+      };
+
+      var _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_SpaceSystem_SetAsyncCallCompletedCallback_void_AsyncCallCompletedCallbackHandler",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+    }
   }
 }
 
@@ -62660,19 +63082,6 @@ export namespace Systems {
         [this.pointer],
       );
     }
-
-    /**
-     * @description Deregisters the system from listening for the named event.
-     */
-
-    deregisterSystemCallback(): void {
-      Module.ccall(
-        "csp_systems_UserSystem_DeregisterSystemCallback_void",
-        "void",
-        ["number"],
-        [this.pointer],
-      );
-    }
   }
 }
 
@@ -62710,6 +63119,24 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_FeatureFlag(): Array<FeatureFlag> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Ctor_csp_FeatureFlag",
+        "void",
+        ["number"],
+        [_ret],
+      );
+      var _inst = new Array<FeatureFlag>(
+        getNativePointer(_ret),
+        csp_FeatureFlagFactory,
+        "csp_FeatureFlag",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_common_ReplicatedValue(): Array<Common.ReplicatedValue> {
       var _ret = Module._malloc(8);
       Module.ccall(
@@ -63489,6 +63916,24 @@ export namespace Common {
       return _inst;
     }
 
+    static ofcsp_FeatureFlag_number(size: number): Array<FeatureFlag> {
+      var _ret = Module._malloc(8);
+      Module.ccall(
+        "csp_common_Array_Conv_size_tC_csp_FeatureFlag",
+        "void",
+        ["number", "number"],
+        [_ret, size],
+      );
+      var _inst = new Array<FeatureFlag>(
+        getNativePointer(_ret),
+        csp_FeatureFlagFactory,
+        "csp_FeatureFlag",
+      );
+      Module._free(_ret);
+
+      return _inst;
+    }
+
     static ofcsp_common_ReplicatedValue_number(
       size: number,
     ): Array<Common.ReplicatedValue> {