connected-spaces-platform.web 4.30.0 → 4.31.0

package/connectedspacesplatform.ts

@@ -3914,6 +3914,7 @@ export namespace Systems {
 export namespace Systems {
   export enum EPointOfInterestType {
     DEFAULT,
+    SPACE,
   }
 }
 
@@ -31919,6 +31920,26 @@ export namespace Systems {
         [this.pointer, value],
       );
     }
+
+    get spaceId(): string {
+      let _result = Module.ccall(
+        "csp_systems_PointOfInterest__Get_SpaceId",
+        "string",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    set spaceId(value: string) {
+      Module.ccall(
+        "csp_systems_PointOfInterest__Set_SpaceId",
+        "void",
+        ["number", "string"],
+        [this.pointer, value],
+      );
+    }
   }
 }
 
@@ -47655,8 +47676,8 @@ export namespace Systems {
     }
 
     /**
-     * @description Creates a new sequence. If a sequence already exists with this key, it will overwrite the current one. This call will fail if the user
-     * isn't a creator of the space.
+     * @description Creates a new sequence. If a sequence already exists with this key, it will overwrite the current one.
+     * This call will fail if the user isn't a creator of the space.
      * @param sequenceKey - The unique grouping name. The suggested convention is: Type:[Id]
      * @param referenceType - The type of reference (GroupId, SpaceId etc.)
      * @param referenceId - The id of the reference
@@ -47664,33 +47685,50 @@ export namespace Systems {
      * @param callback - Callback to call when a response is received
      */
 
-    createSequence(
+    async createSequence(
       sequenceKey: string,
       referenceType: string,
       referenceId: string,
       items: Common.Array<string>,
-      callback: (result: Systems.SequenceResult) => void,
-    ): void {
+    ): Promise<Systems.SequenceResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.SequenceResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
       var _callback = (_stateObject__: number, result) => {
-        var _result = new Systems.SequenceResult(getNativePointer(result));
-        callback(_result);
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.SequenceResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
       };
 
-      var callbackPtr = Module.addFunction(_callback, "vii");
+      _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
         "csp_systems_SequenceSystem_CreateSequence_void_StringRC_StringRC_StringRC_ArrayRC_SequenceResultCallback",
         "void",
-        ["number", "string", "string", "string", "number", "number"],
+        ["number", "string", "string", "string", "number", "number", "number"],
         [
           this.pointer,
           sequenceKey,
           referenceType,
           referenceId,
           items.pointer,
-          callbackPtr,
+          _callbackPtr,
+          0,
         ],
       );
+
+      return _promise;
     }
 
     /**
@@ -47702,33 +47740,50 @@ export namespace Systems {
      * @param callback - Callback to call when a response is received
      */
 
-    updateSequence(
+    async updateSequence(
       sequenceKey: string,
       referenceType: string,
       referenceId: string,
       items: Common.Array<string>,
-      callback: (result: Systems.SequenceResult) => void,
-    ): void {
+    ): Promise<Systems.SequenceResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.SequenceResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
       var _callback = (_stateObject__: number, result) => {
-        var _result = new Systems.SequenceResult(getNativePointer(result));
-        callback(_result);
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.SequenceResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
       };
 
-      var callbackPtr = Module.addFunction(_callback, "vii");
+      _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
         "csp_systems_SequenceSystem_UpdateSequence_void_StringRC_StringRC_StringRC_ArrayRC_SequenceResultCallback",
         "void",
-        ["number", "string", "string", "string", "number", "number"],
+        ["number", "string", "string", "string", "number", "number", "number"],
         [
           this.pointer,
           sequenceKey,
           referenceType,
           referenceId,
           items.pointer,
-          callbackPtr,
+          _callbackPtr,
+          0,
         ],
       );
+
+      return _promise;
     }
 
     /**
@@ -47738,24 +47793,40 @@ export namespace Systems {
      * @param callback - Callback to call when a response is received
      */
 
-    renameSequence(
+    async renameSequence(
       oldSequenceKey: string,
       newSequenceKey: string,
-      callback: (result: Systems.SequenceResult) => void,
-    ): void {
+    ): Promise<Systems.SequenceResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.SequenceResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
       var _callback = (_stateObject__: number, result) => {
-        var _result = new Systems.SequenceResult(getNativePointer(result));
-        callback(_result);
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.SequenceResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
       };
 
-      var callbackPtr = Module.addFunction(_callback, "vii");
+      _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
         "csp_systems_SequenceSystem_RenameSequence_void_StringRC_StringRC_SequenceResultCallback",
         "void",
-        ["number", "string", "string", "number"],
-        [this.pointer, oldSequenceKey, newSequenceKey, callbackPtr],
+        ["number", "string", "string", "number", "number"],
+        [this.pointer, oldSequenceKey, newSequenceKey, _callbackPtr, 0],
       );
+
+      return _promise;
     }
 
     /**
@@ -47767,33 +47838,50 @@ export namespace Systems {
      * @param callback - Callback to call when a response is received
      */
 
-    getSequencesByCriteria(
+    async getSequencesByCriteria(
       sequenceKeys: Common.Array<string>,
-      keyRegex: string,
-      referenceType: string,
+      keyRegex: string | null,
+      referenceType: string | null,
       referenceIds: Common.Array<string>,
-      callback: (result: Systems.SequencesResult) => void,
-    ): void {
+    ): Promise<Systems.SequencesResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.SequencesResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
       var _callback = (_stateObject__: number, result) => {
-        var _result = new Systems.SequencesResult(getNativePointer(result));
-        callback(_result);
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.SequencesResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
       };
 
-      var callbackPtr = Module.addFunction(_callback, "vii");
+      _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
         "csp_systems_SequenceSystem_GetSequencesByCriteria_void_ArrayRC_StringRC_StringRC_ArrayRC_SequencesResultCallback",
         "void",
-        ["number", "number", "string", "string", "number", "number"],
+        ["number", "number", "string", "string", "number", "number", "number"],
         [
           this.pointer,
           sequenceKeys.pointer,
           keyRegex,
           referenceType,
           referenceIds.pointer,
-          callbackPtr,
+          _callbackPtr,
+          0,
         ],
       );
+
+      return _promise;
     }
 
     /**
@@ -47802,23 +47890,37 @@ export namespace Systems {
      * @param callback - Callback to call when a response is received
      */
 
-    getSequence(
-      sequenceKey: string,
-      callback: (result: Systems.SequenceResult) => void,
-    ): void {
+    async getSequence(sequenceKey: string): Promise<Systems.SequenceResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.SequenceResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
       var _callback = (_stateObject__: number, result) => {
-        var _result = new Systems.SequenceResult(getNativePointer(result));
-        callback(_result);
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.SequenceResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
       };
 
-      var callbackPtr = Module.addFunction(_callback, "vii");
+      _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
         "csp_systems_SequenceSystem_GetSequence_void_StringRC_SequenceResultCallback",
         "void",
-        ["number", "string", "number"],
-        [this.pointer, sequenceKey, callbackPtr],
+        ["number", "string", "number", "number"],
+        [this.pointer, sequenceKey, _callbackPtr, 0],
       );
+
+      return _promise;
     }
 
     /**
@@ -47827,23 +47929,39 @@ export namespace Systems {
      * @param callback - Callback to call when a response is received
      */
 
-    deleteSequences(
+    async deleteSequences(
       sequenceKeys: Common.Array<string>,
-      callback: (result: Systems.NullResult) => void,
-    ): void {
+    ): Promise<Systems.NullResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.NullResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
       var _callback = (_stateObject__: number, result) => {
-        var _result = new Systems.NullResult(getNativePointer(result));
-        callback(_result);
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.NullResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
       };
 
-      var callbackPtr = Module.addFunction(_callback, "vii");
+      _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
         "csp_systems_SequenceSystem_DeleteSequences_void_ArrayRC_NullResultCallback",
         "void",
-        ["number", "number", "number"],
-        [this.pointer, sequenceKeys.pointer, callbackPtr],
+        ["number", "number", "number", "number"],
+        [this.pointer, sequenceKeys.pointer, _callbackPtr, 0],
       );
+
+      return _promise;
     }
   }
 }
@@ -52246,15 +52364,17 @@ export namespace Systems {
     }
 
     /**
-     * @description Retrieves an array with all the Points of Interest that are located inside the circular area defined by the parameters
-     * @param originLocation - Latitude and longitude coordinates of the circular area origin
-     * @param areaRadius - Radius of the circular area origin
-     * @param callback - Callback when asynchronous task finishes
+     * @description Retrieves an array with all the Points of Interest that are located inside the circular area defined by the parameters..
+     * @param originLocation - The latitude and longitude coordinates of origin of the search location.
+     * @param areaRadius - The Radius of the circular area to search around the provided origin.
+     * @param type - The type of POI to search for. If none is specified, all types will be included in the returned set.
+     * @param callback - Callback when asynchronous task finishes.
      */
 
     async getPOIsInArea(
       originLocation: Systems.GeoLocation,
       areaRadius: number,
+      type: Systems.EPointOfInterestType | null,
     ): Promise<Systems.POICollectionResult> {
       var _resolve;
 
@@ -52278,13 +52398,30 @@ export namespace Systems {
 
       _callbackPtr = Module.addFunction(_callback, "vii");
 
+      var typePointer = 0;
+      if (type != null) {
+        typePointer = Module._malloc(4);
+        Module.setValue(typePointer, type, "i32");
+      }
+
       Module.ccall(
-        "csp_systems_PointOfInterestSystem_GetPOIsInArea_void_GeoLocationRC_doubleC_POICollectionResultCallback",
+        "csp_systems_PointOfInterestSystem_GetPOIsInArea_void_GeoLocationRC_doubleC_EPointOfInterestTypeRC_POICollectionResultCallback",
         "void",
-        ["number", "number", "number", "number", "number"],
-        [this.pointer, originLocation.pointer, areaRadius, _callbackPtr, 0],
+        ["number", "number", "number", "number", "number", "number"],
+        [
+          this.pointer,
+          originLocation.pointer,
+          areaRadius,
+          typePointer,
+          _callbackPtr,
+          0,
+        ],
       );
 
+      if (typePointer) {
+        Module._free(typePointer);
+      }
+
       return _promise;
     }
   }
@@ -53607,13 +53744,52 @@ export namespace Systems {
       return _promise;
     }
 
+    /** @deprecated
+            Deprecated in favour of GetBasicProfilesByUserId
+    */
+
+    async getProfilesByUserId(
+      userIds: Common.Array<string>,
+    ): Promise<Systems.BasicProfilesResult> {
+      var _resolve;
+
+      var _promise = new Promise<Systems.BasicProfilesResult>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, result) => {
+        var _resultPtr = getNativePointer(result);
+        var _resultInstance = new Systems.BasicProfilesResult(_resultPtr);
+
+        if (_resultInstance.getResultCode() == Systems.EResultCode.InProgress) {
+          return;
+        }
+
+        _resolve(_resultInstance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_systems_UserSystem_GetProfilesByUserId_void_ArrayRC_BasicProfilesResultCallback",
+        "void",
+        ["number", "number", "number", "number"],
+        [this.pointer, userIds.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
     /**
      * @description Get a list of minimal profiles (avatarId, personalityType, userName, and platform) by user IDs.
      * @param inUserIds - An array of user ids to search for users by
      * @param callback - Callback to call when a response is received
      */
 
-    async getProfilesByUserId(
+    async getBasicProfilesByUserId(
       userIds: Common.Array<string>,
     ): Promise<Systems.BasicProfilesResult> {
       var _resolve;
@@ -53639,7 +53815,7 @@ export namespace Systems {
       _callbackPtr = Module.addFunction(_callback, "vii");
 
       Module.ccall(
-        "csp_systems_UserSystem_GetProfilesByUserId_void_ArrayRC_BasicProfilesResultCallback",
+        "csp_systems_UserSystem_GetBasicProfilesByUserId_void_ArrayRC_BasicProfilesResultCallback",
         "void",
         ["number", "number", "number", "number"],
         [this.pointer, userIds.pointer, _callbackPtr, 0],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "connected-spaces-platform.web",
   "displayName": "connected-spaces-platform.web",
-  "version": "4.30.0+522",
+  "version": "4.31.0+523",
   "description": "This package provides the binaries required to interface with the Connected Spaces Platform API.",
   "license": "Apache-2.0",
   "dependencies": {